icalPal 3.2.0 → 3.4.0

data/lib/ToICalPal.rb

@@ -6,25 +6,25 @@ class RDoc::Markup::ToICalPal < RDoc::Markup::Formatter
   # ANSI[https://www.itu.int/rec/dologin_pub.asp?lang=e&id=T-REC-T.416-199303-I!!PDF-E&type=items]
   # colors
   ANSI = {
-    'black':   30,  '#000000': '38;5;0',
-    'red':     31,  '#ff0000': '38;5;1',
-    'green':   32,  '#00ff00': '38;5;2',
-    'yellow':  33,  '#ffff00': '38;5;3',
-    'blue':    34,  '#0000ff': '38;5;4',
-    'magenta': 35,  '#ff00ff': '38;5;5',
-    'cyan':    36,  '#00ffff': '38;5;6',
-    'white':   37,  '#ffffff': '38;5;255',
-    'default': 39,  'custom': nil,
+    black:   30,  '#000000': '38;5;0',
+    red:     31,  '#ff0000': '38;5;1',
+    green:   32,  '#00ff00': '38;5;2',
+    yellow:  33,  '#ffff00': '38;5;3',
+    blue:    34,  '#0000ff': '38;5;4',
+    magenta: 35,  '#ff00ff': '38;5;5',
+    cyan:    36,  '#00ffff': '38;5;6',
+    white:   37,  '#ffffff': '38;5;255',
+    default: 39,  custom: nil,
 
     # Reminders custom colors
-    'brown':     '38;2;162;132;94',
-    'gray':      '38;2;91;98;106',
-    'indigo':    '38;2;88;86;214',
-    'lightblue': '38;2;90;200;250',
-    'orange':    '38;2;255;149;0',
-    'pink':      '38;2;255;45;85',
-    'purple':    '38;2;204;115;225',
-    'rose':      '38;2;217;166;159',
+    brown:     '38;2;162;132;94',
+    gray:      '38;2;91;98;106',
+    indigo:    '38;2;88;86;214',
+    lightblue: '38;2;90;200;250',
+    orange:    '38;2;255;149;0',
+    pink:      '38;2;255;45;85',
+    purple:    '38;2;204;115;225',
+    rose:      '38;2;217;166;159',
   }.freeze
 
   # Increased intensity
@@ -55,7 +55,7 @@ class RDoc::Markup::ToICalPal < RDoc::Markup::Formatter
   # @option opts [Array<String>] :ps List of property separators
   # @option opts [String] :ss Section separator
   def initialize(opts)
-    super(opts)
+    super
     @opts = opts
   end
 
@@ -76,10 +76,7 @@ class RDoc::Markup::ToICalPal < RDoc::Markup::Formatter
   def accept_list_start(_arg)
     begin
       return if @item['placeholder']
-    rescue
-    end
 
-    begin
       if (@item['due_date'] + ICalPal::ITIME).between?(ICalPal::ITIME + 1, $now.to_i)
         @res << "#{@opts[:ab]} " unless @opts[:nb]
         return
@@ -95,7 +92,7 @@ class RDoc::Markup::ToICalPal < RDoc::Markup::Formatter
   # @param arg [RDoc::Markup::ListItem]
   # @option arg [String] .label Contains the property name
   def accept_list_item_start(arg)
-    @res << @opts[:ps][@ps] || '    ' unless @item['placeholder']
+    @res << (@opts[:ps][@ps] || '    ') unless @item['placeholder']
     @res << colorize(*LABEL_COLOR, arg.label) << ': ' unless @opts[:npn] || NO_LABEL.any?(arg.label)
 
     @ps += 1 unless @ps == @opts[:ps].count - 1
@@ -133,7 +130,7 @@ class RDoc::Markup::ToICalPal < RDoc::Markup::Formatter
   # @param p [RDoc::Markup::Paragraph]
   # @option p [Array<String>] :parts The property's text
   def accept_paragraph(p)
