mhc 1.0.0

data/lib/mhc/property_value.rb

@@ -0,0 +1,33 @@
+module Mhc
+  module PropertyValue
+    class ParseError < StandardError; end
+    class Base
+      def self.parse(string)
+        return self.new.parse(string)
+      end
+
+      def parse(string)
+        @value = string
+        return self
+      end
+
+      def to_mhc_string
+        return @value.to_s
+      end
+
+      alias_method :to_s, :to_mhc_string
+    end
+
+    dir = File.dirname(__FILE__) + "/property_value"
+
+    autoload :Date,                "#{dir}/date.rb"
+    autoload :Integer,             "#{dir}/integer.rb"
+    autoload :List,                "#{dir}/list.rb"
+    autoload :Period,              "#{dir}/period.rb"
+    autoload :Range,               "#{dir}/range.rb"
+    autoload :RecurrenceCondition, "#{dir}/recurrence_condition.rb"
+    autoload :Text,                "#{dir}/text.rb"
+    autoload :Time,                "#{dir}/time.rb"
+
+  end # modlue PropertyValue
+end # module Mhc

data/lib/mhc/property_value/date.rb

@@ -0,0 +1,190 @@
+# -*- coding: utf-8 -*-
+
+require "date"
+
+module Mhc
+  module PropertyValue
+    class Date < ::Date
+
+      DAYS_OF_MONTH = [0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]
+
+      def self.parse(string)
+        if /^(\d{4})(\d{2})(\d{2})$/ =~ string
+          # don't use super(string) because it's slow.
+          new($1.to_i, $2.to_i, $3.to_i)
+        else
+          return nil # raise ParseError
+        end
+      end
+
+      def self.parse_relative(date_string)
+        case (date_string.downcase)
+        when 'today'
+          return self.today
+
+        when 'tomorrow'
+          return self.today.succ
+
+        when /^\d{8}$/
+          return self.parse(date_string)
+
+        when /^\d{6}$/
+          return self.parse(date_string + '01')
+
+        when /^thismonth$/
+          return self.today.first_day_of_month
+
+        when /^nextmonth$/
+          return self.today.first_day_of_month.next_month
+
+        else
+          raise ParseError, "invalid date string '#{date_string}'"
+        end
+      end
+
+      def self.parse_range(range_string)
+        case range_string
+        # yyyymmdd-yyyymmdd
+        when /^([^+-]+)-([^+-]+)$/
+          return parse_relative($1)..parse_relative($2)
+
+        # yyyymmdd+2w
+        when /^([^+-]+)\+(\d+)([dwm])$/
+          date = parse_relative($1)
+          return date..date.succ_by($3, $2.to_i).prev_day
+
+        when /^(thismonth|nextmonth|\d{6})$/
+          date = parse_relative($1)
+          return date..date.last_day_of_month
+
+        when /^([^+-]+)$/
+          date = parse_relative($1)
+          return date..date
+        else
+          raise ParseError, "invalid date range string '#{range_string}'"
+        end
+      end
+
+      def succ_by(unit = :d, number = 1)
+        case unit.to_sym
+        when :d
+          return self + number.to_i
+        when :w
+          return self + (number.to_i * 7)
+        when :m
+          return self >> number.to_i
+        end
+      end
+
+      def parse(string)
+        if /^\d{8}$/ =~ string
+          self.class.parse(string)
+        else
+          return nil # raise ParseError
+        end
+      end
+
+      def add_time(time = nil)
+        if time
+          return ::Time.local(year, month, mday, time.hour, time.minute)
+        else
+          return ::Time.local(year, month, mday, 0, 0)
+        end
+      end
+
+      def to_mhc_string
+        return strftime("%Y%m%d")
+      end
+      alias_method :to_s, :to_mhc_string
+
+      def last_week_of_month?
+        return mday > days_of_month - 7
+      end
+
+      def week_number_of_month
+        return (mday - 1) / 7 + 1
+      end
+
+      def days_of_month
+        return DAYS_OF_MONTH[month] + (month == 2 && leap? ? 1 : 0)
+      end
+
+      def first_day_of_month
+        return self.class.new(year, month, 1)
+      end
+
+      def last_day_of_month
+        return self.class.new(year, month, -1)
+      end
+
+      def each_day_in_month
+        for d in (1 .. days_of_month)
+          yield self.class.new(year, month, d)
+        end
+      end
+
+      def today?
+        return self.class.today == self
+      end
+
+      def absolute_from_epoch
+        return (self - Date.new(1970, 1, 1)).to_i
+      end
+
+      #
+      # Make a date by DAY like ``1st Wed of Nov, 1999''.
+      # caller must make sure:
+      #   YEAR and MONTH must be valid.
+      #   NTH must be <0 or >0.
+      #   WDAY must be 0..6.
+      #
+      # returns nil if no date was match (for example,
+      # no 5th Saturday exists on April 2010).
+      #
+      def self.new_by_day(year, month, nth, wday)
+        return nil if nth < -5 or nth > 5 or nth == 0
+        direction = nth > 0 ? 1 : -1
+
+        edge      = Date.new(year, month, direction)
+        y_offset  = nth - direction
+        x_offset  = wday_difference(edge.wday, wday, direction)
+        mday      = edge.mday + y_offset * 7 + x_offset
+
+        return new(year, month, mday) # May raise ArgumentError
+      end
+
+      def next_monthday(month, mday)
+        year = self.year + (month < self.month ? 1 : 0)
+        return self.class.new(year, month, mday)
+      end
+
+      def next_day(month, nth, wday)
+        year = self.year + (month < self.month ? 1 : 0)
+        year += 1 while !(date = self.class.new_by_day(year, month, nth, wday))
+        return date
+      end
+
+      def to_ics
+        return strftime("%Y%m%d")
+      end
+
+      private
+      #
+      # Returns diff of days between 2 wdays: FROM and TO.
+      # Each FROM and TO is one of 0(=Sun) ... 6(Sat).
+      #
+      # DIRECTION must be -1 or 1, which represents search direction.
+      #
+      #     Sun Mon Tue Wed Thu Fri Sat Sun Mon Tue ...
+      #      0   1   2   3   4   5   6   0   1   2  ...
+      #
+      # returns  3 if FROM, TO, DIRECTION = 4, 0,  1
+      # returns -4 if FROM, TO, DIRECTION = 4, 0, -1
+      #
+      def wday_difference(from, to, direction)
+        return direction * ((direction * (to - from)) % 7)
+      end
+
+    end # class Date
+  end # module PropertyValue
+end # module Mhc

