mhc 1.0.0

data/lib/mhc/logger.rb

@@ -0,0 +1,94 @@
+module Mhc
+  ################################################################
+  # Log maintenance functions.
+  #
+  #  M 2000-04-25 00:06:08 <20.nom@.nomcom> ~nom/Mail/schedule/2000/04/1 Luncheon
+  #  D 2000-04-25 00:06:08 <20.nom@.nomcom> ~nom/Mail/schedule/2000/04/1 Luncheon
+  #  S 2000-04-25 00:06:08 user_id
+  #
+  class Logger
+    def initialize(filename)
+      @filename = filename
+    end
+
+    def add_entry(entry)
+      file = File.open(@filename, "a+")
+      file.print "#{entry}\n"
+      file.fsync if file.respond_to?("fsync")
+      file.close
+    end
+
+    def each_entry
+      begin
+        file = File.open(@filename)
+        while line = file.gets
+          yield(LogEntry.new(line.chomp))
+        end
+        file.close
+      rescue
+      end
+    end
+
+    def entries()
+      arry = []
+      each_entry{|e|
+        arry << e
+      }
+      return arry
+    end
+
+    def shrink_entries(user_id)
+      hash = {}
+      each_entry{|e|
+        if e.status == 'S' and e.rec_id == user_id
+          hash.clear
+        else
+          hash[e.rec_id] = e
+        end
+      }
+      return hash.values
+    end
+  end
+
+  class LogEntry
+    attr :status
+    attr :mtime
+    attr :rec_id
+    attr :path
+    attr :subject
+
+    def initialize(status, mtime = nil, rec_id = nil, path = nil, subject = nil)
+      if mtime.nil?
+        init_from_string(status)
+      else
+        @status, @mtime, @rec_id, @path, @subject =
+          status, mtime, rec_id, path, subject
+      end
+    end
+
+    def to_s
+      return [
+        @status,
+        @mtime.strftime("%Y-%m-%d %H:%M:%S"),
+        @rec_id,
+        @path,
+        @subject
+      ].join(' ')
+    end
+
+    ################
+    private
+    ################
+    def init_from_string(line)
+      str = line.chomp
+      status, yymmdd, hhmmss, rec_id, path, subject = str.split
+      yy, mm, dd = yymmdd.split('-')
+      h,  m,  s  = hhmmss.split(':')
+
+      mtime = Time.local(yy.to_i, mm.to_i, dd.to_i,
+                          h .to_i, m .to_i, s .to_i)
+      @status, @mtime, @rec_id, @path, @subject =
+        status, mtime, rec_id, path, subject
+    end
+  end
+end

data/lib/mhc/modifier.rb

