icalPal 2.2.0 → 3.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 76513daaf66f3c4aa8b2a9e1703f275ba5d5a65ef9e8b71a86b263c59d409fdd
-  data.tar.gz: c06430cfbdd5c415dae2d154b774c1ba1feb210534e6511f9fbb1cf12052cbfd
+  metadata.gz: c3e477a80eaaf8149b68b6c36aa0a5a9422e4ea9d6fdbcf36b11bdb74f8cca7f
+  data.tar.gz: 416f7f1afb820b969d887cd15f0a60ae0344ea5433f6b7a145a4672f166286de
 SHA512:
-  metadata.gz: 290f75e744ea88673f474c478565ec281a2b8eae8dcfc730ccb7abf88f33b5fdc8c10baf53b971c336d48a3a4abc3f311e02973e9f2295fea2d134e3d987a499
-  data.tar.gz: af3d7eec48d408f2c7ff15af7cdddcf581fa60574e1ab3602efb32e6625bfa61833919194108fe012fbae35a312c14af6ffbf628be4921d7cd11651e67717151
+  metadata.gz: 9818532d5d53e090e7045480455ceb8f989c4530665698382781d59fce4ab380517cd22c9b204b0a556a87ce263e6242c3a11436112b7a32c121477b8afbd7e7
+  data.tar.gz: f16c07f9b1e4d113c096dfed547565114352e3c50ea65bbe49ee58ae9753d8bf2edd0362e5447bb2b529a7038e2c2a70797e63a3793f45e02d3a96914d8ea6b1

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}'"
 
@@ -65,12 +65,19 @@ end
 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)
+$opts[:db].each do |db|
+    $log.debug("Trying #{db}")
+
+    if klass == ICalPal::Reminder then
+      # Load all .sqlite files
+      $log.debug("Loading *.sqlite in #{db}")
+      Dir.glob("#{db}/*.sqlite").each { |d| $rows += ICalPal.load_data(d, klass::QUERY) }
+    else
+      # Load database
+      begin
+        $rows += ICalPal.load_data(db, klass::QUERY)
+      end
+  end
 end
 
 $log.info("Loaded #{$rows.count} #{klass} rows")
@@ -95,14 +102,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,13 +139,13 @@ $rows.each_with_index do |row, i|
     next
   end
 
-  # --regexp
+  # --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(":regex")
+        $log.debug(":match")
         next
       end
     end

data/bin/icalpal

@@ -0,0 +1,327 @@
+#!/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
+$opts[:db].each do |db|
+    $log.debug("Trying #{db}")
+
+    if klass == ICalPal::Reminder then
+      # Load all .sqlite files
+      $log.debug("Loading *.sqlite in #{db}")
+      Dir.glob("#{db}/*.sqlite").each { |d| $rows += ICalPal.load_data(d, klass::QUERY) }
+    else
+      # Load database
+      begin
+        $rows += ICalPal.load_data(db, klass::QUERY)
+      end
+  end
+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,9 +8,12 @@ $defaults = {
     ab: '!',
     aep: [],
     bullet: '•',
-    cf: "#{ENV['HOME']}/.icalPal",
+    cf: "#{ENV['HOME']}/.icalpal",
     color: false,
-    db: "#{ENV['HOME']}/Library/Calendars/Calendar.sqlitedb",
+    db: [
+      "#{ENV['HOME']}/Library/Calendars/Calendar.sqlitedb",
+      "#{ENV['HOME']}/Library/Group Containers/group.com.apple.calendar/Calendar.sqlitedb",
+    ],
     debug: Logger::WARN,
     df: '%b %-d, %Y',
     ec: [],
@@ -36,19 +39,19 @@ $defaults = {
   },
   tasks: {
     dated: 0,
-    db: ICalPal::Reminder::DB_PATH,
+    db: [ ICalPal::Reminder::DB_PATH ],
     iep: [ 'title', 'notes', 'due', 'priority' ],
     sort: 'prio',
   },
   undatedTasks: {
     dated: 1,
-    db: ICalPal::Reminder::DB_PATH,
+    db: [ ICalPal::Reminder::DB_PATH ],
     iep: [ 'title', 'notes', 'due', 'priority' ],
     sort: 'prio',
   },
   datedTasks: {
     dated: 2,
-    db: ICalPal::Reminder::DB_PATH,
+    db: [ ICalPal::Reminder::DB_PATH ],
     iep: [ 'title', 'notes', 'due', 'priority' ],
     sort: 'prio',
   },

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
@@ -112,8 +116,13 @@ module ICalPal
     def non_recurring
       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)

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::CantOpenException => e
+      $log.debug("Can't open #{db_file}")
+
     rescue SQLite3::SQLException => e
       $log.info("#{db_file}: #{e}")
 

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.

data/lib/version.rb

@@ -1,3 +1,4 @@
 module ICalPal
-  VERSION = '2.2.0'
+  NAME = 'icalPal'
+  VERSION = '3.1.0'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: icalPal
 version: !ruby/object:Gem::Version
-  version: 2.2.0
+  version: 3.1.0
 platform: ruby
 authors:
 - Andy Rosen
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-05-15 00:00:00.000000000 Z
+date: 2024-11-05 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