icalPal 2.0.0 → 2.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7f91434d02dd357bcd02342b2d79418b91e23ec789a6a069a01f2f508685d8ca
-  data.tar.gz: 51cfa58c767650d0c7e62213ad4a58dbe9a2d5fc42f17d5ce18c8b65e6a178be
+  metadata.gz: 76513daaf66f3c4aa8b2a9e1703f275ba5d5a65ef9e8b71a86b263c59d409fdd
+  data.tar.gz: c06430cfbdd5c415dae2d154b774c1ba1feb210534e6511f9fbb1cf12052cbfd
 SHA512:
-  metadata.gz: 20b4a10406535baf33986bd6bdf859376a6dfd7055815b2f263d6971d6e8255d5d60fa019c49c4de54ec3a4178e3752136478aafa5937176c80adfdfc36cc8aa
-  data.tar.gz: 8a5fbde979186c3347ed6c8c52f3b39b81fc6b303680e1923c0b011583b1c63651dc65b33e4e34a3794b5d01430cb7bd4dd66b2f12510374f13626e438aef079
+  metadata.gz: 290f75e744ea88673f474c478565ec281a2b8eae8dcfc730ccb7abf88f33b5fdc8c10baf53b971c336d48a3a4abc3f311e02973e9f2295fea2d134e3d987a499
+  data.tar.gz: af3d7eec48d408f2c7ff15af7cdddcf581fa60574e1ab3602efb32e6625bfa61833919194108fe012fbae35a312c14af6ffbf628be4921d7cd11651e67717151

data/README.md

@@ -4,16 +4,30 @@
 
 ## Description
 
