mhc 1.0.0

data/lib/mhc/property_value/text.rb

@@ -0,0 +1,11 @@
+module Mhc
+  module PropertyValue
+    class Text < Base
+      require "nkf"
+      def to_mhc_string
+        return NKF.nkf("-w", @value.to_s)
+      end
+      alias_method :to_s, :to_mhc_string
+    end # class Text
+  end # module PropertyValue
+end # module Mhc

data/lib/mhc/property_value/time.rb

@@ -0,0 +1,45 @@
+class DateTime
+  alias_method :to_mhc_string, :to_s
+end
+
+module Mhc
+  module PropertyValue
+    class Time < Base
+      include Comparable
+
+      def parse(string)
+        if /^(\d+):(\d+)$/ =~ string
+          @sec = ($1.to_i) * 3600 + ($2.to_i) * 60
+        end
+        return self
+      end
+
+      def days;    (@sec        ) / 86400 ;end
+      def hour;    (@sec % 86400) / 3600  ;end
+      def minute;  (@sec % 3600)  / 60    ;end
+
+      def <=>(o)
+        return @sec <=> o.to_i
+      end
+
+      def to_mhc_string
+        return format("%02d:%02d", hour, minute)
+      end
+
+      alias_method :to_s, :to_mhc_string
+
+      def to_i
+        return @sec
+      end
+
+      def to_a
+        return [hour, minute]
+      end
+
+      def to_datetime(date = Mhc::PropertyValue::Date.new(1970, 1, 2))
+        date = date + days
+        time = ::DateTime.new(date.year, date.month, date.day, hour, minute, 0, DateTime.now.zone) # make local DateTime
+      end
+    end
+  end # module PropertyValue
+end # module Mhc

data/lib/mhc/query.rb

@@ -0,0 +1,210 @@
+module Mhc
+  class Query
+    def initialize(query_string)
+      @expression = Expression.new(Context.new(query_string))
+      @query_string = query_string
+    end
+
+    def to_proc
+      return @expression.to_proc
+    end
+
+    def to_s
+      @query_string.to_s
+    end
+
+    class ParseError < StandardError; end
+
+    #
+    # Expression :: Term ('|' Term)*
+    #
+    class Expression
+      def initialize(context)
+        @terms = [Term.new(context)]
+        @terms << Term.new(context) while context.eat_if(:orop)
+      end
+
+      def to_proc
+        @procs = @terms.map(&:to_proc)
+        return lambda {|ev| @procs.any? {|p| p.call(ev)}}
+      end
+    end # class Expression
+
+    #
+    # Term :: Factor ('&' Factor)*
+    #
+    class Term
+      def initialize(context)
+        @factors = [Factor.new(context)]
+        @factors << Factor.new(context) while context.eat_if(:andop)
+      end
+
+      def to_proc
+        @procs = @factors.map(&:to_proc)
+        return lambda {|ev| @procs.all? {|p| p.call(ev)}}
+      end
+    end # class Term
+
+    #
+    # Factor :: '!'* ( '(' Expression ')' || RelationalExpression )
+    #
+    class Factor
+      def initialize(context)
+        @expected_value = true
+        @expected_value = !@expected_value while context.eat_if(:negop)
+
+        if context.eat_if(:lparen)
+          @value = Expression.new(context)
+          context.expect(:rparen)
+        else
+          @value = RelationalExpression.new(context)
+        end
+      end
+
+      def to_proc
+        @proc = @value.to_proc
+        return lambda {|ev| @proc.call(ev) == @expected_value}
+      end
+    end # class Factor
+
+    #
+    # RelationalExpression :: Symbol Operator (Argument || '[' Argument Argument* ']')
+    #
+    class RelationalExpression
+      KEYWORDS = [:subject, :category, :body, :location, :recurrence_tag]
+
+      def initialize(context)
+        @name = context.expect(:symbol).value.downcase.to_sym
+        raise ParseError, "unknown keyword '#{@name}'" unless KEYWORDS.member?(@name)
+
+        context.expect(:sepop) # Currently, operator is only ":"
+
+        @arguments = []
+        if context.eat_if(:lbracket)
+          loop do
+            @arguments << Argument.new(context)
+            break if context.eat_if(:rbracket)
+          end
+        else
+          @arguments << Argument.new(context)
+        end
+      end
+
+      def to_proc
+        case @name
+        when :category
+          @arguments = @arguments.map{|arg| arg.value.downcase}
+          return lambda {|ev| !(ev.categories.map{|c| c.to_s.downcase} & @arguments).empty?}
+        when :recurrence_tag
+          @arguments = @arguments.map{|arg| arg.value.downcase}
+          return lambda {|ev| !!@arguments.find{|v| ev.send(@name).to_s.downcase.toutf8 == v}}
+        else
+          @arguments = @arguments.map{|arg| Regexp.quote(arg.value)}
+          return lambda {|ev| !!@arguments.find{|v| ev.send(@name).to_s.toutf8.match(v)}}
+        end
+      end
+    end # class RelationalExpression
+
+    #
+    # Argument :: Symbol || String
+    #
+    class Argument
+      def initialize(context)
+        token = context.expect(:symbol, :string)
+        @type  = token.type
+        @value = token.value
+      end
+
+      def value
+        case @type
+        when :string
+          @value[1..-2]
+        else
+          @value
+        end
+      end
+    end # class Argument
+
+    class Context
+      TOKENS = {
+        symbol:   /[a-zA-Z_][a-zA-Z_\d]*/,
+        string:   /"(?:[^"\\]|\\.)*"/,
+        negop:    /!/,
+        andop:    /&/,
+        orop:     /\|/,
+        sepop:    /:/,
+        lparen:   /\(/,
+        rparen:   /\)/,
+        lbracket: /\[/,
+        rbracket: /\]/
+      }.map{|type,regexp| "(?<#{type}>#{regexp})"}.join("|")
+
+      TOKEN_REGEXP = Regexp.new('^\s*(' + TOKENS + ')')
+
+      def initialize(string)
+        @tokens = tokenize(string)
+      end
+
+      def eat_if(*expected_types)
+        expected_types.each do |expected_type|
+          if @tokens.first and @tokens.first.type == expected_type
+            return @tokens.shift
+          end
+        end
+        return nil
+      end
+
+      def expect(*expected_types)
+        token = eat_if(*expected_types) and return token
+        raise ParseError, "#{expected_types.map(&:upcase).join(' or ')} expected before #{@tokens.first.value rescue 'END'}"
+      end
+
+      def debug_dump
+        @tokens.map{|token| "#{token.type} => #{token.value}"}.join(", ")
+      end
+
+      private
+
+      def tokenize(string)
+        tokens = []
+
+        loop do
+          token, string = get_token(string)
+          break if token.nil?
+          tokens << token
+        end
+
+        raise ParseError, "can not tokenize '#{string}'" unless string.length == 0
+        return tokens
+      end
+
+      def get_token(string)
+        if match = TOKEN_REGEXP.match(string)
+          name   = match.names.find{|name| match[name]}
+          value  = match[name]
+          remain = match.post_match.strip
+          return [Token.new(name, value), remain]
+        end
+        return [nil, string]
+      end
+    end # class Context
+
+    class Token
+      attr_reader :type, :value
+
+      def initialize(type, string)
+        @type, @value = type.to_sym, string
+      end
+    end # class Token
+
+    class Test
+      attr_reader :categories, :subject
+
+      def initialize(categories = [], subject = "", body = "")
+        @categories = categories
+        @subject = subject
+        @body = body
+      end
+    end
+  end
+end

