icalPal 2.1.0 → 3.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4dab143a05d8a63ae36b721ca6ba53180c75d8b4dd0f0cebdc84fb533968c248
-  data.tar.gz: 8d243a120762c90059e4206a2deb5e79b821e558cf9ad9a437ad84fbfbb6a21b
+  metadata.gz: 25a711f9e4887a81dafccbc57e0a2fa84530dc8cee81e58f0d5df6041783bec2
+  data.tar.gz: 698a498065687f7a7d06e6c316d1937bfc3b1a58d7a661b612bb8d39b5429318
 SHA512:
-  metadata.gz: 24f4b88c592e59f2ffbc116761d6da41b60a7e5d4554feea9bdb023450967eaa7921f5c4708a66bf76554926ab4e0ca52965470f7576cef1cce5aec9a6112cbb
-  data.tar.gz: d69cc1d2cd63072020a4059a352ccdb2262a189e10c3c4e1891bd1c953ea2cb60a577fc83bd2ab55b561d0a752b0fb4198495bc2a5f57909d4216101cc7ea012
+  metadata.gz: 9cf18231c95a94b663e1a41ecd16326f447fb038864677ad05ba2a6fa5f684ae999732401ff30b9df1b0739ff31f78f7b0385e3f7774d5260b9cfbc37a6d2680
+  data.tar.gz: d3aaf37df004da104518e80463c2bc6933ba87277fc9c913bb73a4653055a93417694fb1de655d1c3776f3d47d45afaf241b5ba59361894bafa7ebd1bf253c29

data/README.md