data/lib/mhc/property_value/integer.rb

@@ -0,0 +1,15 @@
+module Mhc
+  module PropertyValue
+    class Integer < Base
+      def parse(string)
+        @value = string.to_i if /^\d+$/ =~ string
+        return self
+      end
+
+      def to_i
+        @value.to_i
+      end
+
+    end # class Integer
+  end # module PropertyValue
+end # module Mhc

data/lib/mhc/property_value/list.rb

@@ -0,0 +1,41 @@
+module Mhc
+  module PropertyValue
+    class List < Base
+      include Enumerable
+
+      ITEM_SEPARATOR = " "
+
+      def initialize(item_class)
+        @list = []
+        @item_class = item_class
+      end
+
+      def each
+        @list.each do |value|
+          yield value
+        end
+      end
+
+      def include?(o)
+        @list.include?(o)
+      end
+
+      def empty?
+        @list.empty?
+      end
+
+      def parse(string)
+        string.strip.split(ITEM_SEPARATOR).each do |str|
+          item = @item_class.parse(str)
+          @list << item if item
+        end
+        return self
+      end
+
+      def to_mhc_string
+        @list.map{|item| item.to_mhc_string}.join(ITEM_SEPARATOR)
+      end
+
+    end # class List
+  end # module PropertyValue
+end # module Mhc

data/lib/mhc/property_value/period.rb

