timex_datalink_caldav 0.3.0 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8d31450cb602c3c36c121b4ffd2240664ed8f9e550388a246f1c5e169d12f7fa
-  data.tar.gz: 351b4213184ca2652205c80e99b7997538385bd0fab7e6ee3f4a6a57f1977247
+  metadata.gz: 8301c0dee4e085d6ebbbebbcd41872211625f6798980f688cf66765550519622
+  data.tar.gz: 30171ce1fcdb85fa57b17121982c85ab5805cdbef1f12106d56561397bd82ee6
 SHA512:
-  metadata.gz: '08bf1aa6454647ccc74a568cb0e54e5b9724394da3f0d8ff6a8bcb0205d63ddb35208b40d99cbdbdab0be8c6b6e5c0c6febdb9db3369c415bad5cfdba7be7cb5'
-  data.tar.gz: c2334ebf8d3d5515f4bce340808b61cacdc39ccdeaad6d2b7e7e356340fb97cf049c0316d1587d37b74dad9f4a593dcf91be66399bbfc3075018ef023a0e267d
+  metadata.gz: 31a43cf2e995bcd29d51ebae9d3a30002239ac0bea6862f97b0f967daf25734409432e75fbced7727ecc2126e6ec509bdb0c09fd6dc7fcbffed87e9c124d73a5
+  data.tar.gz: 5b8b1f14b62a03c6354c2b555651ae6336b6248ddc633b4749b966929c2e8b6e39c8d6f8845cb57329a46a5dc18c35522bd8a193c115efa781922ead52853705

data/Gemfile

@@ -20,3 +20,13 @@ gem "icalendar-recurrence", "~> 1.1"
 gem "activesupport", "~> 7.0"
 
 gem "tzinfo", "~> 2.0"
+
+gem "yaml", "~> 0.2.1"
+
+gem "text", "~> 1.3"
+
+gem "humanize", "~> 2.5"
+
+gem "down", "~> 5.4"
+
+gem "ruby-progressbar", "~> 1.13"

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    timex_datalink_caldav (0.2.0)
+    timex_datalink_caldav (1.0.0)
 
 GEM
   remote: https://rubygems.org/
@@ -24,6 +24,8 @@ GEM
     diff-lcs (1.5.0)
     domain_name (0.5.20190701)
       unf (>= 0.0.5, < 1.0.0)
+    down (5.4.1)
+      addressable (~> 2.8)
     ffi (1.15.5)
     ffi-compiler (1.0.1)
       ffi (>= 1.0.0)
@@ -36,6 +38,7 @@ GEM
     http-cookie (1.0.5)
       domain_name (~> 0.5)
     http-form_data (2.3.0)
+    humanize (2.5.1)
     i18n (1.13.0)
       concurrent-ruby (~> 1.0)
     icalendar (2.8.0)
@@ -67,8 +70,10 @@ GEM
       diff-lcs (>= 1.2.0, < 2.0)
       rspec-support (~> 3.12.0)
     rspec-support (3.12.0)
+    ruby-progressbar (1.13.0)
     rubyserial (0.6.0)
       ffi (~> 1.9, >= 1.9.3)
+    text (1.3.1)
     timex_datalink_client (0.11.0)
       activemodel (~> 7.0.4)
       crc (~> 0.4.2)
@@ -79,6 +84,7 @@ GEM
     unf (0.1.4)
       unf_ext
     unf_ext (0.0.8.2)
+    yaml (0.2.1)
 
 PLATFORMS
   arm64-darwin-22
@@ -86,13 +92,18 @@ PLATFORMS
 DEPENDENCIES
   activesupport (~> 7.0)
   calendav (~> 0.4.0)
+  down (~> 5.4)
+  humanize (~> 2.5)
   icalendar (~> 2.8)
   icalendar-recurrence (~> 1.1)
   rake (~> 13.0)
   rspec (~> 3.12)
+  ruby-progressbar (~> 1.13)
+  text (~> 1.3)
   timex_datalink_caldav!
   timex_datalink_client (~> 0.11.0)
   tzinfo (~> 2.0)
+  yaml (~> 0.2.1)
 
 BUNDLED WITH
    2.4.10

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Willy Hardy
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -1,6 +1,10 @@
 # TimexDatalinkCaldav
 