@@ -1,10 +1,10 @@
-[![Gem Version](https://badge.fury.io/rb/icalPal.svg)](https://badge.fury.io/rb/icalPal)
+[![Gem Version](https://badge.fury.io/rb/icalpal.svg)](https://badge.fury.io/rb/icalpal)
 
-# icalPal
+# icalpal
 
 ## Description
 
-icalPal is a command-line tool to query a macOS Calendar and Reminders
+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.
@@ -14,27 +14,27 @@ Calendar or Reminders database.
 As a system-wide Ruby gem:
 
 ```
-gem install icalPal
+gem install icalpal
 ```
 
 or in your home diretory:
 
 ```
-gem install --user-install icalPal
+gem install --user-install icalpal
 ```
 
 As a Homebrew formula:
 
 ```
-brew tap ajrosen/icalPal
-brew install icalPal
+brew tap ajrosen/icalpal
+brew install icalpal
 ```
 
 ## Features
 
 ### Compatability with [icalBuddy](https://github.com/ali-rantakari/icalBuddy)
 
-icalPal tries to be compatible with icalBuddy for command-line options
+icalpal tries to be compatible with icalBuddy for command-line options
 and for output.  There are a some important differences to be aware
 of.
 
@@ -48,17 +48,17 @@ of.
 
 ### Additional commands
 
-```icalPal accounts```
+```icalpal accounts```
 
-Shows a list of enabled Calendar accounts.  Internally they are known as *Stores*; you can run ```icalPal stores``` instead.
+Shows a list of enabled Calendar accounts.  Internally they are known as *Stores*; you can run ```icalpal stores``` instead.
 
-```icalPal datedTasks```
+```icalpal datedTasks```
 
 Shows only reminders that have a due date.
 
 ### Additional options
 
-* Options can be abbreviated, so long as they are unique.  Eg., ```icalPal -c ev --da 3``` is the same as ```icalPal -c events --days 3```.
+* Options can be abbreviated, so long as they are unique.  Eg., ```icalpal -c ev --da 3``` is the same as ```icalpal -c events --days 3```.
 * The ```-c``` part is optional, but you cannot abbreviate the command if you leave it off.
 * Use ```-o``` to print the output in different formats.  CSV or JSON are intertesting choices.
 * Copy your Calendar database file and use ```--db``` on it.
@@ -68,12 +68,13 @@ Shows only reminders that have a due date.
 * ```--aep``` is like ```--iep```, but *adds* to the default property list instead of replacing it.
 * ```--sep``` to separate by any property, not just calendar (```--sc```) or date (```--sd```)
 * ```--color``` uses a wider color palette.  Calendar colors are what you have chosen in the Calendar app.  Not supported in all terminals, but looks great in [iTerm2](https://iterm2.com/).
+* ```--match``` lets you filter the results of any command to items where a *FIELD* matches a regular expression.  Eg., ```--match notes=zoom.us``` to show only Zoom meeetings
 
-Because icalPal is written in Ruby, and not a native Mac application, you can run it just about anywhere.  It's been tested with the version of Ruby (2.6.10) included with macOS.
+Because icalpal is written in Ruby, and not a native Mac application, you can run it just about anywhere.  It's been tested with the version of Ruby (2.6.10) included with macOS.
 
 ## Usage
 
-icalPal: Usage: icalPal [options] [-c] COMMAND
+icalpal: Usage: icalpal [options] [-c] COMMAND
 
 COMMAND must be one of the following:
 ```
@@ -95,7 +96,7 @@ Global options:
         --db=DB             Use DB file instead of Calendar (default: /Users/ajr/Library/Calendars/Calendar.sqlitedb)
                             For the tasks commands this should be a directory containing .sqlite files
                             (default: /Users/ajr/Library/Group Containers/group.com.apple.reminders/Container_v1/Stores)
-        --cf=FILE           Set config file path (default: /Users/ajr/.icalPal)
+        --cf=FILE           Set config file path (default: /Users/ajr/.icalpal)
     -o, --output=FORMAT     Print as FORMAT (default: default)
                             [ansi, csv, default, hash, html, json, md, rdoc, remind, toc, xml, yaml]
 ```
@@ -114,6 +115,9 @@ Including/excluding calendars and reminders:
 
         --il=LISTS          List of reminder lists to include
         --el=LISTS          List of reminder lists to exclude
+
+        --match=FIELD=REGEXP
+                            Include only items whose FIELD matches REGEXP (ignoring case)
 ```
 
 Choosing dates:
@@ -196,19 +200,19 @@ Environment variables:
 ```
     ICALPAL                 Additional arguments
     ICALPAL_CONFIG          Additional arguments from a file
-                            (default: /Users/ajr/.icalPal)
+                            (default: /Users/ajr/.icalpal)
 ```
 
 ## Output formats
 
-icalPal supports several output formats.  The **default** format tries
+icalpal supports several output formats.  The **default** format tries
 to mimic icalBuddy as much as possible.
 
 CSV, Hash, JSON, XML, and YAML print all fields for all items in their
 respective formats.  From that you can analyze the results any way you
 like.
 
-[Remind](https://dianne.skoll.ca/projects/remind/) format uses a minimal implementation built in icalPal.
+[Remind](https://dianne.skoll.ca/projects/remind/) format uses a minimal implementation built in icalpal.
 
 Other formats such as ANSI, HTML, Markdown, RDoc, and TOC, use Ruby's
 [RDoc::Markup](https://ruby-doc.org/stdlib-2.6.10/libdoc/rdoc/rdoc/RDoc/Markup.html)
@@ -256,9 +260,9 @@ 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.
+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
+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

@@ -9,12 +9,12 @@ begin
   require 'sqlite3'
   require 'yaml'
 
-  require_relative '../lib/icalPal'
+  require_relative '../lib/icalpal'
   require_relative '../lib/options'
 rescue LoadError => e
   dep = e.message[/-- (.*)/, 1]
 
-  $stderr.puts "FATAL: icalPal is missing a dependency: #{dep}"
+  $stderr.puts "FATAL: icalpal is missing a dependency: #{dep}"
   $stderr.puts
   $stderr.puts "Install with 'gem install --user-install #{dep}'"
 
@@ -95,14 +95,16 @@ $rows.each_with_index do |row, i|
   end
 
   # --ec/--ic
-  if $opts[:ec].any? row['calendar'] then
-    $log.debug(":ec")
-    next
-  end
+  unless klass == ICalPal::Store or !row['calendar']
+    if $opts[:ec].any? row['calendar'] then
+      $log.debug(":ec")
+      next
+    end
 
-  unless $opts[:ic].empty? or $opts[:ic].any? row['calendar']
-    $log.debug(":ic")
-    next
+    unless $opts[:ic].empty? or $opts[:ic].any? row['calendar']
+      $log.debug(":ic")
+      next
+    end
   end
 
   # Instantiate an item
@@ -130,6 +132,18 @@ $rows.each_with_index do |row, i|
     next
   end
 
+  # --match
+  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(":match")
+        next
+      end
+    end
+  end
+
   if ICalPal::Event === item
     # Check for all-day and cancelled events
     if $opts[:ea] && item['all_day'].positive? then

data/bin/icalpal

@@ -0,0 +1,320 @@
+#!/usr/bin/env ruby
+
+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]
+
+  $stderr.puts "FATAL: icalpal is missing a dependency: #{dep}"
+  $stderr.puts
+  $stderr.puts "Install with 'gem install --user-install #{dep}'"
+
+  exit
+end
+
+
+##################################################
+# Load options
+
+# All kids love log!
+$log = Logger.new(STDERR, { level: $defaults[:common][:debug] })
+$log.formatter = proc do |s, t, p, m| # Severity, time, progname, msg
+  ($log.level.positive?)? "#{s}: #{m}\n" :
+    "[%-5s] %s [%s] - %s\n" %
+    [ s, t.strftime('%H:%M:%S.%L'), caller(4, 1)[0].split('/')[-1], m ]
+end
+
+$opts = ICalPal::Options.new.parse_options
+
+$rows = []                      # Rows from the database
+$items = []                     # Items to be printed
+
+
+##################################################
+# All kids love log!
+
+$log.info("Options: #{$opts}")
+
+
+##################################################
+# Add an item to the list
+#
+# @param item[Object]
+
+def add(item)
+  $log.info("Adding #{item.inspect} #{item['UUID']} (#{item['title']})") if item['UUID']
+
+  item['sday'] = ICalPal::RDT.new(*item['sdate'].to_a[0..2]) if item === ICalPal::Event && item['sdate']
+  $items.push(item)
+end
+
+
+##################################################
+# Load the data
+
+# What are we getting?
+klass = ICalPal::($opts[:cmd])
+
+# Get it
+if klass == ICalPal::Reminder then
+  # Load all .sqlite files
+  Dir.glob("#{$opts[:db]}/*.sqlite").each { |db| $rows += ICalPal.load_data(db, klass::QUERY) }
+else
+  # Load database
+  $rows += ICalPal.load_data($opts[:db], klass::QUERY)
+end
+
+$log.info("Loaded #{$rows.count} #{klass} rows")
+
+
+##################################################
+# Process the data
+
+# Add rows
+$rows.each_with_index do |row, i|
+  $log.debug("Row #{i}: #{row['ROWID']}:#{row['UUID']} - #{row['account']}/#{row['calendar']}/#{row['title']}")
+
+  # --es/--is
+  if $opts[:es].any? row['account'] then
+    $log.debug(":es")
+    next
+  end
+
+  unless $opts[:is].empty? or $opts[:is].any? row['account']
+    $log.debug(":is");
+    next
+  end
+
+  # --ec/--ic
+  unless klass == ICalPal::Store or !row['calendar']
+    if $opts[:ec].any? row['calendar'] then
+      $log.debug(":ec")
+      next
+    end
+
+    unless $opts[:ic].empty? or $opts[:ic].any? row['calendar']
+      $log.debug(":ic")
+      next
+    end
+  end
+
+  # Instantiate an item
+  item = klass.new(row)
+
+  # --et/--it
+  if $opts[:et].any? item['type'] then
+    $log.debug(":et")
+    next
+  end
+
+  unless $opts[:it].empty? or $opts[:it].any? item['type']
+    $log.debug(":it")
+    next
+  end
+
+  # --el/--il
+  if $opts[:el].any? item['list_name'] then
+    $log.debug(":el")
+    next
+  end
+
+  unless $opts[:il].empty? or $opts[:il].any? item['list_name']
+    $log.debug(":il")
+    next
+  end
+
+  # --match
+  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(":match")
+        next
+      end
+    end
+  end
+
+  if ICalPal::Event === item
+    # Check for all-day and cancelled events
+    if $opts[:ea] && item['all_day'].positive? then
+      $log.debug(":ea")
+      next
+    end
+
+    if $opts[:ia] && !item['all_day'].positive? then
+      $log.debug(":ia")
+      next
+    end
+
+    if item['status'] == :canceled then
+      $log.debug(":canceled")
+      next
+    end
+
+    (item['has_recurrences'].positive?)?
+      item.recurring.each { |i| add(i) } :
+      item.non_recurring.each { |i| add(i) }
+  else
+    # Check for dated reminders
+    if ICalPal::Reminder === item then
+      if $opts[:dated] == 1 and item['due_date'] > 0 then
+        $log.debug(":undated")
+        next
+      end
+
+      if $opts[:dated] == 2 and item['due_date'] == 0 then
+        $log.debug(":dated")
+        next
+      end
+    end
+
+    add(item)
+  end
+end
+
+# Add placeholders for empty days
+if $opts[:sed] && $opts[:sd] && klass == ICalPal::Event
+  days = $items.collect { |i| i['sday'] }.uniq.sort
+
+  $opts[:days].times do |n|
+    day = $opts[:from] + n
+    $items.push(klass.new(day)) unless days.any? { |i| i.to_s == day.to_s }
+  end
+end
+
+# Sort the rows
+begin
+  $log.info("Sorting/uniqing #{$items.count} items by #{[ $opts[:sep], $opts[:sort], 'sdate' ]}, reverse #{$opts[:reverse].inspect}")
+
+  $items.sort_by! { |i| [ i[$opts[:sep]], i[$opts[:sort]], i['sdate'] ] }
+  $items.reverse! if $opts[:reverse]
+  $items.uniq!
+rescue Exception => e
+  $log.info("Sorting failed: #{e}\n")
+end
+
+$log.debug("#{$items.count} items remain")
+
+# Configure formatting
+mu = case $opts[:output]
+     when 'ansi' then RDoc::Markup::ToAnsi.new
+     when 'default' then RDoc::Markup::ToICalPal.new($opts)
+     when 'html' then
+       rdoc = RDoc::Options.new
+       rdoc.pipe = true
+       rdoc.output_decoration = false
+       RDoc::Markup::ToHtml.new(rdoc)
+     when 'md' then RDoc::Markup::ToMarkdown.new
+     when 'rdoc' then RDoc::Markup::ToRdoc.new
+     when 'toc' then RDoc::Markup::ToTableOfContents.new
+     end
+
+
+##################################################
+# Print the data
+
+items = $items[0..$opts[:li] - 1]
+
+unless mu
+  $log.debug("Output in #{$opts[:output]} format")
+
+  puts case $opts[:output]
+       when 'csv' then
+         # Get all headers
+         headers = []
+         items.each { |i| headers += i.keys }
+         headers.uniq!
+
+         # Populate a CSV::Table
+         table = CSV::Table.new([], headers: headers)
+         items.each { |i| table << i.to_csv(headers) }
+
+         table
+       when 'hash' then items.map { |i| i.self }
+       when 'json' then items.map { |i| i.self }.to_json
+       when 'xml' then
+         xml = items.map { |i| "<#{$opts[:cmd].chomp("s")}>#{i.to_xml}</#{$opts[:cmd].chomp("s")}>" }
+         "<#{$opts[:cmd]}>\n#{xml.join("")}</#{$opts[:cmd]}>"
+       when 'yaml' then items.map { |i| i.self }.to_yaml
+       when 'remind' then items.map { |i|
+                            "REM #{i['sdate'].strftime('%F AT %R')} " +
+                              "DURATION #{((i['edate'] - i['sdate']).to_f * 1440).to_i } " +
+                              "MSG #{i['title']}"
+                          }.join("\n")
+       else abort "No formatter for #{$opts[:output]}"
+       end
+
+  exit
+end
+
+$log.debug("Formatting with #{mu.inspect}")
+
+doc = RDoc::Markup::Document.new
+section = nil
+
+items.each_with_index do |i, j|
+  $log.debug("Print #{j}: #{i.inspect}")
+
+  # --li
+  break if $opts[:li].positive? && j >= $opts[:li]
+
+  # Use RDoc::Markup::Verbatim to save the item
+  v = RDoc::Markup::Verbatim.new
+  v.format = i
+  doc << v
+
+  # Sections
+  if $opts[:sep] && section != i[$opts[:sep]]
+    $log.debug("New section '#{$opts[:sep]}': #{i[$opts[:sep]]}")
+
+    doc << RDoc::Markup::Raw.new($opts[:sep])
+
+    doc << RDoc::Markup::BlankLine.new if j.positive?
+    doc << RDoc::Markup::Heading.new(1, i[$opts[:sep]].to_s)
+    doc << RDoc::Markup::Rule.new(0)
+
+    section = i[$opts[:sep]]
+  end
+
+  # Item
+  props = RDoc::Markup::List.new(:BULLET)
+
+  # Properties
+  $opts[:props].each_with_index do |prop, k|
+    value = i[prop]
+
+    next unless value
+    next if Array === value && !value[0]
+    next if String === value && value.length == 0
+
+    $log.debug("#{prop}: #{value}")
+
+    # Use Raw to save the property
+    props << RDoc::Markup::Raw.new(prop)
+
+    unless k.positive?
+      # First property, value only
+      props << RDoc::Markup::Heading.new(2, value.to_s)
+    else
+      props << RDoc::Markup::BlankLine.new unless (i['placeholder'] || $opts[:ps])
+      props << RDoc::Markup::ListItem.new(prop, RDoc::Markup::Paragraph.new(value)) unless(i['placeholder'])
+    end
+  end
+
+  # Print it
+  props << RDoc::Markup::BlankLine.new unless props.empty?
+
+  doc << props
+end
+
+print doc.accept(mu)

data/icalPal.gemspec

@@ -1,8 +1,9 @@
 require './lib/version'
 
 Gem::Specification.new do |s|
-  s.name	= "icalPal"
+  s.name	= ICalPal::NAME
   s.version	= ICalPal::VERSION
+
   s.summary	= "Command-line tool to query the macOS Calendar"
   s.description	= <<-EOF
 Inspired by icalBuddy and maintains close compatability.  Includes

data/lib/EventKit.rb

@@ -42,6 +42,7 @@ class EventKit
     { name: 'MobileMe',   color: '#FFFF00' }, # Yellow
     { name: 'Subscribed', color: '#FF0000' }, # Red
     { name: 'Birthdays',  color: '#FF00FF' }, # Magenta
+    { name: 'Reminders',  color: '#066FF3' }, # Blue
   ]
 
   EKSpan = [

data/lib/defaults.rb

@@ -8,7 +8,7 @@ $defaults = {
     ab: '!',
     aep: [],
     bullet: '•',
-    cf: "#{ENV['HOME']}/.icalPal",
+    cf: "#{ENV['HOME']}/.icalpal",
     color: false,
     db: "#{ENV['HOME']}/Library/Calendars/Calendar.sqlitedb",
     debug: Logger::WARN,
@@ -26,6 +26,7 @@ $defaults = {
     output: 'default',
     ps: [ "\n  " ],
     r: false,
+    match: nil,
     sc: false,
     sd: false,
     sep: false,

data/lib/event.rb

@@ -1,3 +1,5 @@
+require 'time'
+
 module ICalPal
   # Class representing items from the <tt>CalendarItem</tt> table
   class Event
@@ -92,8 +94,10 @@ module ICalPal
       end
 
       if @self['start_tz'] == '_float'
-        @self['sdate'] = RDT.new(*(@self['sdate'].to_time - Time.zone_offset($now.zone())).to_a.reverse[4..], $now.zone)
-        @self['edate'] = RDT.new(*(@self['edate'].to_time - Time.zone_offset($now.zone())).to_a.reverse[4..], $now.zone)
+        tzoffset = Time.zone_offset($now.zone())
+
+        @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)
       end
 
       # Type of calendar event is from
@@ -110,20 +114,27 @@ 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 = []
+
+      nDays = (self['duration'] / 86400).to_i
+
+      # Sanity checks
+      return events if nDays > 100000
 
       # Repeat for multi-day events
-      ((self['duration'] / 86400).to_i + 1).times do |i|
+      (nDays + 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
@@ -131,35 +142,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
@@ -168,67 +193,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
+
+          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
 
-      # Check for changes
-      changes.detect(
-        proc {
-          retval.push(clone)
-        }) { |i| @self['sday'] == i['sday'] } unless retval.count.positive?
+        # 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
@@ -243,6 +273,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

@@ -141,7 +141,7 @@ module ICalPal
   # 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)
@@ -155,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

@@ -13,7 +13,7 @@ module ICalPal
   #
   # Many options are intentionally copied from
   # icalBuddy[https://github.com/ali-rantakari/icalBuddy].  Note that
-  # icalPal requires two hyphens for all options, except single-letter
+  # icalpal requires two hyphens for all options, except single-letter
   # options which require a single hyphen.
   #
   # Options can be abbreviated as long as they are unique.
@@ -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,4 @@
 module ICalPal
-  VERSION = '2.1.0'
+  NAME = 'icalPal'
+  VERSION = '3.0.0'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: icalPal
 version: !ruby/object:Gem::Version
-  version: 2.1.0
+  version: 3.0.0
 platform: ruby
 authors:
 - Andy Rosen
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-04-28 00:00:00.000000000 Z
+date: 2024-09-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: sqlite3
@@ -50,6 +50,7 @@ extra_rdoc_files:
 files:
 - README.md
 - bin/icalPal
+- bin/icalpal
 - icalPal.gemspec
 - lib/EventKit.rb
 - lib/ToICalPal.rb
@@ -81,7 +82,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.9
+rubygems_version: 3.5.18
 signing_key:
 specification_version: 4
 summary: Command-line tool to query the macOS Calendar