mhc 1.0.0

data/lib/mhc/calendar.rb

@@ -0,0 +1,106 @@
+# -*- coding: utf-8 -*-
+module Mhc
+  class Calendar
+
+    def initialize(datastore, modifiers = [], &default_scope)
+      @datastore     = datastore
+      @modifiers     = modifiers || []
+      @logger        = @datastore.logger
+      @default_scope = default_scope
+    end
+
+    def find(uid:)
+      if event = @datastore.find_by_uid(uid)
+        decorate_event(event)
+      end
+    end
+
+    def events(date_range = nil, &scope_block)
+      occurrences(date_range, &scope_block).map(&:event).uniq
+    end
+
+    def occurrences(date_range, &scope_block)
+      ocs = []
+      @datastore.entries(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)
+        end
+      end
+      return ocs.sort
+    end
+
+    ################################################################
+    ## for sync manager
+
+    def report_etags(uid = nil)
+      return find(uid) if uid
+      date_range = (Mhc::PropertyValue::Date.today - 90)..
+                   (Mhc::PropertyValue::Date.today + 90)
+      events(date_range)
+    end
+
+    def get_with_etag(uid)
+      find(uid: uid)
+    end
+
+    def put_if_match(uid, ics_string, expected_etag)
+      STDERR.print "Mhc::Calendar#put_if_match(uid:#{uid}, expected_etag:#{expected_etag})..."
+      if ev = find(uid: uid) and ev.etag != expected_etag
+        STDERR.print "failed: etag not match #{ev.etag} != #{expected_etag}\n"
+        return nil
+      end
+      if expected_etag and (not ev)
+        STDERR.print "failed: etag not match #{expected_etag} != nil\n"
+      end
+      begin
+        ev = Mhc::Event.new_from_ics(ics_string)
+        @datastore.update(ev)
+        STDERR.print "succeeded #{ev.etag}\n"
+        return true
+      rescue Exception => e
+        STDERR.print "failed: #{e.to_s}\n"
+        STDERR.print "#{e.backtrace.first}\n" if $MHC_DEBUG
+        STDERR.print "#{ics_string}\n" if $MHC_DEBUG
+        return nil
+      end
+    end
+
+    def delete_if_match(uid, expected_etag)
+      STDERR.print "Mhc::Calendar#delete_if_match(uid:#{uid}, expected_etag:#{expected_etag})..."
+      unless ev = find(uid: uid)
+        STDERR.print "failed: uid #{uid} not found\n"
+        return nil
+      end
+      if expected_etag && ev.etag != expected_etag
+        STDERR.print "failed: etag not match #{ev.etag} != #{expected_etag}\n"
+        return nil
+      end
+      begin
+        @datastore.delete(ev)
+        STDERR.print "succeeded: #{ev.etag}\n"
+        return ev
+      rescue Exception => e
+        STDERR.print "failed: #{e.to_s}\n"
+        return nil
+      end
+    end
+
+    ################################################################
+    private
+    ################################################################
+
+    def decorate_event(event)
+      @modifiers.each do |deco|
+        event = deco.decorate(event)
+      end
+      return event
+    end
+
+    def in_scope?(oc, &scope_block)
+      (!@default_scope || @default_scope.call(oc)) &&
+        (!scope_block || scope_block.call(oc))
+    end
+
+  end # class Calendar
+end # module Mhc

data/lib/mhc/command.rb

@@ -0,0 +1,13 @@
+module Mhc
+  module Command
+
+    dir = File.dirname(__FILE__) + "/command"
+
+    autoload :Completions, "#{dir}/completions.rb"
+    autoload :Cache,       "#{dir}/cache.rb"
+    autoload :Init,        "#{dir}/init.rb"
+    autoload :Scan,        "#{dir}/scan.rb"
+    autoload :Sync,        "#{dir}/sync.rb"
+
+  end # module Command
+end # module Mhc