-TimexDatalinkCaldav is a simple Ruby gem designed to sync events from a CalDAV server to a Timex Datalink watch. It can also be used as a standalone command-line interface (CLI) tool.
+TimexDatalinkCaldav is a simple Ruby gem designed to sync events from a CalDAV server or an ical formatted ics file to a Timex Datalink watch. It can also be used as a standalone command-line interface (CLI) tool.
+
+## Pre-requisites
+
+If you need to install Ruby, follow the Ruby installation instructions [here](https://www.ruby-lang.org/en/documentation/installation/).
 
 ## Installation
 
@@ -13,9 +17,7 @@ gem install timex_datalink_caldav
 Or add this line to your application's Gemfile:
 
 ```ruby
-source "https://rubygems.pkg.github.com/wjhrdy" do
-  gem "timex_datalink_caldav"
-end
+gem "timex_datalink_caldav"
 ```
 
 And then execute:
@@ -33,26 +35,47 @@ Here's an example of how to use the tool in your Ruby code:
 ```ruby
 require 'timex_datalink_caldav'
 
-client = TimexDatalinkCaldav::Client.new(your_username, your_password, your_server_uri, your_device)
-client.sync_to_watch
+client = TimexDatalinkCaldav::Client.new(your_username, your_password, your_server_uri, your_device, your_protocol_version, days_forward)
+
+client.parse_events
+client.write_to_watch
 ```
 
 ### As a CLI Tool
 
-After installing the gem, you can use it as a CLI tool:
+After installing the gem, you can use it as a CLI tool. You can specify the CalDAV server details directly on the command line:
 
 ```sh
-timex_datalink_caldav -u https://caldavendpoint.com -n your_username -p your_password -d your_device
+timex_datalink_caldav -u https://caldavendpoint.com -n your_username -p your_password -d your_device -a your_protocol_version -f days_forward
 ```
 
-Please replace `caldavendpoint.com` `your_username`, `your_password`, and `your_device` with your actual CalDAV server, username, password, and serial device respectively.
+Please replace `https://caldavendpoint.com`, `your_username`, `your_password`, `your_device`, `your_protocol_version`, and `days_forward` with your actual CalDAV server URI, username, password, serial device, protocol version, and number of days to look forward for events, respectively.
+
+Or you can provide these details in a configuration file:
+
+```sh
+timex_datalink_caldav -c config.yml -a 1 -d /dev/tty.usbmodem0000000000001 -f 7
+```
+
+The configuration file should be a YAML file in the following format:
+
+```yaml
+endpoints:
+  - uri: https://www.google.com/calendar/dav/email@gmail.com/events
+    user: email@gmail.com
+    password: app_password
+  - uri: https://caldavendpoint2.com
+    user: your_username2
+    password: your_password2
+  - uri: https://icalendpoint.com/example.ics
+```
 
-The device is a serial device that flashes an led when it receives data. On Linux, this is usually `/dev/ttyUSB0`. On macOS, this is usually `/dev/cu.usbserial-0001`. On Windows, this is usually `COM1`.
+The device is a serial device that flashes an led when it receives data. On Linux, this is usually `/dev/tty*`. On macOS, this is usually `$(ls /dev/tty.usbmodem* | head -n 1)`. On Windows, this is usually `COM1`.
 
-If you want to use this I highly recommend pairing it with the Raspberry Pi Pico and [this project](https://github.com/famiclone6502/DIY_Datalink_Adapter). It is the cheapest and easiest way to get a serial device that works with the Timex Datalink watch.
+If you want to use this, I highly recommend pairing it with the Raspberry Pi Pico and [this project](https://github.com/famiclone6502/DIY_Datalink_Adapter). It is the cheapest and easiest way to get a serial device that works with the Timex Datalink watch.
 
-## Note
+## Notes
 
-Ensure you have the necessary dependencies installed on your system and you have the correct permissions to access the specified device.
+- This gem is not affiliated with Timex, nor is it affiliated with any CalDAV server. It is simply a tool that I wrote to sync my events from my CalDAV server to my Timex Datalink watch.
 
-The tool currently filters down to events that have attendees and converts event times to Eastern Standard Time (EST). Events are sorted by time before syncing to the watch.
+- This gem uses the anniversary feature for full day events, and the appointments feature for events with a start and end time.

data/bin/get_ebrain_db

@@ -0,0 +1,57 @@
+#!/usr/bin/env ruby
+
+require 'down'
+require 'fileutils'
+require 'tmpdir'
+require 'ruby-progressbar'
+
+# Define URL and file names
+url = "https://archive.org/download/ebrain-1.1.6/ebrain-1.1.6.iso"
+iso_file = File.join(Dir.tmpdir, "ebrain-1.1.6.iso")
+msi_file = File.join(Dir.tmpdir, "eBrain.MSI")
+cab_file = File.join(Dir.tmpdir, "Cabs.w4.cab")
+mdb_file1 = File.join(Dir.tmpdir, "pcvocab.mdb1")
+mdb_file = "pcvocab.mdb" # This is in the current directory
+
+# Check if 7zip is installed
+unless system('which 7z > /dev/null 2>&1')
+  puts "7zip is not installed. Please download and install 7zip from https://www.7-zip.org/download.html"
+  exit 1
+end
+
+# Initialize the progress bar
+progressbar = nil
+
+# Download the ISO file
+puts "Downloading ISO file..."
+Down.download(url,
+  destination: iso_file,
+  content_length_proc: ->(content_length) {
+    progressbar = ProgressBar.create(
+      title: 'Download Progress',
+      total: content_length,
+      format: '%a %bᗧ%i %p%% %t, Estimated time: %e'
+    )
+  },
+  progress_proc: ->(progress) {
+    progressbar.progress = progress
+  }
+)
+
+# Extract the MSI file from the ISO
+puts "Extracting MSI file..."
+system("7z e #{iso_file} -o#{File.dirname(msi_file)} #{File.basename(msi_file)}")
+
+# Extract the CAB file from the MSI
+puts "Extracting CAB file..."
+system("7z e #{msi_file} -o#{File.dirname(cab_file)} #{File.basename(cab_file)}")
+
+# Extract the MDB file from the CAB
+puts "Extracting MDB file..."
+system("7z e #{cab_file} -o#{File.dirname(mdb_file1)} #{File.basename(mdb_file1)}")
+
+# Rename and move the MDB file to the current directory
+puts "Renaming and moving MDB file..."
+FileUtils.mv mdb_file1, mdb_file
+
+puts "Done."

data/examples/README.md

@@ -0,0 +1,7 @@
+# Examples
+
+This directory contains sample configurations and code for the timex_datalink_caldav gem.
+
+## Configuration
+
+`caldav.yaml.sample` is a sample configuration file for CalDAV endpoints. You should rename it to `caldav.yaml` and adjust the URI, username, and password for your endpoints.

data/examples/caldav.yaml.sample

@@ -0,0 +1,8 @@
+endpoints:
+  - uri: https://example.com/caldav1
+    user: user1
+    password: password1
+  - uri: https://example.com/caldav2
+    user: user2
+    password: password2
+  - uri: https://example.com/example.ical

data/lib/timex_datalink_caldav/client.rb

@@ -1,25 +1,30 @@
 require 'calendav'
+require 'icalendar'
 require 'icalendar/recurrence'
 require 'timex_datalink_client'
 require 'active_support/time'
 require 'tzinfo'
+require 'humanize'
+require_relative 'similar_word'
 
 module TimexDatalinkCaldav
   class Client
-    def initialize(user, password, server_url, serial_device, protocol_version)
+    def initialize(user, password, server_url, serial_device, protocol_version, days_forward = 1)
       @user = user
       @password = password
       @server_url = server_url
       @serial_device = serial_device
+      @days_forward = days_forward
       @protocol_version = protocol_version.to_i
       @protocol_class = case @protocol_version
-                        when 1 then TimexDatalinkClient::Protocol1
-                        when 3 then TimexDatalinkClient::Protocol3
-                        when 4 then TimexDatalinkClient::Protocol4
-                        else
-                          raise ArgumentError, "Invalid protocol version: #{@protocol_version}"
-                        end
-                      end
+                          when 1 then TimexDatalinkClient::Protocol1
+                          when 3 then TimexDatalinkClient::Protocol3
+                          when 4 then TimexDatalinkClient::Protocol4
+                          when 7 then TimexDatalinkClient::Protocol7
+                          else
+                            raise ArgumentError, "Invalid protocol version: #{@protocol_version}"
+                          end
+    end
 
     def get_localzone
       TZInfo::Timezone.get(TZInfo::Timezone.all_country_zones.detect {|z| z.period_for_local(Time.now).utc_total_offset == Time.now.utc_offset}.identifier)
@@ -33,49 +38,140 @@ module TimexDatalinkCaldav
         authentication: :basic_auth
       )
 
-      # Create a new client with the credentials
-      client = Calendav.client(credentials)
+      if @user && @password
+        # Create a new client with the credentials
+        client = Calendav.client(credentials)
 
-      # Get events from the calendar for the next day
-      client.events.list(@server_url, from: Time.now, to: Time.now + 24*60*60)
+        # Get events from the calendar for the next day
+        caldav_events = client.events.list(@server_url, from: Time.now, to: Time.now + @days_forward*24*60*60)
+        events = caldav_events.map { |event| Icalendar::Event.parse(event.calendar_data).first }
+      else
+        cal_file = URI.open(@server_url)
+        cals = Icalendar::Calendar.parse(cal_file)
+        cal = cals.first
+        events = cal.events
+      end
+
+      events
     end
 
-    def sync_to_watch
+    def parse_events
       events = get_events
-
+    
       appointments = []
+      anniversaries = []
       appointment_map = {} # Used to avoid duplicate appointments
-
+      anniversary_map = {} # Used to avoid duplicate anniversaries
+    
+      phrase_builder = SimlarWord.new(database: "pcvocab.mdb") if @protocol_version == 7
+    
       events.each do |event|
-        ical_events = Icalendar::Event.parse(event.calendar_data)
-        if ical_events.any?
-          ical_event = ical_events.first
-          if ical_event.attendee&.any? # Exclude events without attendees
-            next_occurrence = ical_event.occurrences_between(Time.now, Time.now + 24*60*60).first
-            if next_occurrence
-              puts get_localzone
-              est_time = next_occurrence.start_time.in_time_zone(get_localzone)
-              key = "#{est_time}_#{ical_event.summary.to_s}"
-              unless appointment_map[key] # Check if the event is already in the map
-                puts "Adding appointment: #{ical_event.summary.to_s} at time #{est_time}"
-                appointment = @protocol_class::Eeprom::Appointment.new(
-                  time: est_time,
-                  message: ical_event.summary.to_s
-                )
-                appointments << appointment
-                appointment_map[key] = true
-              end
-            end
+        next unless event && event.dtstart && event.dtend
+    
+        summary_words = parse_summary(event)
+    
+        occurrences = event.occurrences_between(Time.now, Time.now + @days_forward*24*60*60)
+    
+        if @protocol_version == 7
+          if all_day_event?(event)
+            add_anniversary_event(anniversary_map, anniversaries, phrase_builder, summary_words, occurrences)
+          else
+            add_appointment_event(appointment_map, appointments, phrase_builder, summary_words, occurrences)
+          end
+        else
+          if all_day_event?(event)
+            add_anniversary(event, anniversary_map, anniversaries, summary_words, occurrences)
+          else
+            add_appointment(event, appointment_map, appointments, summary_words, occurrences)
           end
         end
       end
-      
-      # Sort the appointments by time
-      appointments.sort_by! { |appointment| appointment.time }
-      write_to_watch(appointments)
+    
+      [appointments, anniversaries]
+    end
+    
+    def all_day_event?(event)
+      (event.dtend.to_date - event.dtstart.to_date == 1) && event.dtstart.to_datetime.hour == 0 && event.dtstart.to_datetime.min == 0 && event.dtend.to_datetime.hour == 0 && event.dtend.to_datetime.min == 0
+    end
+    
+    def parse_summary(event)
+      event.summary.to_s.split.map do |word| 
+        if word =~ /\A[a-zA-Z]+\z/
+          word
+        elsif word =~ /\A\d+\z/ 
+          word.to_i.humanize
+        end
+      end.compact
+    end
+    
+    def add_appointment_event(appointment_map, appointments, phrase_builder, summary_words, occurrences)
+      occurrences.each do |occurrence|
+        est_time = occurrence.start_time.in_time_zone(get_localzone)
+        key = "#{est_time}_#{summary_words}"
+        unless appointment_map[key]
+          puts "Adding appointment event: #{summary_words.join(' ')} at time #{est_time}"
+          event_phrase = phrase_builder.vocab_ids_for(*summary_words)
+          appointment = @protocol_class::Eeprom::Calendar::Event.new(
+            time: est_time,
+            phrase: event_phrase
+          )
+          appointments << appointment
+          appointment_map[key] = true
+        end
+      end
+    end
+    
+    def add_anniversary_event(anniversary_map, anniversaries, phrase_builder, summary_words, occurrences)
+      occurrences.each do |occurrence|
+        est_time = occurrence.start_time.in_time_zone(get_localzone)
+        key = "#{est_time}_#{summary_words.join(' ')}"
+        unless anniversary_map[key]
+          puts "Adding anniversary event: #{summary_words.join(' ')} at date #{event.dtstart.to_s}"
+          event_phrase = phrase_builder.vocab_ids_for(*summary_words)
+          anniversary = @protocol_class::Eeprom::Calendar::Event.new(
+            time: Time.new(est_time.year, est_time.month, est_time.day, 9, 30, 0),
+            phrase: event_phrase
+          )
+          anniversaries << anniversary
+          anniversary_map[key] = true
+        end
+      end
+    end
+    
+    def add_appointment(event, appointment_map, appointments, summary_words, occurrences)
+      occurrences.each do |occurrence|
+        est_time = occurrence.start_time.in_time_zone(get_localzone)
+        key = "#{est_time}_#{summary_words}"
+        unless appointment_map[key]
+          puts "Adding appointment: #{summary_words} at time #{est_time}"
+          appointment = @protocol_class::Eeprom::Appointment.new(
+            time: est_time,
+            message: summary_words
+          )
+          appointments << appointment
+          appointment_map[key] = true
+        end
+      end
+    end
+    
+    def add_anniversary(event, anniversary_map, anniversaries, summary_words, occurrences)
+      occurrences.each do |occurrence|
+        est_time = occurrence.start_time.in_time_zone(get_localzone)
+        key = "#{est_time}_#{summary_words}"
+        unless anniversary_map[key]
+          puts "Adding anniversary: #{summary_words} at date #{event.dtstart.to_s}"
+          anniversary = @protocol_class::Eeprom::Anniversary.new(
+            time: event.dtstart.to_time,
+            anniversary: summary_words
+          )
+          anniversaries << anniversary
+          anniversary_map[key] = true
+        end
+      end
     end
 
-    def write_to_watch(appointments)
+    def write_to_watch(appointments, anniversaries)
+      appointments.sort_by! { |appointment| appointment.time }
       # add 3 because it always seems to be about 3 seconds behind.
       time1 = Time.now + 3
       time2 = time1.dup.utc
@@ -99,7 +195,7 @@ module TimexDatalinkCaldav
           zone: 2,
           name: time2.zone
         )
-      else
+      elsif @protocol_version == 3 || @protocol_version == 4
         time_model = @protocol_class::Time.new(
           zone: 1,
           name: time1.zone,
@@ -117,21 +213,41 @@ module TimexDatalinkCaldav
         time_name_model = nil # Not needed for protocol version 3 and 4
         utc_time_name_model = nil # Not needed for protocol version 3 and 4
 
+      else
+        time_model = nil
+        utc_time_model = nil
+        time_name_model = nil
+        utc_time_name_model = nil
+      end
+      
+      if @protocol_version == 7
+        calendar = @protocol_class::Eeprom::Calendar.new(
+          time: time1,
+          events: appointments
+        )
+        models = [
+          @protocol_class::Sync.new,
+          @protocol_class::Start.new,
+          @protocol_class::Eeprom.new(
+            calendar: calendar
+          )
+        ]
+      else
+        models = [
+          @protocol_class::Sync.new,
+          @protocol_class::Start.new,
+          time_model,
+          time_name_model,
+          utc_time_model,
+          utc_time_name_model,
+          @protocol_class::Eeprom.new(
+            appointments: appointments,
+            anniversaries: anniversaries,
+            appointment_notification_minutes: 5
+          ),
+          @protocol_class::End.new
+        ].compact # Remove any nil entries
       end
-
-      models = [
-        @protocol_class::Sync.new,
-        @protocol_class::Start.new,
-        time_model,
-        time_name_model,
-        utc_time_model,
-        utc_time_name_model,
-        @protocol_class::Eeprom.new(
-          appointments: appointments,
-          appointment_notification_minutes: 5
-        ),
-        @protocol_class::End.new
-      ].compact # Remove any nil entries
 
       timex_datalink_client = TimexDatalinkClient.new(
         serial_device: @serial_device,

data/lib/timex_datalink_caldav/similar_word.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+require "mdb"
+require "text"  # import the text gem
+
+
+class SimlarWord
+    class WordNotFound < StandardError; end
+    
+    attr_accessor :database
+    
+    def initialize(database:)
+        @database = database
+    end
+    
+    def vocab_ids_for(*words)
+        words.flat_map do |word|
+            vocab = vocab_for_word(word)
+            
+            # If the word is not found, look for a similar sounding word
+            if vocab.nil?
+                word = find_similar_word(word)
+                vocab = vocab_for_word(word)
+            end
+            
+            raise(WordNotFound, "#{word} is not a valid word!") unless vocab
+            
+            vocab_links = vocab_links_for_vocab(vocab)
+            
+            vocab_links.map do |vocab_link|
+                linked_vocab = vocab_for_vocab_link(vocab_link)
+                
+                linked_vocab[:"PC Index"].to_i
+            end
+        end
+    end
+    
+    private
+    
+    def find_similar_word(word)
+        word_metaphone = Text::Metaphone.double_metaphone(word)
+      
+        # Filter out words that start with '<' before finding the minimum distance
+        filtered_vocab_table = vocab_table.reject { |vocab_word| vocab_word[:Label].start_with?('<') }
+    
+        similar_word = filtered_vocab_table.min_by do |vocab_word|
+          distance = Text::Levenshtein.distance(
+            Text::Metaphone.double_metaphone(vocab_word[:Label]).first, 
+            word_metaphone.first
+          )
+          distance
+        end
+      
+        if similar_word
+            puts "Similar word for '#{word}' is '#{similar_word[:Label]}'"
+            similar_word[:Label]
+        else
+            puts "No similar word found for '#{word}', using original word"
+            word
+        end
+    end
+    
+    def mdb
+        @mdb ||= Mdb.open(database)
+    end
+    
+    def vocab_table
+        @vocab_table ||= mdb["Vocab"]
+    end
+    
+    def vocab_links_table
+        @vocab_links_table ||= mdb["Vocab Links"]
+    end
+    
+    def vocab_for_word(word)
+        vocab_table.detect { |vocab| vocab[:Label].casecmp?(word) }
+    end
+    
+    def vocab_links_for_vocab(vocab)
+        links = vocab_links_table.select { |vocab_link| vocab_link[:"PC Index"] == vocab[:"PC Index"] }
+        
+        links.sort_by { |link| link[:Sequence].to_i }
+    end
+    
+    def vocab_for_vocab_link(vocab_link)
+        vocab_table.detect { |vocab| vocab[:"PC Index"] == vocab_link[:"eBrain Index"] }
+    end
+end

data/lib/timex_datalink_caldav/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module TimexDatalinkCaldav
-  VERSION = "0.3.0"
+  VERSION = "1.1.0"
 end

data/lib/timex_datalink_caldav.rb

@@ -1,5 +1,6 @@
-# frozen_string_literal: true
 require 'optparse'
+require 'yaml'
+require 'open-uri'
 require_relative "timex_datalink_caldav/client"
 
 module TimexDatalinkCaldav
@@ -9,27 +10,55 @@ module TimexDatalinkCaldav
     end
 
     def execute
-      client = TimexDatalinkCaldav::Client.new(@options.fetch(:user), @options.fetch(:password), @options.fetch(:uri), @options.fetch(:device), @options.fetch(:api,1))
-      client.sync_to_watch
+      all_appointments = []
+      all_anniversaries = []
+      
+      @options[:endpoints].each do |endpoint|
+        client = TimexDatalinkCaldav::Client.new(endpoint[:user], endpoint[:password], endpoint[:uri], @options[:device], @options[:api], @options[:days_forward])
+        appointments, anniversaries = client.parse_events
+        all_appointments.concat(appointments) if appointments.any?
+        all_anniversaries.concat(anniversaries) if anniversaries.any?
+      end
+    
+      if all_appointments.any? || all_anniversaries.any?
+        client = TimexDatalinkCaldav::Client.new(
+          @options[:endpoints][0][:user],
+          @options[:endpoints][0][:password],
+          @options[:endpoints][0][:uri],
+          @options[:device],
+          @options[:api],
+          @options[:days_forward]
+        )
+        client.write_to_watch(all_appointments, all_anniversaries)
+      end
     end
 
     private
 
     def parse_options(arguments)
-      options = {}
+      options = { days_forward: 1 }
+      cli_endpoint = {}
       OptionParser.new do |opts|
         opts.banner = "Usage: timex_datalink_caldav [options]"
 
+        opts.on("-c", "--config FILE", "Configuration file") do |v|
+          raise ArgumentError, "Both CLI options and configuration file provided. Please provide only one." if cli_endpoint.any?
+          parsed_config = YAML.load_file(v)
+          options[:endpoints] = parsed_config['endpoints'].map do |endpoint|
+            endpoint.each_with_object({}) { |(k, v), result| result[k.to_sym] = v }
+          end
+        end
+
         opts.on("-u", "--uri URI", "CalDAV server URI") do |v|
-          options[:uri] = v
+          cli_endpoint[:uri] = v
         end
 
         opts.on("-n", "--user USERNAME", "Username for CalDAV server") do |v|
-          options[:user] = v
+          cli_endpoint[:user] = v
         end
 
         opts.on("-p", "--password PASSWORD", "Password for CalDAV server") do |v|
-          options[:password] = v
+          cli_endpoint[:password] = v
         end
 
         opts.on("-d", "--device DEVICE", "Serial device for Timex Datalink watch") do |v|
@@ -39,8 +68,14 @@ module TimexDatalinkCaldav
         opts.on("-a", "--api PROTOCOL_VERSION", "Protocol Version") do |v|
           options[:api] = v
         end
+
+        opts.on("-f", "--forward DAYS", Integer, "Number of days to look forward for events") do |v|
+          options[:days_forward] = v
+        end
       end.parse!(arguments)
+      
+      options[:endpoints] = [cli_endpoint] if cli_endpoint.any? and options[:endpoints].nil?
       options
     end
   end
-end
+end

data/timex_datalink_caldav.gemspec

@@ -28,7 +28,7 @@ Gem::Specification.new do |spec|
   end
   spec.require_paths = ["lib"]
   spec.executables << 'timex_datalink_caldav'
-
+  spec.executables << 'get_ebrain_db'
   # Uncomment to register a new dependency of your gem
   # spec.add_dependency "example-gem", "~> 1.0"
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: timex_datalink_caldav
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 1.1.0
 platform: ruby
 authors:
 - Willy Hardy
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-05-17 00:00:00.000000000 Z
+date: 2023-05-26 00:00:00.000000000 Z
 dependencies: []
 description: 'Adds a CLI and a feature to pull your next day of calendar events into
   the Timex Datalink watch. Note: Hardcoded protocol1 and EST timezone. At the moment.'
@@ -16,17 +16,23 @@ email:
 - zpga8gbp@mailer.me
 executables:
 - timex_datalink_caldav
+- get_ebrain_db
 extensions: []
 extra_rdoc_files: []
 files:
 - CHANGELOG.md
 - Gemfile
 - Gemfile.lock
+- LICENSE
 - README.md
 - Rakefile
+- bin/get_ebrain_db
 - bin/timex_datalink_caldav
+- examples/README.md
+- examples/caldav.yaml.sample
 - lib/timex_datalink_caldav.rb
 - lib/timex_datalink_caldav/client.rb
+- lib/timex_datalink_caldav/similar_word.rb
 - lib/timex_datalink_caldav/version.rb
 - sig/timex_datalink_caldav.rbs
 - timex_datalink_caldav.gemspec
@@ -53,7 +59,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.10
+rubygems_version: 3.4.13
 signing_key:
 specification_version: 4
 summary: Allows the Timex Datalink watch to sync with a CalDAV server.