data/lib/mhc/sync.rb

@@ -0,0 +1,46 @@
+################################################################
+#
+# We assume a CalDAV server as a remote side.
+# CalDAV has no ability to provide such information.
+# It only provides ETag mechanism, which is defined
+# in HTTP protocol (see rfc2616).
+#
+# So, we have to maintain a ETag cache (replica) on local and
+# manage difference between the cache and the remote.
+# Using the ETag information:
+#
+# (1) get uid-etag list via PROPFIND (WebDav) method
+#
+#     make a set: R_SET = [(r_uid, r_etag)..]
+#       r_uid:  unique id of a remote article.
+#       r_etag: corresponding etag of r_uid.
+#
+# (2) get uid-etag list via local cache.
+#
+#     make a set: L_SET = [(l_uid, l_etag)..]
+#
+# (3) for each uid: [uid| (uid, etag) <- L_SET + R_SET]
+#
+#     (A) if (uid, _) is missed in L_SET
+#           -> SET_MARK(uid, M)
+#
+#     (B) if (uid, _) is missed in R_SET
+#           -> SET_MARK(uid, D)
+#
+#     (C) if (uid, _) exists in both R_SET and L_SET
+#           if l_etag != r_etag
+#             -> SET_MARK(uid, M)
+#           if l_etag == r_etag
+#             -> SET_MARK(uid, N)
+#
+module Mhc
+  module Sync
+    dir = File.dirname(__FILE__) + "/sync"
+
+    autoload :Driver,        "#{dir}/driver.rb"
+    autoload :Status,        "#{dir}/status.rb"
+    autoload :StatusManager, "#{dir}/status_manager.rb"
+    autoload :Strategy,      "#{dir}/strategy.rb"
+    autoload :Log,           "#{dir}/syncinfo.rb"
+  end # module  Sync
+end # module Mhc

data/lib/mhc/sync/driver.rb