data/lib/mhc/command/cache.rb

@@ -0,0 +1,14 @@
+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}"
+        end
+      end
+
+    end # class Cache
+  end # module Command
+end # module Mhc

data/lib/mhc/command/completions.rb

@@ -0,0 +1,108 @@
+module Mhc
+  module Command
+    class Completions
+
+      def initialize(help, global_options, arguments, config = nil)
+        @help, @global_options, @arguments, @config = help, global_options, arguments, config
+        command_name = arguments.first
+
+        if command_name and help[command_name]
+          option_arguments(help, global_options, command_name)
+        else
+          command_arguments
+        end
+      end
+
+      private
+
+      def command_arguments
+        print "_arguments\n"
+        print "1:Possible commands\\::"
+        print possible_commands + "\n"
+      end
+
+      def option_arguments(help, global_options, command_name)
+        command_arguments
+        print arguments(help, command_name)
+        print options(help[command_name], global_options)
+      end
+
+      # make normal argument completion setting from usage string such as: "scan REPOSITORY"
+      def arguments(help, command_name, position = 2)
+        str = ""
+        help[command_name].usage.split(/\s+/)[1..-1].each do |arg|
+          pos = position
+
+          if /^\[(.*)\]/ =~ arg
+            arg = $1
+          end
+
+          multi = ""
+          if /(.*)\.\.\.$/ =~ arg
+            arg = $1
+            pos = "*"
+            multi = ":"
+          end
+
+          str << "#{pos}:#{arg}\\::#{possible_values(arg)}#{multi}\n"
+          position += 1
+        end
+        return str
+      end
+
+      # make option argument completion setting from usage options help
+      def options(command_help, global_options, position = 2)
+        str = ""
+        options = command_help.options.merge(global_options)
+
+        options.each do |name, opt|
+          name = name.to_s.gsub("_", "-")
+
+          if opt.type == :boolean
+            str << "(--#{name})--#{name}[#{opt.description}]\n"
+          else
+            str << "(--#{name})--#{name}=-[#{opt.description}]:#{opt.banner}:#{possible_values_for_opt(opt)}\n"
+          end
+        end
+        return str
+      end
+
+      def possible_commands
+        str = "(("
+        @help.each_value do |cmd|
+          next if cmd.name == "completions"
+          str << " #{cmd.name}\\:"
+          str << cmd.description.gsub(/([()\s"';&|#\\])/, '\\\\\1')
+        end
+        str << "))"
+      end
+
+      def possible_values_for_opt(option)
+        return "(" + option.enum.join(" ") + ")" if option.enum
+        return possible_values(option.banner)
+      end
+
+      def possible_values(banner)
+        case banner
+        when /^CALENDAR/
+          "(" + @config.calendars.select{|cal| cal.type == "mhc"}.map(&:name).join(' ') + ")"
+        when /^SYNC_CHANNEL/
+          "(" + @config.sync_channels.map(&:name).join(' ') + ")"
+        when /^(FILE|CONF)/
+          "_files"
+        when /^DIR/
+          "_files -/"
+        when "COMMAND"
+          possible_commands
+        when "RANGE"
+          "(today tomorrow thismonth nextmonth)"
+        when /^NUM/
+          "_guard '[0-9]#' 'Number'"
+        else
+          ""
+        end
+      end
+
+    end # class Completions
+  end # module Command
+end # module Mhc

data/lib/mhc/command/init.rb

@@ -0,0 +1,133 @@
+module Mhc
+  module Command
+    class Init
+      SUB_DIRS = %w(draft inbox presets spool trash
+               status/cache status/log status/sync_channels)
+
+      TEMPLATE_DIR = File.expand_path("../../templates", __FILE__)
+
+      def initialize(top_dir, config_path, tzid = nil, template_dir = nil)
+        @shell = Thor.new
+        @status = {green: 0, yellow: 0, red: 0}
+        @config = {}
+
+        # guess teimzone
+        say "Guessing current local timezone ..."
+
+        if @config[:tzid] = find_current_tzid
+          say_status "ok", "guess timezone ... #{@config[:tzid]}", :green
+          tzid = find_current_tzid
+        else
+          say_status "failed", "guess timezone... Unknown", :red
+        end
+
+        # mkdir
+        say "Making directries under #{top_dir} ..."
+        SUB_DIRS.each do |ent|
+          mkdir_p(File.expand_path(ent, top_dir))
+        end
+
+        # make config file from tamplate
+        say "Copying config file(s) into #{config_path} ..."
+        src = File.expand_path("config.yml.erb", TEMPLATE_DIR)
+        dst = File.expand_path(config_path)
+        @config[:topdir] = top_dir
+        expand_template(src, dst)
+
+        say_status_report
+      end
+
+      private
+
+      def say(message, color = nil)
+        @shell.say(message, color)
+      end
+
+      def say_status(status, message, log_status = nil)
+        @status[log_status] += 1
+        @shell.say_status(status, message, log_status)
+      end
+
+      def say_status_report
+        if (errors = @status[:red]) > 0
+          say "#{errors} error(s) were occurred.", :red
+        else
+          say "Done."
+        end
+      end
+
+      def expand_template(template_path, dest_path)
+        require "erb"
+        template = ERB.new(File.open(template_path).read, nil, "-")
+
+        if File.exists?(dest_path)
+          say_status "exist", "Ignore #{dest_path}", :yellow
+          return
+        end
+
+        begin
+          mkdir_p(File.expand_path("..", dest_path))
+          File.open(dest_path, "w", 0600) do |file|
+            file.write(template.result(binding))
+          end
+          say_status "ok", "copy #{dest_path}", :green
+        rescue StandardError => e
+          say_status "failed", "#{e.message.split(' @').first} #{dest_path}", :red
+        end
+      end
+
+      def mkdir_p(path)
+        path = File.expand_path(path)
+
+        if File.directory?(path)
+          say_status "exist", "Ignore #{path}", :yellow
+          return
+        end
+
+        begin
+          FileUtils.mkdir_p(path)
+          say_status "create", "#{path}", :green
+        rescue StandardError => e
+          say_status "failed", "#{e.message.split(' @').first} #{path}", :red
+        end
+      end
+
+      def find_current_tzid
+        require "digest/md5"
+
+        # Debian
+        if File.exists?("/etc/timezone")
+          return File.open("/etc/timezone").read.chomp
+        end
+
+        # Mac
+        if File.symlink?("/etc/localtime") &&
+            /([^\/]+\/[^\/]+)$/ =~ File.readlink("/etc/localtime")
+          return $1
+        end
+
+        # Red Had / CentOS
+        if File.exists?("/etc/sysconfig/clock") &&
+            /ZONE=["']?([^"']+)/ =~ File.open("/etc/sysconfig/clock").read.chomp
+          return $1
+        end
+
+        # generic including FreeBSD
+        if File.exists?("/etc/localtime")
+          localtime = Digest::MD5.file("/etc/localtime")
+          candidates = Dir.chdir("/usr/share/zoneinfo") do
+            Dir.glob("**/*").select do |fn|
+              File.file?(fn) && Digest::MD5.file(fn) == localtime
+            end
+          end
+          unless candidates.empty?
+            # take the most descriptive (has long name) one
+            return candidates.sort {|a,b| b.length <=> a.length}.first
+          end
+        end
+        return "Unknown"
+      end
+
+    end # class Init
+  end # module Command
+end # module Mhc

data/lib/mhc/command/scan.rb

@@ -0,0 +1,33 @@
+module Mhc
+  module Command
+    class Scan
+      Encoding.default_external = "UTF-8"
+
+      def initialize(calendar, range_string, format: :text, search: nil, **options)
+        date_range = Mhc::PropertyValue::Date.parse_range(range_string)
+        formatter = Mhc::Formatter.build(formatter: format, date_range: date_range, **options)
+        format_range(calendar, formatter, date_range, search: search, **options)
+      end
+
+      def format_range(calendar, formatter, date_range, search: nil, **options)
+        if options[:category] and not search
+          search = "category:\"#{options[:category]}\""
+        end
+
+        if search
+          begin
+            search_proc = Mhc::Query.new(search).to_proc
+          rescue Mhc::Query::ParseError => e
+            STDERR.print "Error: " + e.message.capitalize + " in search string\n"
+            exit 1
+          end
+        end
+
+        calendar.occurrences(date_range, &search_proc).each do |oc|
+          formatter << oc
+        end
+        print formatter.to_s
+      end
+    end # class Scan
+  end # module Command
+end # module Mhc

data/lib/mhc/command/sync.rb

@@ -0,0 +1,22 @@
+module Mhc
+  module Command
+    class Sync
+      Encoding.default_external = "UTF-8"
+
+      def initialize(channel_name, config)
+        channel = config.sync_channels[channel_name]
+
+        unless channel
+          STDERR.print "Error: Not found '#{channel_name}' in ~/.mhc/config.yml\n"
+          exit 1
+        end
+
+        builder = Mhc::Builder.new(config)
+
+        driver = builder.sync_driver(channel.name, channel.strategy)
+        driver.sync_all
+      end
+
+    end # class Sync
+  end # module Command
+end # module Mhc

data/lib/mhc/config.rb

@@ -0,0 +1,229 @@
+require 'yaml'
+require 'pp'
+
+module Mhc
+  class Config
+    # Syntax table manipulation
+    class Syntax
+      def initialize(syntax_config)
+        @syntax_config = syntax_config
+      end
+
+      def keyword_symbols
+        @syntax_config.keys
+      end
+
+      def keywords
+        keyword_symbols.map {|sym| sym.to_s.upcase }
+      end
+
+      def keyword?(word)
+        if word.is_a?(Symbol)
+          keyword_symbols.member?(word)
+        else
+          # String
+          keywords.member?(word)
+        end
+      end
+
+      def instance_variable_name(word)
+        return nil unless keyword?(word)
+        return '@' + as_symbol(word).to_s
+      end
+
+      def item_class(word)
+        return nil unless keyword?(word)
+        @syntax_config[as_symbol(word)]
+      end
+
+      private
+      def as_symbol(word)
+        word.to_s.downcase.sub(/^@+/, "").to_sym
+      end
+    end # class Syntax
+
+    # Parse Key-Value object in YAML
+    class Base
+      # attr_accessor :name
+
+      def self.create_from_yaml_file(yaml_file)
+        yaml_string = File.open(File.expand_path(yaml_file)).read
+        return create_from_yaml_string(yaml_string, yaml_file)
+      end
+
+      def self.create_from_yaml_string(yaml_string, filename = nil)
+        hash = YAML.load(yaml_string, filename) || {}
+        return new(hash)
+      end
+
+      def self.define_syntax(config)
+        @syntax = Syntax.new(config)
+        @syntax.keyword_symbols.each do |sym|
+          attr_accessor sym # XXX: attr_reader is enough?
+        end
+      end
+
+      def self.syntax
+        return @syntax
+      end
+
+      def initialize(hash = {})
+        @original_hash = hash
+        (hash || {}).each do |key, val|
+          raise Mhc::ConfigurationError, "config syntax error (#{key})" unless syntax.keyword?(key)
+          var = syntax.instance_variable_name(key)
+          obj = create_subnode(key, val)
+          instance_variable_set(var, obj)
+        end
+      end
+
+      attr_reader :original_hash
+
+      def get_value(dot_separated_string = nil)
+        if dot_separated_string.to_s == ""
+          return original_hash
+        end
+
+        key, subkey = dot_separated_string.to_s.upcase.split(".", 2)
+        subnode = get_subnode(key)
+
+        if subnode.respond_to?(:get_value)
+          return subnode.get_value(subkey)
+        else
+          return subnode.to_s
+        end
+      end
+
+      def to_yaml
+        return self.to_hash.to_yaml
+      end
+
+      def to_hash
+        hash = {}
+        syntax.keywords.each do |key|
+          var = syntax.instance_variable_name(key)
+          obj = instance_variable_get(var)
+          obj = obj.respond_to?(:to_hash) ? obj.to_hash : obj.to_s
+          hash[key] = obj
+        end
+        return hash
+      end
+
+      private
+      def syntax
+        self.class.syntax
+      end
+
+      def get_subnode(key)
+        raise Mhc::ConfigurationError, "Invalid key: #{key}" unless syntax.keyword?(key)
+        return instance_variable_get(syntax.instance_variable_name(key))
+      end
+
+      def create_subnode(keyword, value)
+        item_class = syntax.item_class(keyword)
+        if item_class.is_a?(Array)
+          return List.new(item_class.first, value)
+        elsif item_class == String
+          return value.to_s
+        else
+          return item_class.new(value)
+        end
+      end
+
+    end # class Base
+
+    # Parse Array object in YAML
+    class List < Base
+      include Enumerable
+
+      def initialize(item_class, array = [])
+        @original_hash = array
+        @configs = []
+        (array || []).each do |value|
+          item = item_class.new(value)
+          @configs << item
+        end
+      end
+
+      def [](key)
+        @configs.find {|c| c.name == key}
+      end
+
+      alias_method :get_subnode, :[]
+
+      def <<(conf)
+        @configs << conf
+      end
+
+      def to_hash # XXX: actually, it returns a Array
+        return @configs.map {|c| c.respond_to?(:to_hash) ? c.to_hash : c.to_s}
+      end
+
+      def each
+        @configs.each do |conf|
+          yield conf
+        end
+      end
+    end # List
+
+    ## concrete config classes
+
+    class General < Base
+      define_syntax :tzid => String,
+                    :repository => String
+    end # class General
+
+    class SyncChannel < Base
+      define_syntax :name => String,
+                    :calendar1 => String,
+                    :calendar2 => String,
+                    :strategy => String
+    end # class SyncChannel
+
+    class Calendar < Base
+      define_syntax :name => String,
+                    :type => String,
+                    :user => String,
+                    :password => String,
+                    :url => String,
+                    :filter => Mhc::Query,
+                    :modifiers => [Mhc::Modifier]
+    end # class Calendar
+
+    # Top-Level Config
+    class Top < Base
+      define_syntax :general => General,
+                    :sync_channels => [SyncChannel],
+                    :calendars => [Calendar]
+
+      def embed_values
+        super hash
+        self.sync_channels.each do |ch|
+          # String -> Calendar
+          ch.calendar1 = calendars[ch.calendar1] if calendars[ch.calendar1]
+          ch.calendar2 = calendars[ch.calendar2] if calendars[ch.calendar2]
+        end
+      end
+    end # class Top
+
+    def self.create_from_file(file_name)
+      unless File.exists?(File.expand_path(file_name))
+        raise Mhc::ConfigurationError, "config file '#{file_name}' not found"
+      end
+      begin
+        return Top.create_from_yaml_file(file_name)
+      rescue Psych::SyntaxError, Mhc::Query::ParseError, Mhc::Modifier::ParseError => e
+        raise Mhc::ConfigurationError, e.message
+      end
+    end
+
+    def self.create_from_string(string)
+      begin
+        return Top.create_from_yaml_string(string)
+      rescue Psych::SyntaxError, Mhc::Query::ParseError, Mhc::Modifier::ParseError => e
+        raise Mhc::ConfigurationError, e.message
+      end
+    end
+
+  end # class Config
+end # module Mhc