@@ -0,0 +1,149 @@
+module Mhc
+  class Modifier
+    class ParseError < StandardError; end
+
+    attr_accessor :name
+
+    def initialize(name)
+      @name = name
+    end
+
+    def to_s
+      @name.to_s
+    end
+
+    def decorate(event)
+      if deco = Decorator.find_subclass(@name.to_sym)
+        deco.new(event)
+      else
+        raise Mhc::Modifier::ParseError, "Unknown Decorator #{@name}"
+      end
+    end
+
+    class Decorator
+      require 'forwardable'
+      extend Forwardable
+
+      def_delegators :@event,
+      :path,
+      :alarm,
+      :categories,
+      :description,
+      :body,
+      :location,
+      :priority,
+      :record_id,
+      :occurrences,
+      :uid,
+      :subject,
+      :dates,
+      :exceptions,
+      :time_range,
+      :duration,
+      :recurrence_condition,
+      :recurrence_tag,
+      :mission_tag,
+      :sequence,
+#      :occurrences,
+      :dtstart,
+      :dtend,
+      :rdates,
+      :exdates,
+      :etag,
+      :recurring?,
+      :allday?
+
+      def self.find_subclass(snake_name)
+        @subclasses ||= {}
+
+        if c = @subclasses[snake_name]
+          return c
+        end
+
+        class_name = snake_name.to_s.capitalize.gsub(/_([a-z\d]+)/){ $1.capitalize }.to_sym
+        return nil unless const_defined?(class_name)
+
+        const = const_get(class_name)
+        if const.class == Class and const.superclass == self
+          return @subclasses[snake_name] = const
+        end
+        return nil
+      end
+
+      def initialize(event)
+        @event = event
+      end
+
+      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
+
+      def occurrences(range:nil)
+        Mhc::OccurrenceEnumerator.new(self, dates, exceptions, recurrence_condition, duration, range)
+      end
+
+      class HideDetails < Decorator
+        def subject
+          return Mhc::PropertyValue::Text.new.parse("BUSY")
+        end
+
+        def location
+          return nil
+        end
+
+        def description
+          return nil
+        end
+        alias_method :body, :description
+
+      end # class HideDetails
+
+
+      class HideDescription < Decorator
+
+        def description
+          return nil
+        end
+
+        alias_method :body, :description
+
+      end # class HideDescription
+
+
+      class HideLocation < Decorator
+        def location
+          return nil
+        end
+      end # class HideLocation
+
+
+      class HideTimeRange <  Decorator
+        def allday?
+          return true
+        end
+
+        def time_range
+          # create empty time_range
+          Mhc::PropertyValue::Range.new(Mhc::PropertyValue::Time)
+        end
+      end # class HideTimeRange
+
+      class ReplaceSubjectByCategory < Decorator
+        def subject
+          categories = @event.categories
+          return "BUSY" if categories.empty?
+          return categories.first.to_s.capitalize
+        end
+      end # class ReplaceSubjectByCategory
+
+    end # class Decorator
+  end # class Modifier
+end # module Mhc

data/lib/mhc/occurrence.rb

@@ -0,0 +1,94 @@
+require 'forwardable'
+
+module Mhc
+  class Occurrence
+    include Comparable
+    extend Forwardable
+
+    def_delegators :@event,
+    :path,
+    :alarm,
+    :categories,
+    :description,
+    :body,
+    :location,
+    :priority,
+    :record_id,
+    :uid,
+    :subject,
+    :time_range,
+    :recurrence_tag,
+    :mission_tag,
+    :allday?
+
+    attr_reader :event
+
+    def initialize(event, date_range)
+      @event = event
+
+      if date_range.respond_to?(:first)
+        @start_date = date_range.first
+        @end_date   = date_range.last
+      else
+        @start_date = date_range
+        @end_date   = date_range
+      end
+    end
+
+    def date
+      @start_date
+    end
+
+    def dtstart
+      if allday?
+        @start_date
+      else
+        time_range.first.to_datetime(@start_date)
+      end
+    end
+
+    def dtend
+      if allday?
+        @end_date + 1
+      else
+        time_range.last.to_datetime(@end_date)
+      end
+    end
+
+    def first
+      @start_date
+    end
+
+    def last
+      @end_date
+    end
+
+    def days
+      @end_date - @start_date + 1
+    end
+
+    def oneday?
+      @start_date == @end_date
+    end
+
+    def to_mhc_string
+      if allday?
+        return "#{dtstart.to_mhc_string}" if oneday?
+        return "#{@start_date.to_mhc_string}-#{@end_date.to_mhc_string}"
+      else
+        return dtstart.strftime("%Y%m%d %H:%m-") + ((@start_date == @end_date) ? dtend.strftime("%H:%m") : dtend.strftime("%Y%m%dT%H:%m"))
+      end
+    end
+
+    alias_method :to_s, :to_mhc_string
+
+    def <=>(o)
+      if o.respond_to?(:dtstart)
+        return self.dtstart <=> o.dtstart
+      else
+        return self.dtstart <=> o
+      end
+    end
+
+  end # class Occurrence
+end # module Mhc

data/lib/mhc/occurrence_enumerator.rb