@@ -0,0 +1,108 @@
+module Mhc
+  module Sync
+    ##
+    # Sync Driver takes two calendar databases to sync.
+    #
+    # Each record in calendar has to respond to:
+    # * Record#unmodified?
+    # * Record#deleted?
+    # * Record#etag
+    # * Record#etag=
+    # * Record#ex_etag
+    #
+    class Driver
+      def initialize(db1, db2, strategy)
+        @db1 = db1
+        @db2 = db2
+        @strategy = Strategy::Factory.create(strategy)
+      end
+
+      def sync_all(dry_run = false, max_count = 50)
+        list_cache = uid_list
+
+        items = count_sync_items(list_cache)
+        if items > max_count
+          STDERR.print "Too many (#{items}) articles to sync... abort\n"
+          return false
+        end
+
+        list_cache.each do |uid|
+          sync(uid, dry_run)
+        end
+
+        return true
+      end
+
+      private
+
+      def count_sync_items(sync_uid_list)
+        sync_uid_list.map{|uid| sync(uid, true, true)}.count{|s| s != :ignore}
+      end
+
+      def sync(uid, dry_run = false, quiet = false)
+        info1 = @db1.syncinfo(uid)
+        info2 = @db2.syncinfo(uid)
+
+        unless @strategy.whatnow(info1, info2) == :ignore or quiet
+          STDERR.print "ABOUT#{dry_run ? '(DRY_RUN)' : ''} #{uid} => #{@strategy.whatnow(info1, info2)} "
+          STDERR.print "(#{info1.sync_status} vs #{info2.sync_status})\n"
+        end
+        return @strategy.whatnow(info1, info2) if dry_run
+
+        case @strategy.whatnow(info1, info2)
+        when :ignore
+          #ignore(side1, side2)
+        when :conflict
+          merge(uid, @db1, @db2)
+        when :delete1
+          delete(uid, @db1, @db2)
+        when :delete2
+          delete(uid, @db2, @db1)
+        when :copy1_to_2
+          copy(uid, @db1, @db2)
+        when :copy2_to_1
+          copy(uid, @db2, @db1)
+        when :overwrite1_to_2
+          copy(uid, @db1, @db2, :overwrite)
+        when :overwrite2_to_1
+          copy(uid, @db2, @db1, :overwrite)
+        end
+      end
+
+      def uid_list
+        (@db1.uid_list + @db2.uid_list).sort.uniq
+      end
+
+      def merge(uid, db1, db2)
+        # Not yet implemented
+        s1 = db1.get(uid)
+        s2 = db2.get(uid)
+        STDERR.print("Conflict: UID=#{uid} ... did nothing.\n")
+      end
+
+
+      def delete(uid, db, db2)
+        info = db.syncinfo(uid)
+        info2 = db2.syncinfo(uid)
+        if db.delete(uid)
+          info.mark_synced(nil)
+          info2.mark_synced(nil)
+        end
+      end
+
+      def copy(uid, db1, db2, overwrite = false)
+        ev = db1.get(uid)
+        STDERR.print "COPYING:#{overwrite ? ' (overwrite)' : ''} #{ev.uid}\n"
+
+        db2.delete(uid) if overwrite
+
+        if new_info = db2.put(ev, overwrite)
+          db1.syncinfo(uid).mark_synced(ev.etag)
+          db2.syncinfo(uid).mark_synced(new_info.etag)
+        else
+          STDERR.print "COPY: failed.\n"
+        end
+      end
+    end # class Driver
+  end # module  Sync
+end # module Mhc

data/lib/mhc/sync/status.rb

@@ -0,0 +1,70 @@
+module Mhc
+  module Sync
+    ##
+    # status
+    #
+    class Status
+      def initialize(uid, manager, wrapped_record = nil)
+        @uid, @manager, @wrapped_record = uid, manager, wrapped_record
+      end
+
+      def uid
+        return @uid
+      end
+
+      def etag
+        @manager.etag(@uid)
+      end
+
+      def ex_etag
+        @manager.ex_etag(@uid)
+      end
+
+      def sync_status
+        return :norecord   if !etag and !ex_etag
+        return :created    if  etag and !ex_etag
+        return :deleted    if !etag and  ex_etag
+        return :unmodified if  etag ==   ex_etag
+        return :modified   if  etag !=   ex_etag
+      end
+
+      def modified?
+        sync_status == :created or sync_status == :modified
+      end
+
+      def unmodified?
+        sync_status == :unmodified
+      end
+
+      def norecord?
+        sync_status == :norecord
+      end
+
+      def deleted?
+        sync_status == :deleted
+      end
+
+      def mark_synced(etag = self.etag)
+        @manager.mark_synced(uid, etag)
+        return self
+      end
+
+      ### as a calendar DB redord
+      def to_ics_string
+        # LastNote or mhc is assumed.
+        if  @wrapped_record.respond_to?(:to_ics_string)
+          result = @wrapped_record.to_ics_string
+           return result
+        end
+
+        # HTTP::Response from caldav server is assumed.
+        if @wrapped_record.respond_to?(:body)
+          return @wrapped_record.body
+        end
+
+        return nil # Nil or unsupport object class. XXX donot put.
+      end
+
+    end # class Status
+  end # module  Sync
+end # module Mhc