-icalPal is a command-line tool to query a macOS Calendar database for
-accounts, calendars, and events.  It can be run on any system with
-[Ruby](https://www.ruby-lang.org/) and access to a Calendar database
-file, or a Reminders database.
+icalPal is a command-line tool to query a macOS Calendar and Reminders
+databases for accounts, calendars, events, and tasks.  It can be run
+on any system with [Ruby](https://www.ruby-lang.org/) and access to a
+Calendar or Reminders database.
 
 ## Installation
 
+As a system-wide Ruby gem:
+
 ```
 gem install icalPal
-icalPal events
+```
+
+or in your home diretory:
+
+```
+gem install --user-install icalPal
+```
+
+As a Homebrew formula:
+
+```
+brew tap ajrosen/icalPal
+brew install icalPal
 ```
 
 ## Features
@@ -21,7 +35,8 @@ icalPal events
 ### Compatability with [icalBuddy](https://github.com/ali-rantakari/icalBuddy)
 
 icalPal tries to be compatible with icalBuddy for command-line options
-and for output.  There are a few differences to be aware of.
+and for output.  There are a some important differences to be aware
+of.
 
 * Options require two hyphens, except for single-letter options that require one hyphen
 * *eventsFrom* is not supported.  Instead there is *--from*, *--to*, and *--days*
@@ -184,27 +199,6 @@ Environment variables:
                             (default: /Users/ajr/.icalPal)
 ```
 
-## History
-
-I have used icalBuddy for many years.  It's great for scripting,
-automation, and as a desktop widget for apps like
-[GeekTool](https://www.tynsoe.org/geektool/) and
-[Übersicht](https://tracesof.net/uebersicht/).
-
-As with many applications, I started to run into some limitations in
-icalBuddy.  The biggest being that active development ended in 2014.
-It's only thanks to the efforts of [Jim
-Lawton](https://github.com/jimlawton) that it even compiles anymore.
-
-Instead of trying to understand and extend the existing code, I chose
-to start anew using my language of choice.  Using Ruby means icalPal
-is multi-platform.  It also meant *much* less code; about 1,200 lines
-vs. 7,000.
-
-I won't pretend to understand **why** you would want this on Linux or
-Windows.  But since icalPal is written in Ruby and gets its data
-directly from the Calendar database file instead of an API, you *can*.
-
 ## Output formats
 
 icalPal supports several output formats.  The **default** format tries
@@ -242,5 +236,29 @@ objects, one for each of the item's properties:
 
 The document will also include a number of
 [RDoc::Markup::Verbatim](https://ruby-doc.org/stdlib-2.6.10/libdoc/rdoc/rdoc/RDoc/Markup/Verbatim.html)
+and
+[RDoc::Markup::Raw](https://ruby-doc.org/stdlib-2.6.10/libdoc/rdoc/rdoc/RDoc/Markup/Raw.html)
 items.  They are not included in the output, but are used to pass
 information about the item and property to the default formatter.
+
+## History
+
+I used icalBuddy for many years.  It's great for scripting,
+automation, and as a desktop widget for apps like
+[GeekTool](https://www.tynsoe.org/geektool/) and
+[Übersicht](https://tracesof.net/uebersicht/).
+
+As with many applications, I started to run into some limitations in
+icalBuddy.  The biggest being that active development ended in 2014.
+It's only thanks to the efforts of [Jim
+Lawton](https://github.com/jimlawton) that it even compiles anymore.
+
+Instead of trying to understand and extend the existing code, I chose
+to start anew using my language of choice: Ruby.  Using Ruby meant
+there is *much* less code; about 1,600 lines vs. 7,000.  It also means
+icalPal is multi-platform.
+
+I won't pretend to understand **why** you would want to run this on
+Linux or Windows.  But since icalPal is written in Ruby and gets its
+data directly from the Calendar and Reminders database files instead
+of an API, you *can*.

data/bin/icalPal

@@ -1,16 +1,25 @@
 #!/usr/bin/env ruby
-# *-*- mode: enh-ruby -*-*
 
-require 'logger'
+begin
+  require 'logger'
+
+  require 'csv'
+  require 'json'
+  require 'rdoc'
+  require 'sqlite3'
+  require 'yaml'
+
+  require_relative '../lib/icalPal'
+  require_relative '../lib/options'
+rescue LoadError => e
+  dep = e.message[/-- (.*)/, 1]
 
-require 'csv'
-require 'json'
-require 'rdoc'
-require 'sqlite3'
-require 'yaml'
+  $stderr.puts "FATAL: icalPal is missing a dependency: #{dep}"
+  $stderr.puts
+  $stderr.puts "Install with 'gem install --user-install #{dep}'"
 
-require_relative '../lib/icalPal'
-require_relative '../lib/options'
+  exit
+end
 
 
 ##################################################
@@ -121,6 +130,18 @@ $rows.each_with_index do |row, i|
     next
   end
 
+  # --regexp
+  if $opts[:match]
+    r = $opts[:match].split('=')
+
+    if item[r[0]].to_s.respond_to?(:match)
+      unless item[r[0]].to_s.match(Regexp.new(r[1].to_s, Regexp::IGNORECASE)) then
+        $log.debug(":regex")
+        next
+      end
+    end
+  end
+
   if ICalPal::Event === item
     # Check for all-day and cancelled events
     if $opts[:ea] && item['all_day'].positive? then

data/lib/defaults.rb

@@ -26,6 +26,7 @@ $defaults = {
     output: 'default',
     ps: [ "\n  " ],
     r: false,
+    match: nil,
     sc: false,
     sd: false,
     sep: false,

data/lib/event.rb

@@ -110,18 +110,22 @@ module ICalPal
     #   If an event spans multiple days, the return value will contain
     #   a unique {Event} for each day that falls within our window
     def non_recurring
-      retval = []
+      events = []
 
       # Repeat for multi-day events
       ((self['duration'] / 86400).to_i + 1).times do |i|
+        break if self['sdate'] > $opts[:to]
+
         $log.debug("multi-day event #{i + 1}") if (i > 0)
+
         self['daynum'] = i + 1
-        retval.push(clone) if in_window?(self['sdate'])
+        events.push(clone) if in_window?(self['sdate'])
+
         self['sdate'] += 1
         self['edate'] += 1
       end
 
-      retval
+      events
     end
 
     # Check recurring events
@@ -129,35 +133,49 @@ module ICalPal
     # @return [Array<Event>]
     #   All occurrences of a recurring event that are within our window
     def recurring
-      retval = []
+      stop = [ $opts[:to], (self['rdate'] || $opts[:to]) ].min
 
       # See if event ends before we start
-      stop = [ $opts[:to], (self['rdate'] || $opts[:to]) ].min
       if stop < $opts[:from] then
         $log.debug("#{stop} < #{$opts[:from]}")
-        return(retval)
+        return(Array.new)
       end
 
       # Get changes to series
-      changes = $rows.select { |r| r['orig_item_id'] == self['ROWID'] }
+      changes = [ { 'orig_date' => -1 } ]
+      changes += $rows.select { |r| r['orig_item_id'] == self['ROWID'] }
+
+      events = []
+      count = 1
 
-      i = 1
       while self['sdate'] <= stop
-        if self['count'].positive? && i > self['count'] then
-          $log.debug("count exceeded: #{i} > #{self['count']}")
-          return(retval)
+        # count
+        break if self['count'].positive? and count > self['count']
+        count += 1
+
+        # Handle specifier or clone self
+        if self['specifier'] and self['specifier'].length.positive?
+          occurrences = get_occurrences(changes)
+        else
+          occurrences = [ clone ]
         end
-        i += 1
 
-        unless @self['xdate'].any?(@self['sdate']) # Exceptions?
-          o = get_occurrences(changes)
-          o.each { |r| retval.push(r) if in_window?(r['sdate'], r['edate']) }
+        # Check for changes
+        occurrences.each do |occurrence|
+          changes.each do |change|
+            next if change['orig_date'] == self['sdate'].to_i - ITIME
+            events.push(occurrence) if in_window?(occurrence['sdate'], occurrence['edate'])
+          end
         end
 
+        break if self['specifier']
         apply_frequency!
       end
 
-      retval
+      # Remove exceptions
+      events.delete_if { |event| event['xdate'].any?(event['sdate']) }
+
+      return(events)
     end
 
     private
@@ -166,67 +184,72 @@ module ICalPal
 
     # @return a deep clone of self
     def clone()
-      self['stime'] = @self['sdate'].to_i
-      self['etime'] = @self['edate'].to_i
-
       Marshal.load(Marshal.dump(self))
     end
 
-    # Get next occurences of a recurring event
+    # Get next occurences of a recurring event from a specifier
     #
     # @param changes [Array] Recurrence changes for the event
     # @return [Array<IcalPal::Event>]
     def get_occurrences(changes)
-      ndate = self['sdate']
-      odays = []
-      retval = []
-
-      # Deconstruct specifier(s)
-      if self['specifier']
-        self['specifier'].split(';').each do |k|
-          j = k.split('=')
-
-          # M=Day of the month, O=Month of the year, S=Nth
-          case j[0]
-          when 'M' then ndate = RDT.new(ndate.year, ndate.month, j[1].to_i)
-          when 'O' then ndate = RDT.new(ndate.year, j[1].to_i, ndate.day)
-          when 'S' then @self['specifier'].sub!(/D=0/, "D=+#{j[1].to_i}")
-          end
-
-          # No time travel!
-          ndate = self['sdate'] if ndate <= self['sdate']
+      occurrences = []
+
+      dow = DOW.keys
+      dom = [ nil ]
+      moy = 1..12
+      nth = nil
+
+      specifier = self['specifier']? self['specifier'] : []
+
+      # Deconstruct specifier
+      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
+        case j[0]
+        when 'D' then dow = j[1].split(',')
+        when 'M' then dom = j[1].split(',')
+        when 'O' then moy = j[1].split(',')
+        when 'S' then nth = j[1].to_i
+        else $log.warn("Unknown specifier: #{k}")
         end
+      end
 
-        # D=Day of the week
-        self['specifier'].split(';').each do |k|
-          j = k.split('=')
+      # Build array of DOWs
+      dows = [ nil ]
+      dow.each { |d| dows.push(DOW[d[-2..-1].to_sym]) }
 
-          odays = j[1].split(',') if j[0] == 'D'
-        end
-      end
+      # Months of the year (O)
+      moy.each do |m|
+        next unless m
 
-      # Deconstruct occurence day(s)
-      odays.each do |n|
-        dow = DOW[n[-2..-1].to_sym]
-        ndate += 1 until ndate.wday == dow
-        ndate = ICalPal.nth(Integer(n[0..1]), n[-2..-1], ndate) unless (n[0] == '0')
+        nsdate = RDT.new(self['sdate'].year, m.to_i, 1)
+        nedate = RDT.new(self['edate'].year, m.to_i, 1)
 
-        # Check for changes
-        changes.detect(
-          proc {
-            self['sdate'] = RDT.new(*ndate.to_a[0..2], *self['sdate'].to_a[3..])
-            self['edate'] = RDT.new(*ndate.to_a[0..2], *self['edate'].to_a[3..])
-            retval.push(clone)
-          }) { |i| @self['sday'] == i['sday'] }
-      end
+        # Days of the month (M)
+        dom.each do |x|
+          next unless x
 
-      # Check for changes
-      changes.detect(
-        proc {
-          retval.push(clone)
-        }) { |i| @self['sday'] == i['sday'] } unless retval.count.positive?
+          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)
+        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)
+        else
+          if 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)
+          end
+        end
+      end
 
-      retval
+      return(occurrences)
     end
 
     # Apply frequency and interval
@@ -241,6 +264,7 @@ module ICalPal
         when 'weekly'  then self[d] +=  self['interval'] * 7
         when 'monthly' then self[d] >>= self['interval']
         when 'yearly'  then self[d] >>= self['interval'] * 12
+        else $log.error("Unknown frequency: #{self['frequency']}")
         end
       end if self['frequency'] && self['interval']
     end

data/lib/icalPal.rb

@@ -58,6 +58,9 @@ module ICalPal
     rescue SQLite3::BusyException => e
       $log.error("Non-fatal error closing database #{db.filename}")
 
+    rescue SQLite3::SQLException => e
+      $log.info("#{db_file}: #{e}")
+
     rescue SQLite3::Exception => e
       abort("#{db_file}: #{e}")
 
@@ -92,32 +95,53 @@ module ICalPal
     CSV::Row::new(headers, values)
   end
 
+  # Convert +self+ to XML
+  #
   # @return [String] All fields in a simple XML format: <field>value</field>.
   # Fields with empty values return <field/>.
   def to_xml
     retval = ""
-
-    @self.keys.each do |k|
-      v = @self[k]
-
-      if v.respond_to?(:length) then
-        if v.length == 0 or v[0] == nil then
-          retval += "<#{k}/>"
-        else
-          # Keep non-blank and whitespace, except form feeds and vertical whitespace
-          v = v.gsub(/[^[[:print:]][[:space:]]]/, '.').gsub(/[\f\v]/, '.')
-          retval += "<#{k}>#{v}</#{k}>"
-        end
-      end
-    end
+    @self.keys.each { |k| retval += xmlify(k, @self[k]) }
 
     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 return("<#{key}/>")
+
+    # String, Integer
+    when String then return("<#{key}>#{value}</#{key}>")
+    when Integer then return("<#{key}>#{value}</#{key}>")
+
+    # Array
+    when Array then
+      # Treat empty arrays as nil values
+      return(xmlify(key, nil)) if value[0] == nil 
+
+      retval = ""
+      value.each { |x| retval += xmlify("#{key}0", x) }
+      return("<#{key}>#{retval}</#{key}>")
+
+    # RDT
+    when ICalPal::RDT then return("<#{key}>#{value.to_s}</#{key}>")
+
+    # Unknown
+    else return("<#{key}>#{value.to_s}</#{key}>")
+    end
+  end
+
   # Get the +n+'th +dow+ in month +m+
   #
   # @param n [Integer] Integer between -4 and +4
-  # @param dow [String] Day of the week abbreviation from ICalPal::DOW
+  # @param dow [Array] Days 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)
@@ -131,7 +155,7 @@ module ICalPal
 
     j = 0
     a[0].step(a[1], step) do |i|
-      j += step if i.wday == DOW[dow.to_sym]
+      j += step if dow.any?(i.wday)
       return i if j == n
     end
   end

data/lib/options.rb

@@ -55,7 +55,7 @@ module ICalPal
             "Print as FORMAT (default: #{$defaults[:common][:output]})", "[#{OUTFORMATS.join(', ')}]")
       
       # include/exclude
-      @op.separator("\nIncluding/excluding calendars:\n\n")
+      @op.separator("\nIncluding/excluding accounts, calendars, items:\n\n")
 
       @op.on('--is=ACCOUNTS', Array, 'List of accounts to include')
       @op.on('--es=ACCOUNTS', Array, 'List of accounts to exclude')
@@ -73,6 +73,9 @@ module ICalPal
       @op.on('--il=LISTS', Array, 'List of reminder lists to include')
       @op.on('--el=LISTS', Array, 'List of reminder lists to exclude')
 
+      @op.separator('')
+      @op.on('--match=FIELD=REGEXP', String, 'Include only items whose FIELD matches REGEXP (ignoring case)')
+
       # dates
       @op.separator("\nChoosing dates:\n\n")
 

data/lib/version.rb

@@ -1,3 +1,3 @@
 module ICalPal
-  VERSION = '2.0.0'
+  VERSION = '2.2.0'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: icalPal
 version: !ruby/object:Gem::Version
-  version: 2.0.0
+  version: 2.2.0
 platform: ruby
 authors:
 - Andy Rosen
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-04-14 00:00:00.000000000 Z
+date: 2024-05-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: sqlite3
@@ -81,7 +81,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.4
+rubygems_version: 3.5.9
 signing_key:
 specification_version: 4
 summary: Command-line tool to query the macOS Calendar