@@ -0,0 +1,113 @@
+module Mhc
+  class OccurrenceEnumerator
+    include Enumerable
+    # ; The FREQ rule part is REQUIRED,
+    # ; but MUST NOT occur more than once.
+    #
+    # FREQ       = (DAILY|WEEKLY|MONTHLY|YEARLY)
+    #
+    # ; The UNTIL or COUNT rule parts are OPTIONAL,
+    # ; but they MUST NOT occur in the same 'recur'.
+    #
+    # UNTIL      = (date|date-time)
+    # COUNT      = \d+
+    #
+    # ; The other rule parts are OPTIONAL,
+    # ; but MUST NOT occur more than once.
+    #
+    # INTERVAL   = \d+ # positive value default is 1
+    # BYDAY      = ([+-]\d{1,2})?(SU|MO|TU|WE|TH|FR|SA),... # 1 to 53
+    # BYMONTHDAY = [+-]\d{1,2},...   # 1 to 31
+    # BYYEARDAY  = [+-]\d{1,3},...   # 1 to 366
+    # BYWEEKNO   = [+-]\d{1,3},...   # 1 to 53
+    # BYMONTH    = \d{1,2},...       # 1 to 12
+    # BYSETPOS   = [+-]\d+,...       # 1 to 366
+    # WKST       = (SU|MO|TU|WE|TH|FR|SA)
+    #
+    def initialize(event, dates, exceptions, recurrence_condition, duration, date_range = nil)
+      @event = event
+
+      # Since some articles with RECURRENCE_CONDITION and without DURATION
+      # makes infinit entries, we have to clip the range by some artificial values
+      # It will make 101 enum entries from 1970-1-1 to now+50 years:
+      #
+      #   X-SC-Subject: New Year's Day
+      #   X-SC-Cond: Jan 1
+      #
+      date_range = (Date.new(1970, 1, 1) .. Date.new(Date.today.year + 50)) unless date_range
+
+      # If we have both DURATION and RANGE, we can take narrower term
+      # by the combination of the both.
+      date_range = duration.narrow(date_range.first, date_range.last)
+
+      # range.last is effective in narrowing the end_date,
+      # however, we can't adopt range.first to the start_date.
+      # Original start_date derived from DURATION is required for calculating
+      # the start point of recurrence loop in case the
+      # loop interval is larger than one.
+      #
+      # At moment, we will have over-scanning entries even if the range.first
+      # is set narrower than duration.first
+      #
+      # we need some good way to pass the both duration.first and range.first
+      # to the down-stream enumerators.
+      #
+      end_date   = date_range.last
+      start_date = duration.first || date_range.first
+
+      @enumerator = Mhc::DateEnumerator.new(start_date: start_date, end_date: date_range.last)
+      condition_to_enumerator(@enumerator, recurrence_condition, start_date, date_range.last)
+      @enumerator.add_by_range_list(range_list: dates)
+      @exceptions = exceptions.map{|range| range.to_a }.flatten
+      @date_range = date_range
+    end
+
+    def each
+      @enumerator.each do |date_or_range|
+        if date_or_range.respond_to?(:first)
+          first_date = date_or_range.first
+          last_date  = date_or_range.last
+        else
+          first_date = date_or_range
+          last_date  = date_or_range
+        end
+        if last_date < @date_range.first or @date_range.last < first_date
+          next
+        end
+        next if @exceptions.include?(first_date)
+        yield Mhc::Occurrence.new(@event, date_or_range)
+      end
+    end
+
+    private
+
+    def condition_to_enumerator(enumerator, cond, start_date, end_date)
+      if cond.yearly?
+        cond.cond_mon.each do |mon|
+          cond.cond_ord.each do |ord|
+            cond.cond_wek.each do |wek|
+              enumerator.add_yearly_by_day(month: mon, nth: ord, wday: wek)
+            end
+          end
+          cond.cond_num.each do |num|
+            enumerator.add_yearly_by_monthday(month: mon, mday: num)
+          end
+        end
+      elsif cond.monthly?
+        cond.cond_ord.each do |ord|
+          cond.cond_wek.each do |wek|
+            enumerator.add_monthly_by_day(nth: ord, wday: wek)
+          end
+        end
+        cond.cond_num.each do |num|
+          enumerator.add_monthly_by_monthday(mday: num)
+        end
+      elsif cond.weekly?
+        cond.cond_wek.each do |wek|
+          enumerator.add_weekly(wday: wek)
+        end
+      end
+      return enumerator
+    end
+  end # class OccurrenceEnumerator
+end # module Mhc