-    t = p.parts.join('; ').gsub(/\n/, "\n    ")
+    t = p.parts.join('; ').gsub("\n", "\n    ")
     t = colorize(*DATE_COLOR, t) if @prop == 'datetime'
     @res << t
   end
@@ -196,10 +193,10 @@ class RDoc::Markup::ToICalPal < RDoc::Markup::Formatter
 
   # @!visibility private
 
-  # @param a [Array] Ignored
-  def accept_list_end(a) end
+  # @param _a [Array] Ignored
+  def accept_list_end(_a) end
 
-  # @param a [Array] Ignored
-  def accept_list_item_end(a) end
+  # @param _a [Array] Ignored
+  def accept_list_item_end(_a) end
 
 end

data/lib/defaults.rb

@@ -1,6 +1,7 @@
 # Does anybody really know what time it is?
-$now = ICalPal::RDT.now
-$today = ICalPal::RDT.new(*$now.to_a[0..2] + [ 0, 0, 0, $now.zone ])
+now = Time.now
+$now = ICalPal::RDT.from_time(now)
+$today = ICalPal::RDT.new(*$now.to_a[0..2] + [ 0, 0, 0 ])
 
 # Defaults
 $defaults = {
@@ -8,11 +9,11 @@ $defaults = {
     ab: '!',
     aep: [],
     bullet: '•',
-    cf: "#{ENV['HOME']}/.icalpal",
+    cf: "#{Dir.home}/.icalpal",
     color: false,
     db: [
-      "#{ENV['HOME']}/Library/Group Containers/group.com.apple.calendar/Calendar.sqlitedb",
-      "#{ENV['HOME']}/Library/Calendars/Calendar.sqlitedb",
+      "#{Dir.home}/Library/Group Containers/group.com.apple.calendar/Calendar.sqlitedb",
+      "#{Dir.home}/Library/Calendars/Calendar.sqlitedb",
     ],
     debug: Logger::WARN,
     df: '%b %-d, %Y',
@@ -73,10 +74,11 @@ $defaults = {
     n: false,
     nnr: "\n       ",
     nrd: false,
+    now: false,
     ps: [ "\n    " ],
     sa: false,
     sed: false,
-    sort: 'sdate',
+    sort: 'sctime',
     ss: "\n------------------------",
     to: nil,
     uid: false,

data/lib/event.rb

@@ -1,18 +1,20 @@
-require 'time'
+require 'timezone'
 
 module ICalPal
   # Class representing items from the <tt>CalendarItem</tt> table
   class Event
     include ICalPal
 
-    # Standard accessor with special handling for +sdate+.  Setting
-    # +sdate+ will also set +sday+.
+    # Standard accessor with special handling for +sdate+ and +edate+.  Setting
+    # those will also set +sctime+ and +ectime+ respectively.
     #
     # @param k [String] Key/property name
     # @param v [Object] Key/property value
     def []=(k, v)
       @self[k] = v
-      @self['sday'] = ICalPal::RDT.new(*self['sdate'].to_a[0..2]) if k == 'sdate'
+
+      @self['sctime'] = Time.at(@self['sdate'].to_i, in: 'UTC') if k == 'sdate'
+      @self['ectime'] = Time.at(@self['edate'].to_i, in: 'UTC') if k == 'edate'
     end
 
     # Standard accessor with special handling for +age+,
@@ -34,10 +36,10 @@ module ICalPal
           t += ' at ' unless @self['all_day'].positive?
         end
 
-        unless @self['all_day'] && @self['all_day'].positive? || @self['placeholder']
+        unless (@self['all_day'] && @self['all_day'].positive?) || @self['placeholder']
           t ||= ''
-          t += "#{@self['sdate'].strftime($opts[:tf])}" if @self['sdate']
-          t += " - #{@self['edate'].strftime($opts[:tf])}" unless $opts[:eed] || !@self['edate']
+          t += "#{@self['sctime'].strftime($opts[:tf])}" if @self['sctime']
+          t += " - #{@self['ectime'].strftime($opts[:tf])}" unless $opts[:eed] || !@self['ectime'] || @self['duration'].zero?
         end
         t
 
@@ -45,10 +47,10 @@ module ICalPal
         (@self['location'])? [ @self['location'], @self['address'] ].join(' ').chop : nil
 
       when 'notes'              # \n -> :nnr
-        (@self['notes'])? @self['notes'].strip.gsub(/\n/, $opts[:nnr]) : nil
+        (@self['notes'])? @self['notes'].strip.gsub("\n", $opts[:nnr]) : nil
 
       when 'sday'               # pseudo-property
-        ICalPal::RDT.new(*@self['sdate'].to_a[0..2])
+        RDT.new(*@self['sdate'].to_a[0..2])
 
       when 'status'             # Integer -> String
         EventKit::EKEventStatus.select { |_k, v| v == @self['status'] }.keys[0]
@@ -83,23 +85,24 @@ module ICalPal
 
       # Convert JSON arrays to Arrays
       @self['attendees'] = JSON.parse(obj['attendees'])
-      # rubocop: disable Lint/UselessAssignment
       @self['xdate'] = JSON.parse(obj['xdate']).map do |k|
-        k = RDT.new(*Time.at(k + ITIME).to_a.reverse[4..]) if k
+        RDT.from_itime(k) if k
       end
-      # rubocop: enable Lint/UselessAssignment
 
       # Convert iCal dates to normal dates
       obj.keys.select { |i| i.end_with? '_date' }.each do |k|
-        t = Time.at(obj[k] + ITIME) if obj[k]
-        @self["#{k[0]}date"] = RDT.new(*t.to_a.reverse[4..], t.zone) if t
-      end
+        next unless obj[k]
+
+        begin
+          zone = Timezone.fetch(obj['start_tz'])
+        rescue Timezone::Error::InvalidZone
+          zone = 'UTC'
+        end
 
-      if @self['start_tz'] == '_float'
-        tzoffset = Time.zone_offset($now.zone)
+        ctime = obj[k] + ITIME
 
-        @self['sdate'] = RDT.new(*(@self['sdate'].to_time - tzoffset).to_a.reverse[4..], $now.zone)
-        @self['edate'] = RDT.new(*(@self['edate'].to_time - tzoffset).to_a.reverse[4..], $now.zone)
+        @self["#{k[0]}ctime"] = Time.at(ctime)
+        @self["#{k[0]}date"] = RDT.from_time(Time.at(ctime, in: zone))
       end
 
       # Type of calendar event is from
@@ -123,14 +126,17 @@ module ICalPal
       # Sanity checks
       return events if nDays > 100_000
 
+      # If multi-day, each (unique) day needs to end at 23:59:59
+      self['edate'] = RDT.new(*@self['sdate'].to_a[0..2] + [ 23, 59, 59 ]) if nDays.positive?
+
       # Repeat for multi-day events
       (nDays + 1).times do |i|
         break if self['sdate'] > $opts[:to]
 
-        $log.debug("multi-day event #{i + 1}") if (i.positive?)
-
-        self['daynum'] = i + 1
-        events.push(clone) if in_window?(self['sdate'])
+        if in_window?(self['sdate'], self['edate'])
+          self['daynum'] = i + 1 if nDays.positive?
+          events.push(clone)
+        end
 
         self['sdate'] += 1
         self['edate'] += 1
@@ -145,78 +151,76 @@ module ICalPal
     #   All occurrences of a recurring event that are within our window
     def recurring
       stop = [ $opts[:to], (self['rdate'] || $opts[:to]) ].min
+      events = []
+      count = 1
 
       # See if event ends before we start
-      if stop < $opts[:from]
-        $log.debug("#{stop} < #{$opts[:from]}")
-        return([])
-      end
+      return events if $opts[:from] > stop
 
       # Get changes to series
-      changes = [ { 'orig_date' => -1 } ]
+      changes = [ { orig_date: -1 } ]
       changes += $rows.select { |r| r['orig_item_id'] == self['ROWID'] }
 
-      events = []
-      count = 1
-
       while self['sdate'] <= stop
         # count
         break if self['count'].positive? && count > self['count']
 
         count += 1
 
-        # Handle specifier or clone self
-        if self['specifier'] && self['specifier'].length.positive?
-          occurrences = get_occurrences(changes)
-        else
-          occurrences = [ clone ]
-        end
+        # Handle specifier
+        o = []
+        o.push(self) unless self['specifier'] && self['specifier'].length.positive?
+        o += occurrences if self['specifier'] && self['specifier'].length.positive?
 
         # Check for changes
-        occurrences.each do |occurrence|
-          changes.each do |change|
-            next if change['orig_date'] == self['sdate'].to_i - ITIME
+        o.each do |occurrence|
+          skip = false
+
+          changes[1..].each do |change|
+            cdate = Time.at(change['start_date'] + ITIME).to_a[3..5].reverse
+            odate = occurrence['sdate'].ymd
 
-            events.push(occurrence) if in_window?(occurrence['sdate'], occurrence['edate'])
+            skip = true if cdate == odate
           end
-        end
 
-        break if self['specifier']
+          events.push(clone(occurrence)) if in_window?(occurrence['sdate'], occurrence['edate']) && !skip
+        end
 
-        apply_frequency!
+        # Handle frequency and interval
+        apply_frequency! if self['frequency'] && self['interval']
       end
 
       # Remove exceptions
       events.delete_if { |event| event['xdate'].any?(event['sdate']) }
 
-      events
+      events.uniq { |e| e['sdate'] }
     end
 
     private
 
     # @!visibility public
 
-    # @return a deep clone of self
-    def clone
-      Marshal.load(Marshal.dump(self))
+    # Deep clone an object
+    #
+    # @param obj [Object]
+    # @return [Object] a deep clone of obj
+    def clone(obj = self)
+      Marshal.load(Marshal.dump(obj))
     end
 
-    # Get next occurences of a recurring event from a specifier
+    # Get next occurrences of a recurring event given a specifier
     #
-    # @param _changes [Array] Recurrence changes for the event
-    # @return [Array<IcalPal::Event>]
-    def get_occurrences(_changes)
-      occurrences = []
+    # @return [Array<ICalPal::Event>]
+    def occurrences
+      o = []
 
       dow = DOW.keys
-      dom = [ nil ]
+      dom = []
       moy = 1..12
       nth = nil
 
-      specifier = (self['specifier'])? self['specifier'] : []
-
       # Deconstruct specifier
-      specifier.split(';').each do |k|
+      self['specifier'].split(';').each do |k|
         j = k.split('=')
 
         # D=Day of the week, M=Day of the month, O=Month of the year, S=Nth
@@ -230,38 +234,55 @@ module ICalPal
       end
 
       # Build array of DOWs
-      dows = [ nil ]
-      dow.each { |d| dows.push(DOW[d[-2..].to_sym]) }
+      dows = []
+      dow.each do |d|
+        dows.push(DOW[d[-2..].to_sym])
+        nth = d[0..-3].to_i if [ '+', '-' ].include? d[0]
+      end
 
       # Months of the year (O)
-      moy.each do |m|
-        next unless m
+      moy.each do |mo|
+        m = mo.to_i
+
+        # Set dates to the first of <m>
+        nsdate = RDT.new(self['sdate'].year, m, 1, self['sdate'].hour, self['sdate'].minute, self['sdate'].second)
+        nedate = RDT.new(self['edate'].year, m, 1, self['edate'].hour, self['edate'].minute, self['edate'].second)
+
+        # ...but not in the past
+        nsdate >>= 12 if nsdate.month < m
+        nedate >>= 12 if nedate.month < m
+
+        next if nsdate > $opts[:to]
+        next if ((nedate >> 1) - 1) < $opts[:from]
 
-        nsdate = RDT.new(self['sdate'].year, m.to_i, 1)
-        nedate = RDT.new(self['edate'].year, m.to_i, 1)
+        c = clone
 
         # Days of the month (M)
-        dom.each do |x|
-          next unless x
+        dom.each do |day|
+          c['sdate'] = RDT.new(nsdate.year, nsdate.month, day.to_i)
+          c['edate'] = RDT.new(nedate.year, nedate.month, day.to_i)
 
-          self['sdate'] = RDT.new(nsdate.year, nsdate.month, x.to_i)
-          self['edate'] = RDT.new(nedate.year, nedate.month, x.to_i)
-          occurrences.push(clone)
+          o.push(clone(c)) if in_window?(c['sdate'], c['edate'])
         end
 
         # Days of the week (D)
-        if nth
-          self['sdate'] = ICalPal.nth(nth, dows, nsdate)
-          self['edate'] = ICalPal.nth(nth, dows, nedate)
-          occurrences.push(clone)
-        elsif dows[0]
-          self['sdate'] = RDT.new(nsdate.year, m.to_i, nsdate.wday)
-          self['edate'] = RDT.new(nedate.year, m.to_i, nedate.wday)
-          occurrences.push(clone)
+        dows.each do |day|
+          if nth
+            c['sdate'] = ICalPal.nth(nth, day, nsdate)
+            c['edate'] = ICalPal.nth(nth, day, nedate)
+          else
+            diff = day - c['sdate'].wday
+            diff += 7 if diff.negative?
+
+            c['sdate'] += diff
+            c['edate'] += diff
+          end
+
+          o.push(clone(c)) if in_window?(c['sdate'], c['edate'])
         end
       end
 
-      occurrences
+      o
     end
 
     # Apply frequency and interval
@@ -278,7 +299,7 @@ module ICalPal
         when 'yearly'  then self[d] >>= self['interval'] * 12
         else $log.error("Unknown frequency: #{self['frequency']}")
         end
-      end if self['frequency'] && self['interval']
+      end
     end
 
     # Check if an event starts or ends between from and to, or if it's
@@ -287,8 +308,8 @@ module ICalPal
     # @param s [RDT] Event start
     # @param e [RDT] Event end
     # @return [Boolean]
-    def in_window?(s, e = s)
-      if $opts[:n]
+    def in_window?(s, e)
+      if $opts[:now]
         if ($now >= s && $now < e)
           $log.debug("now: #{s} to #{e} vs. #{$now}")
           true

data/lib/icalPal.rb

@@ -19,8 +19,7 @@ module ICalPal
   # @return [Class] The subclass of ICalPal
   def self.call(klass)
     case klass
-    when 'accounts' then Store
-    when 'stores' then Store
+    when 'accounts', 'stores' then Store
     when 'calendars' then Calendar
     when 'events' then Event
     when 'tasks' then Reminder
@@ -32,7 +31,7 @@ module ICalPal
 
   # Load data
   def self.load_data(db_file, q)
-    $log.debug(q.gsub(/\n/, ' '))
+    $log.debug(q.gsub("\n", ' '))
 
     rows = []
 
@@ -93,8 +92,7 @@ module ICalPal
   # @param headers [Array] Key names used as the header row in a CSV::Table
   # @return [CSV::Row] The +Store+, +Calendar+, or +CalendarItem+ as a CSV::Row
   def to_csv(headers)
-    values = []
-    headers.each { |h| values.push((@self[h].respond_to?(:gsub))? @self[h].gsub(/\n/, '\n') : @self[h]) }
+    values = headers.map { |h| (@self[h].respond_to?(:gsub))? @self[h].gsub("\n", '\n') : @self[h] }
 
     CSV::Row.new(headers, values)
   end
@@ -110,48 +108,17 @@ module ICalPal
     retval
   end
 
-  # Convert a key/value pair to XML.  The value should be +nil+, +String+,
-  # +Integer+, +Array+, or +ICalPal::RDT+
-  #
-  # @param key The key
-  # @param value The value
-  # @return [String] The key/value pair in a simple XML format
-  def xmlify(key, value)
-    case value
-    # Nil
-    when NilClass then "<#{key}/>"
-
-    # String, Integer
-    when String then "<#{key}>#{value}</#{key}>"
-    when Integer then "<#{key}>#{value}</#{key}>"
-
-    # Array
-    when Array
-      # Treat empty arrays as nil values
-      xmlify(key, nil) if value[0].nil?
-
-      retval = ''
-      value.each { |x| retval += xmlify("#{key}0", x) }
-      "<#{key}>#{retval}</#{key}>"
-
-    # RDT
-    when ICalPal::RDT then "<#{key}>#{value}</#{key}>"
-
-    # Unknown
-    else "<#{key}>#{value}</#{key}>"
-    end
-  end
-
   # Get the +n+'th +dow+ in month +m+
   #
   # @param n [Integer] Integer between -4 and +4
-  # @param dow [Array] Days of the week
+  # @param dow [Integer] Day of the week
   # @param m [RDT] The RDT with the year and month we're searching
   # @return [RDT] The resulting day
   def self.nth(n, dow, m)
-    # Get the number of days in the month
-    a = [ ICalPal::RDT.new(m.year, m.month, 1) ] # First of this month
-    a[1] = (a[0] >> 1) - 1                       # First of next month, minus 1 day
+    # Get the number of days in the month by advancing to the first of
+    # the next month, then going back one day
+    a = [ RDT.new(m.year, m.month, 1, m.hour, m.minute, m.second) ]
+    a[1] = (a[0] >> 1) - 1
 
     # Reverse it if going backwards
     a.reverse! if n.negative?
@@ -159,7 +126,7 @@ module ICalPal
 
     j = 0
     a[0].step(a[1], step) do |i|
-      j += step if dow.any?(i.wday)
+      j += step if dow == i.wday
       return i if j == n
     end
   end
@@ -170,7 +137,7 @@ module ICalPal
   # Days of the week abbreviations used in recurrence rules
   #
   # <tt><i>SU, MO, TU, WE, TH, FR, SA</i></tt>
-  DOW = { 'SU': 0, 'MO': 1, 'TU': 2, 'WE': 3, 'TH': 4, 'FR': 5, 'SA': 6 }.freeze
+  DOW = { SU: 0, MO: 1, TU: 2, WE: 3, TH: 4, FR: 5, SA: 6 }.freeze
 
   # @!group Accessors
   def [](k)
@@ -188,5 +155,13 @@ module ICalPal
   def values
     @self.values
   end
+
+  # Like inspect, but easier for humans to read
+  #
+  # @return [Array<String>] @self as a key=value array, sorted by key
+  def dump
+    @self.keys.sort.map { |k| "#{k}: #{@self[k]}" }
+  end
+
   # @!endgroup
 end

data/lib/options.rb

@@ -27,9 +27,9 @@ module ICalPal
       @op = OptionParser.new
       @op.summary_width = 23
       @op.banner += ' [-c] COMMAND'
-      @op.version = ICalPal::VERSION
+      @op.version = VERSION
 
-      @op.accept(ICalPal::RDT) { |s| ICalPal::RDT.conv(s) }
+      @op.accept(RDT) { |s| RDT.conv(s) }
 
       # head
       @op.on_head("\nCOMMAND must be one of the following:\n\n")
@@ -83,8 +83,8 @@ module ICalPal
       # dates
       @op.separator("\nChoosing dates:\n\n")
 
-      @op.on('--from=DATE', ICalPal::RDT, 'List events starting on or after DATE')
-      @op.on('--to=DATE', ICalPal::RDT, 'List events starting on or before DATE',
+      @op.on('--from=DATE', RDT, 'List events starting on or after DATE')
+      @op.on('--to=DATE', RDT, 'List events starting on or before DATE',
              'DATE can be yesterday, today, tomorrow, +N, -N, or anything accepted by DateTime.parse()',
              'See https://ruby-doc.org/stdlib-2.6.1/libdoc/date/rdoc/DateTime.html#method-c-parse')
       @op.separator('')
@@ -172,6 +172,14 @@ module ICalPal
       @op.on_tail('%s%s %sAdditional arguments' % pad('ICALPAL'))
       @op.on_tail('%s%s %sAdditional arguments from a file' % pad('ICALPAL_CONFIG'))
       @op.on_tail("%s%s %s(default: #{$defaults[:common][:cf]})" % pad(''))
+
+      @op.on_tail('')
+
+      note = 'Do not quote or escape values.'
+      note += '  Options set in ICALPAL override ICALPAL_CONFIG.'
+      note += '  Options on the command line override ICALPAL.'
+
+      @op.on_tail("#{@op.summary_indent}#{note}")
     end
 
     # Parse options from the CLI and merge them with other sources
@@ -184,11 +192,45 @@ module ICalPal
         env = {}
         cf = {}
 
-        # Load from CLI, environment, configuration file
+        # Load from CLI
         @op.parse!(into: cli)
-        @op.parse!(ENV['ICALPAL'].split, into: env) rescue nil
-        cli[:cf] ||= ENV['ICALPAL_CONFIG'] || $defaults[:common][:cf]
-        @op.parse!(File.read(File.expand_path(cli[:cf])).split, into: cf) rescue nil
+
+        # Environment variable needs special parsing.
+        # OptionParser.parse doesn't handle whitespace in a
+        # comma-separated value.
+        begin
+          o = []
+
+          ENV['ICALPAL'].gsub(/^-/, ' -').split(' -').each do |e|
+            a = e.split(' ', 2)
+
+            if a[0]
+              o.push("-#{a[0]}")
+              o.push(a[1]) if a[1]
+            end
+          end
+
+          @op.parse!(o, into: env)
+        end if ENV['ICALPAL']
+
+        # Configuration file needs special parsing for the same reason
+        begin
+          o = []
+
+          cli[:cf] ||= ENV['ICALPAL_CONFIG'] || $defaults[:common][:cf]
+
+          File.read(File.expand_path(cli[:cf])).split("\n").each do |line|
+            a = line.split(' ', 2)
+
+            if a[0] && a[0][0] != '#'
+              o.push(a[0])
+              o.push(a[1]) if a[1]
+            end
+          end
+
+          @op.parse!(o, into: cf)
+        rescue StandardError
+        end
 
         cli[:cmd] ||= @op.default_argv[0]
         cli[:cmd] ||= env[:cmd] if env[:cmd]
@@ -197,7 +239,7 @@ module ICalPal
 
         # Parse eventsNow and eventsToday commands
         cli[:cmd].match('events(Now|Today)(\+[0-9]+)?') do |m|
-          cli[:n] = true if m[1] == 'Now'
+          cli[:now] = true if m[1] == 'Now'
           cli[:days] = (m[1] == 'Today')? m[2].to_i + 1 : 1
 
           cli[:from] = $today
@@ -244,6 +286,7 @@ module ICalPal
           opts[:to] += 1 if opts[:to]
           opts[:to] ||= opts[:from] + 1 if opts[:from]
           opts[:to] = opts[:from] + opts[:days] if opts[:days]
+          opts[:to] = RDT.new(*opts[:to].to_a[0..2] + [ 23, 59, 59 ])
           opts[:days] ||= Integer(opts[:to] - opts[:from])
           opts[:from] = $now if opts[:n]
         end