@@ -0,0 +1,49 @@
+module Mhc
+  module PropertyValue
+    class Period < Base
+
+      UNIT2MIN = {'minute' => 1, 'hour' => 60, 'day' => 60*24}
+      UNITS    = UNIT2MIN.keys
+      REGEXP   = /(\d+)\s*(#{UNITS.join("|")})s?/
+
+      def self.parse(string)
+        return new.parse(string)
+      end
+
+      def parse(string)
+        if REGEXP =~ string
+          @minutes = (UNIT2MIN[$2] * $1.to_i)
+        end
+        return self
+      end
+
+      def to_mhc_string
+        return "" unless @minutes
+
+        value, unit_size, unit_name = @minutes, 1, "minute"
+
+        UNIT2MIN.each do |unit,minutes|
+          if @minutes % minutes == 0
+            value = @minutes / minutes
+            unit_size = minutes
+            unit_name = unit
+          end
+        end
+        return "#{value} #{unit_name}" + (value > 1 ? "s" : "")
+      end
+
+      def alarm_trigger
+        duration = nil
+        if @alarm
+          seconds = @alarm
+          duration = "-P"
+          duration += "#{seconds /= 86400}D" if seconds >= 86400
+          duration += "T#{seconds /= 3600}H" if seconds >= 3600
+          duration += "T#{seconds /= 60}M"   if seconds >= 60
+        end
+        return duration
+      end
+
+    end # class Period
+  end # module PropertyValue
+end # module Mhc

data/lib/mhc/property_value/range.rb

@@ -0,0 +1,100 @@
+module Mhc
+  module PropertyValue
+    class Range < Base
+      include Comparable
+      ITEM_SEPARATOR = "-"
+
+      attr_reader :first, :last
+
+      def initialize(item_class, prefix = nil, first = nil, last = nil)
+        @item_class, @prefix = item_class, prefix
+        @first, @last = first, last
+      end
+
+      # our Range acceps these 3 forms:
+      #   (1) A-B    : first, last = A, B
+      #   (2) A      : first, last = A, A
+      #   (3) A-     : first, last = A, nil
+      #   (4) -B     : first, last = nil, B
+      #
+      # nil means range is open (infinite).
+      #
+      def parse(string)
+        @first, @last = nil, nil
+        first, last = string.split(ITEM_SEPARATOR, 2)
+        last = first if last.nil? # single "A" means "A-A"
+
+        @first = @item_class.parse(first) unless first.to_s == ""
+        @last  = @item_class.parse(last)  unless last.to_s  == ""
+        return self.class.new(@item_class, @prefix, @first, @last)
+      end
+
+      def to_a
+        array = []
+        i = first
+        while i <= last
+          array << i
+          i = i.succ
+        end
+        return array
+      end
+
+      def each
+        i = first
+        while i <= last
+          yield(i)
+          i = i.succ
+        end
+      end
+
+      def narrow(from, to)
+        from = @first if from.nil? or (@first and from < @first)
+        to   = @last  if to.nil?   or (@last  and to   > @last)
+        self.class.new(@item_class, @prefix, from, to)
+      end
+
+      def <=>(o)
+        o = o.first if o.respond_to?(:first)
+        safe_comp(self.first, o)
+      end
+
+      def infinit?
+        return @first.nil? || @last.nil?
+      end
+
+      def blank?
+        @first.nil? && @last.nil?
+      end
+
+      def to_mhc_string
+        first = @first.nil? ? "" : @first.to_mhc_string
+        last  = @last.nil?  ? "" : @last.to_mhc_string
+
+        if first == last
+          return @prefix.to_s + first
+        else
+          return @prefix.to_s + [first, last].join(ITEM_SEPARATOR)
+        end
+      end
+
+      alias_method :to_s, :to_mhc_string
+
+      private
+
+      def cover?(item)
+        return false if @first && item < @first
+        return false if @last  && item > @last
+        return true
+      end
+
+      def safe_comp(a, o)
+        # nil is minimum
+        return (a <=> o) if  a and  o
+        return -1        if !a and  o
+        return  1        if  a and !o
+        return  0        if !a and !o
+      end
+
+    end # class Range
+  end # module PropertyValue
+end # module Mhc

data/lib/mhc/property_value/recurrence_condition.rb

@@ -0,0 +1,272 @@
+module Mhc
+  module PropertyValue
+    class RecurrenceCondition < Base
+
+      # :stopdoc:
+      MON_LABEL = %w(Jan Feb Mar Apr May Jun Jul Aug Sep Oct Nov Dec)
+      MON_VALUE = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]
+      MON_L2V   = Hash[*MON_LABEL.zip(MON_VALUE).flatten]
+      MON_V2L   = MON_L2V.invert
+
+      ORD_LABEL = %w(1st 2nd 3rd 4th 5th Last)
+      ORD_VALUE = [1, 2, 3, 4, 5, -1]
+      ORD_L2V   = Hash[*ORD_LABEL.zip(ORD_VALUE).flatten]
+      ORD_V2L   = ORD_L2V.invert
+
+      WEK_LABEL = %w(Sun Mon Tue Wed Thu Fri Sat)
+      WEK_VALUE = [0, 1, 2, 3, 4, 5, 6]
+      WEK_L2V   = Hash[*WEK_LABEL.zip(WEK_VALUE).flatten]
+      WEK_V2L   = WEK_L2V.invert
+      WEK_V2I   = Hash[*WEK_VALUE.zip(%w(SU MO TU WE TH FR SA)).flatten]
+
+      MON_REGEXP = /^#{MON_LABEL.join('|')}$/oi
+      ORD_REGEXP = /^#{ORD_LABEL.join('|')}$/oi
+      WEK_REGEXP = /^#{WEK_LABEL.join('|')}$/oi
+      NUM_REGEXP = /^\d+$/oi
+      # :startdoc:
+
+      def cond_mon; return @cond_mon; end
+      def cond_ord; return @cond_ord; end
+      def cond_wek; return @cond_wek; end
+      def cond_num; return @cond_num; end
+
+      def initialize
+        @cond_mon, @cond_ord, @cond_wek, @cond_num = [], [], [], []
+      end
+
+      def parse(string)
+        o = self
+        string.split.grep(MON_REGEXP) {|mon| o.cond_mon << MON_L2V[mon.capitalize]}
+        string.split.grep(ORD_REGEXP) {|ord| o.cond_ord << ORD_L2V[ord.capitalize]}
+        string.split.grep(WEK_REGEXP) {|wek| o.cond_wek << WEK_L2V[wek.capitalize]}
+        string.split.grep(NUM_REGEXP) {|num| o.cond_num << num.to_i}
+        return o
+      end
+
+      #--
+      #  MON NUM ORD WEK  RFC2445-TYPE (!: invalid)
+      # ------------------------------------------------------------------
+      #   -   -   -   -   ! EMPTY
+      #   -   -   -   Y     WEEKLY  BYDAY=wek
+      #   -   -   Y   -   ! MONTHLY BYDAY=ord*ALL
+      #   -   -   Y   Y     MONTHLY BYDAY=ord*wek
+      #   -   Y   -   -     MONTHLY BYMONTHDAY=num
+      #   -   Y   -   Y     MONTHLY BYMONTHDAY=num,BYDAY=wek
+      #   -   Y   Y   -   ! MONTHLY BYMONTHDAY=num,BYDAY=ord*ALL
+      #   -   Y   Y   Y     MONTHLY BYMONTHDAY=num,BYDAY=ord*wek
+      #   Y   -   -   -   ! YEARLY  BYMONTH=mon,BYDAY=ALL
+      #   Y   -   -   Y     YEARLY  BYMONTH=mon,BYDAY=wek
+      #   Y   -   Y   -   ! YEARLY  BYMONTH=mon,BYDAY=ord*ALL
+      #   Y   -   Y   Y     YEARLY  BYMONTH=mon,BYDAY=ord*wek
+      #   Y   Y   -   -     YEARLY  BYMONTH=mon,BYMONTHDAY=num
+      #   Y   Y   -   Y     YEARLY  BYMONTH=mon,BYMONTHDAY=num,BYDAY=wek
+      #   Y   Y   Y   -   ! YEARLY  BYMONTH=mon,BYMONTHDAY=num,BYDAY=ord*ALL
+      #   Y   Y   Y   Y     YEARLY  BYMONTH=mon,BYMONTHDAY=num,BYDAY=ord*wek
+      #++
+      def frequency
+        return :none    if empty?
+        return :daily   if daily?
+        return :weekly  if weekly?
+        return :monthly if monthly?
+        return :yearly  if yearly?
+      end
+
+      def daily?
+        false
+      end
+
+      def weekly?
+        !yearly? && !monthly? && !cond_wek.empty?
+      end
+
+      def monthly?
+        !yearly? && (!cond_num.empty? || !cond_ord.empty?)
+      end
+
+      def yearly?
+        !cond_mon.empty?
+      end
+
+      def valid?
+        frequency != :none
+      end
+
+      def empty?
+        [@cond_mon, @cond_ord, @cond_wek, @cond_num].all?{|cond| cond.empty?}
+      end
+
+      # convert RRULE to X-SC-Cond:
+      #
+      # Due to the over-killing complexity of iCalendar (RFC5545)
+      # format, converting RRULE to X-SC-* format has some restrictions:
+      #
+      # * Not allowed elements:
+      #   * BYSECOND
+      #   * BYMINUTE
+      #   * BYHOUR
+      #   * COUNT
+      #   * BYYEARDAY (-366 to 366)
+      #   * BYWEEKNO  (-53  to  53)
+      #   * BYSETPOS  (-366 to 366)
+      #   * Recurrence-ID (not part of RRULE)
+      #
+      # * Restricted elements:
+      #
+      #   * INTERVAL:
+      #     * it should be 1
+      #
+      #   * BYMONTHDAY:
+      #     * it should be (1..31)
+      #
+      #   * WKST:
+      #     * it should be MO
+      #
+      #   * FREQ:
+      #     * should be one of WEEKLY, MONTHLY, YEARLY
+      #     * should be MONTHLY if BYDAY has (1|2|3|4|-1)
+      #     * should be WEEKLY if BYDAY does not have (1|2|3|4|-1)
+      #
+      #   * BYDAY:
+      #     * should be a list of (1|2|3|4|-1)?(MO|TU|WE|TH|FR|SA|SU)
+      #
+      #     * Every week should have the same number-prefix set:
+      #       WE,SU           is OK => Wed Sun
+      #       3WE,3SU         is OK => 3rd Wed Sun
+      #       2WE,3WE,2SU,3SU is OK => 2nd 3rd Sun Wed
+      #       3WE,2SU         is NG
+      #       3WE,SU          is NG
+      #
+      # * Fully converted elements:
+      #
+      #   * UNTIL
+      #     * YYYYMMDD should goes to X-SC-Duration: -YYYYMMDD
+      #
+      #   * BYMONTH
+      #     * (1..12)* => (Jan|Feb|Mar|Jul|Aug|Sep|Oct|Nov|Dec)*
+      #
+      def validate_rrule(rrule)
+        interval = (rrule =~ /INTERVAL=(\d+)/i) ? $1.to_i : 1
+        return true if rrule.to_s == ""
+        return 1 if rrule =~ /(BYSECOND|BYMINUTE|BYHOUR|COUNT|BYYEARDAY|BYWEEKNO|BYSETPOS)/i
+        return 2 unless (rrule =~ /FREQ=MONTHLY/i and interval == 12) || interval == 1
+        return 3 if rrule =~ /BYMONTHDAY=([^;]+)/i and $1.split(",").map(&:to_i).any?{|i| i < 1 or i > 31}
+        return 4 if rrule =~ /WKST=([^;]+)/i and $1 !~ /MO/
+        return 5 if rrule =~ /FREQ=([^;]+)/i   and $1 !~ /WEEKLY|MONTHLY|YEARLY/i
+        return 6 if rrule =~ /BYDAY=([^;]+)/i  and $1 =~ /\d/ and rrule !~ /FREQ=MONTHLY/i
+        return 7 if rrule =~ /BYDAY=([^;]+)/i  and $1 !~ /\d/ and rrule !~ /FREQ=WEEKLY/i
+        return 8 if rrule =~ /BYDAY=([^;]+)/i  and $1 !~ /((1|2|3|4|-1)?(MO|TU|WE|TH|FR|SA|SU))+/i
+        return true
+      end
+
+      def set_from_ics(rrule, dtstart)
+        if (errno = validate_rrule(rrule)) != true
+          raise "Unsupported RRULE string (errno=#{errno}): #{rrule}"
+        end
+
+        ################
+        ## BYMONTH (cond_mon)
+        cond_mon = []
+        if rrule =~ /BYMONTH=([^;]+)/
+          $1.split(",").each do |mon|
+            cond_mon << mon.to_i
+          end
+        end
+
+        ################
+        ## BYDAY (cond_ord, cond_wek)
+        cond_ord = []
+        cond_wek = []
+        week = {}
+        if rrule =~ /BYDAY=([^;]+)/
+          $1.scan(/(1|2|3|4|-1)?(MO|TU|WE|TH|FR|SA|SU)/).each do |o,w|
+            week[w] ||= []
+            week[w] << o.to_i # unpefixed week is replaced as 0
+          end
+
+          # Every week should have the same number-prefix set:
+          return 9 unless week.values.all?{|orders| orders.sort == week.values.first.sort}
+
+          order = week.values.first.sort
+          #     * Number-prefixed week cannot coexist with unprefixed week
+          #       WE,SU  is OK => Wed Sun
+          #       WE,3SU is NG
+          return 10 if order.length > 1 and order.member?(0) # 0 means non-numberd prefix
+
+          order.delete(0)
+          cond_ord = order
+
+          week.each do |w, o|
+            cond_wek << WEK_V2I.invert[w]
+          end
+        end
+
+        ################
+        ## BYMONTHDAY (cond_num)
+        cond_num = []
+        if rrule =~ /BYMONTHDAY=([^;]+)/i
+          $1.split(",").each do |n|
+            cond_num << n.to_i
+          end
+        end
+
+        ################
+        # Special cases
+
+        interval = (rrule =~ /INTERVAL=(\d+)/i) ? $1.to_i : 1
+
+        # special case of yearly: repeat with 12 months interval
+        # BYMONTH should be taken from DTSTART
+        if interval == 12 and rrule =~ /FREQ=MONTHLY/i and cond_mon.empty?
+          cond_mon << dtstart.month
+        end
+
+        # if RRULE has only FREQ=YEARLY phrase,
+        # BYMONTH and BYMONTHDAY should be taken from DTSTART
+        #
+        if rrule =~ /FREQ=YEARLY/i
+          cond_mon << dtstart.month if cond_mon.empty?
+          cond_num << dtstart.day   if cond_num.empty? and cond_wek.empty?
+        end
+
+        @cond_mon, @cond_ord, @cond_wek, @cond_num = cond_mon, cond_ord, cond_wek, cond_num
+        return self
+      end
+
+      def to_mhc_string
+        return (cond_mon.map{|mon| MON_V2L[mon]} +
+                cond_ord.map{|ord| ORD_V2L[ord]} +
+                cond_wek.map{|wek| WEK_V2L[wek]} +
+                cond_num.map{|num| num.to_s}
+                ).join(" ")
+      end
+
+      def to_ics(dtstart = nil, until_date = nil)
+        return nil unless valid?
+
+        ord_wek = (cond_ord.empty? ? [""] : cond_ord).product(cond_wek)
+        day = ord_wek.map {|o,w| o.to_s + WEK_V2I[w] }.join(',')
+
+        if until_date
+          if dtstart.respond_to?(:hour)
+            tz = TZInfo::Timezone.get(ENV["MHC_TZID"] || 'UTC')
+            localtime = Mhc::PropertyValue::Time.new.parse(dtstart.strftime("%H:%M")).to_datetime(until_date).to_time
+            until_str = tz.local_to_utc(localtime).strftime("%Y%m%dT%H%M%SZ")
+            # puts "until_str local (tz=#{tz.name}) : #{localtime.strftime("%Y%m%dT%H%M%S")} utc: #{until_str}"
+          else
+            until_str = until_date.strftime("%Y%m%d")
+          end
+        end
+
+        ics = "FREQ=#{frequency.to_s.upcase};INTERVAL=1;WKST=MO"
+
+        ics += ";BYMONTH=#{cond_mon.join(',')}"    unless cond_mon.empty?
+        ics += ";BYDAY=#{day}"                     unless day.empty?
+        ics += ";BYMONTHDAY=#{cond_num.join(',')}" unless cond_num.empty?
+        ics += ";UNTIL=#{until_str}" unless until_date.nil?
+
+        return ics
+      end
+
+    end # class RecurrenceCondition
+  end # module PropertyValue
+end # module Mhc