r_cal 0.1.0

data/lib/rcal/adapters/calendar/google.rb

@@ -0,0 +1,161 @@
+require "time"
+require "google/apis/calendar_v3"
+require_relative "base"
+require_relative "../../models/calendar"
+require_relative "../../models/event"
+
+module Rcal
+  module Adapters
+    module Calendar
+      class Google < Base
+        def initialize(service:)
+          @service = service
+        end
+
+        def list_calendars
+          response = @service.list_calendar_lists
+          items = response.items || []
+
+          items.map { |cal| build_calendar(cal) }
+        end
+
+        def list_events(calendar_id:, time_min:, time_max:)
+          response = @service.list_events(
+            calendar_id,
+            time_min: time_min.iso8601,
+            time_max: time_max.iso8601,
+            single_events: true,
+            order_by: "startTime"
+          )
+
+          items = response.items || []
+
+          items.map { |evt| build_event(evt, calendar_id: calendar_id) }
+        end
+
+        def get_event(calendar_id:, event_id:)
+          google_event = @service.get_event(calendar_id, event_id)
+          build_event(google_event, calendar_id: calendar_id)
+        end
+
+        def create_event(calendar_id:, event:)
+          google_event = build_google_event(event)
+          response = @service.insert_event(calendar_id, google_event)
+          build_event(response, calendar_id: calendar_id)
+        end
+
+        def update_event(calendar_id:, event_id:, event:)
+          google_event = build_google_event(event)
+          response = @service.update_event(calendar_id, event_id, google_event)
+          build_event(response, calendar_id: calendar_id)
+        end
+
+        def delete_event(calendar_id:, event_id:)
+          @service.delete_event(calendar_id, event_id)
+          true
+        end
+
+        def quick_add(calendar_id:, text:)
+          response = @service.quick_add_event(calendar_id, text)
+          build_event(response, calendar_id: calendar_id)
+        end
+
+        private
+
+        def build_calendar(google_calendar)
+          Rcal::Calendar.new(
+            id: google_calendar.id,
+            name: google_calendar.summary,
+            description: google_calendar.description,
+            timezone: google_calendar.time_zone,
+            color: google_calendar.background_color,
+            access_role: google_calendar.access_role,
+            primary: google_calendar.primary || false,
+            selected: google_calendar.selected || false
+          )
+        end
+
+        def build_event(google_event, calendar_id:)
+          start_time, all_day = parse_event_time(google_event.start)
+          end_time, = parse_event_time(google_event.end)
+
+          Rcal::Event.new(
+            id: google_event.id,
+            summary: google_event.summary,
+            description: google_event.description,
+            location: google_event.location,
+            start_time: start_time,
+            end_time: end_time,
+            all_day: all_day,
+            calendar_id: calendar_id,
+            transparency: google_event.transparency,
+            recurrence: google_event.recurrence,
+            recurring_event_id: google_event.recurring_event_id,
+            response_status: extract_self_response_status(google_event.attendees),
+            attendees: build_attendees(google_event.attendees),
+            timezone: google_event.start&.time_zone
+          )
+        end
+
+        def parse_event_time(time_obj)
+          return [Time.now, false] if time_obj.nil?
+
+          if time_obj.date_time
+            # Google returns DateTime; convert to Time for consistent arithmetic
+            [time_obj.date_time.to_time, false]
+          elsif time_obj.date
+            [Date.parse(time_obj.date).to_time, true]
+          else
+            [Time.now, false]
+          end
+        end
+
+        def extract_self_response_status(attendees)
+          return nil if attendees.nil?
+
+          self_attendee = attendees.find { |a| a.self }
+          self_attendee&.response_status
+        end
+
+        def build_attendees(google_attendees)
+          return nil if google_attendees.nil?
+
+          google_attendees.map do |attendee|
+            {
+              email: attendee.email,
+              response_status: attendee.response_status,
+              self: attendee.self || false,
+              resource: attendee.resource || false
+            }
+          end
+        end
+
+        def build_google_event(event)
+          google_event = ::Google::Apis::CalendarV3::Event.new(
+            summary: event.summary,
+            description: event.description,
+            location: event.location
+          )
+
+          if event.all_day?
+            google_event.start = ::Google::Apis::CalendarV3::EventDateTime.new(
+              date: event.start_time.to_date.to_s
+            )
+            google_event.end = ::Google::Apis::CalendarV3::EventDateTime.new(
+              date: event.end_time.to_date.to_s
+            )
+          else
+            google_event.start = ::Google::Apis::CalendarV3::EventDateTime.new(
+              date_time: event.start_time.iso8601
+            )
+            google_event.end = ::Google::Apis::CalendarV3::EventDateTime.new(
+              date_time: event.end_time.iso8601
+            )
+          end
+
+          google_event
+        end
+      end
+    end
+  end
+end

data/lib/rcal/adapters/date_parser/base.rb

@@ -0,0 +1,11 @@
+module Rcal
+  module Adapters
+    module DateParser
+      class Base
+        def parse(input)
+          raise NotImplementedError, "#{self.class} must implement #parse"
+        end
+      end
+    end
+  end
+end

data/lib/rcal/adapters/date_parser/chronic.rb

@@ -0,0 +1,86 @@
+require "chronic"
+require "date"
+require_relative "base"
+require_relative "../../errors"
+
+module Rcal
+  module Adapters
+    module DateParser
+      class Chronic < Base
+        # Custom relative date pattern: +N, +Nd, +Nw
+        RELATIVE_PATTERN = /\A\+(\d+)(d|w)?\z/i
+
+        class << self
+          def parse(input)
+            new.parse(input)
+          end
+        end
+
+        def parse(input)
+          normalized = normalize_input(input)
+          validate_input!(normalized)
+
+          result = parse_relative(normalized) ||
+            parse_with_chronic(normalized)
+
+          raise Rcal::ParseError, "Could not parse: #{input.inspect}" if result.nil?
+
+          normalize_result(result, has_time_component?(normalized))
+        end
+
+        private
+
+        def normalize_input(input)
+          input.to_s.strip
+        end
+
+        def validate_input!(input)
+          raise Rcal::ParseError, "Input cannot be empty" if input.empty?
+        end
+
+        def parse_relative(input)
+          match = input.match(RELATIVE_PATTERN)
+          return nil unless match
+
+          count = match[1].to_i
+          unit = match[2]&.downcase
+
+          case unit
+          when "w"
+            Date.today + (count * 7)
+          else
+            Date.today + count
+          end
+        end
+
+        def parse_with_chronic(input)
+          ::Chronic.parse(input)
+        end
+
+        def has_time_component?(input)
+          # Check if input contains time-related patterns
+          time_patterns = [
+            /\d{1,2}:\d{2}/,           # 14:30, 2:30
+            /\d{1,2}\s*(am|pm)/i,      # 3pm, 3 pm
+            /at\s+\d/i,                # at 3, at 14
+            /noon/i,
+            /midnight/i
+          ]
+
+          time_patterns.any? { |pattern| input.match?(pattern) }
+        end
+
+        def normalize_result(result, preserve_time)
+          case result
+          when Time
+            preserve_time ? result : result.to_date
+          when Date
+            result
+          else
+            result.to_date
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rcal/adapters/duration_parser/base.rb

@@ -0,0 +1,15 @@
+module Rcal
+  module Adapters
+    module DurationParser
+      class Base
+        def parse(input)
+          raise NotImplementedError, "#{self.class} must implement #parse"
+        end
+
+        def parse_minutes(input)
+          raise NotImplementedError, "#{self.class} must implement #parse_minutes"
+        end
+      end
+    end
+  end
+end

data/lib/rcal/adapters/duration_parser/chronic_duration.rb

@@ -0,0 +1,47 @@
+require "chronic_duration"
+require_relative "base"
+require_relative "../../errors"
+
+module Rcal
+  module Adapters
+    module DurationParser
+      class ChronicDuration < Base
+        class << self
+          def parse(input)
+            new.parse(input)
+          end
+
+          def parse_minutes(input)
+            new.parse_minutes(input)
+          end
+        end
+
+        def parse(input)
+          normalized = normalize_input(input)
+          validate_input!(normalized)
+
+          result = ::ChronicDuration.parse(normalized)
+
+          raise Rcal::ParseError, "Could not parse duration: #{input.inspect}" if result.nil?
+
+          result
+        end
+
+        def parse_minutes(input)
+          seconds = parse(input)
+          seconds / 60
+        end
+
+        private
+
+        def normalize_input(input)
+          input.to_s.strip
+        end
+
+        def validate_input!(input)
+          raise Rcal::ParseError, "Input cannot be empty" if input.empty?
+        end
+      end
+    end
+  end
+end

data/lib/rcal/adapters/ics_parser/base.rb

@@ -0,0 +1,15 @@
+module Rcal
+  module Adapters
+    module IcsParser
+      class Base
+        def parse(content)
+          raise NotImplementedError, "#{self.class} must implement #parse"
+        end
+
+        def parse_file(path)
+          raise NotImplementedError, "#{self.class} must implement #parse_file"
+        end
+      end
+    end
+  end
+end

data/lib/rcal/adapters/ics_parser/icalendar.rb

@@ -0,0 +1,68 @@
+require "icalendar"
+require_relative "base"
+require_relative "../../models/event"
+require_relative "../../errors"
+
+module Rcal
+  module Adapters
+    module IcsParser
+      class Icalendar < Base
+        def parse(content)
+          calendars = ::Icalendar::Calendar.parse(content)
+          raise Rcal::ParseError, "Invalid ICS content" if calendars.empty?
+
+          extract_events(calendars)
+        rescue ::Icalendar::Parser::ParseError => e
+          raise Rcal::ParseError, "Failed to parse ICS: #{e.message}"
+        end
+
+        def parse_file(path)
+          raise Rcal::ParseError, "File not found: #{path}" unless File.exist?(path)
+
+          content = File.read(path)
+          parse(content)
+        end
+
+        private
+
+        def extract_events(calendars)
+          calendars.flat_map do |calendar|
+            calendar.events.map { |ics_event| build_event(ics_event) }
+          end
+        end
+
+        def build_event(ics_event)
+          start_time, all_day = parse_datetime(ics_event.dtstart)
+          end_time, = parse_datetime(ics_event.dtend)
+
+          Rcal::Event.new(
+            summary: ics_event.summary&.to_s,
+            description: presence(ics_event.description&.to_s),
+            location: presence(ics_event.location&.to_s),
+            start_time: start_time,
+            end_time: end_time,
+            all_day: all_day
+          )
+        end
+
+        def presence(value)
+          return nil if value.nil? || value.empty?
+          value
+        end
+
+        def parse_datetime(dt)
+          return [Time.now, false] if dt.nil?
+
+          case dt
+          when ::Icalendar::Values::Date
+            [dt.to_time, true]
+          when ::Icalendar::Values::DateTime
+            [dt.to_time, false]
+          else
+            [dt.to_time, false]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rcal/auth.rb

@@ -0,0 +1,46 @@
+require_relative "adapters/auth/google"
+require_relative "config"
+
+module Rcal
+  class Auth
+    class << self
+      def store_credentials(credentials)
+        adapter.store_credentials(credentials)
+      end
+
+      def load_credentials
+        adapter.load_credentials
+      end
+
+      def authenticated?
+        adapter.authenticated?
+      end
+
+      def token_expired?
+        adapter.token_expired?
+      end
+
+      def clear_credentials
+        adapter.clear_credentials
+      end
+
+      def adapter
+        @adapter ||= default_adapter
+      end
+
+      attr_writer :adapter
+
+      def reset_adapter!
+        @adapter = nil
+      end
+
+      private
+
+      def default_adapter
+        Adapters::Auth::Google.new(
+          token_path: File.join(Configuration.data_dir, "tokens.json")
+        )
+      end
+    end
+  end
+end

data/lib/rcal/calendar_service.rb

@@ -0,0 +1,103 @@
+require "json"
+require "yaml"
+require "google/apis/calendar_v3"
+require "googleauth"
+require_relative "adapters/calendar/google"
+require_relative "auth"
+require_relative "config"
+
+module Rcal
+  class CalendarService
+    class << self
+      def list_calendars
+        adapter.list_calendars
+      end
+
+      def list_events(calendar_id:, time_min:, time_max:)
+        adapter.list_events(
+          calendar_id: calendar_id,
+          time_min: time_min,
+          time_max: time_max
+        )
+      end
+
+      def get_event(calendar_id:, event_id:)
+        adapter.get_event(calendar_id: calendar_id, event_id: event_id)
+      end
+
+      def create_event(calendar_id:, event:)
+        adapter.create_event(calendar_id: calendar_id, event: event)
+      end
+
+      def update_event(calendar_id:, event_id:, event:)
+        adapter.update_event(calendar_id: calendar_id, event_id: event_id, event: event)
+      end
+
+      def delete_event(calendar_id:, event_id:)
+        adapter.delete_event(calendar_id: calendar_id, event_id: event_id)
+      end
+
+      def quick_add(calendar_id:, text:)
+        adapter.quick_add(calendar_id: calendar_id, text: text)
+      end
+
+      def adapter
+        @adapter ||= default_adapter
+      end
+
+      attr_writer :adapter
+
+      def reset_adapter!
+        @adapter = nil
+      end
+
+      private
+
+      def default_adapter
+        Adapters::Calendar::Google.new(service: build_calendar_service)
+      end
+
+      def build_calendar_service
+        service = Google::Apis::CalendarV3::CalendarService.new
+        service.authorization = load_credentials
+        service
+      end
+
+      def load_credentials
+        client_creds = load_client_credentials
+        token_data = load_google_token_data
+
+        return nil if client_creds.nil? || token_data.nil?
+
+        Google::Auth::UserRefreshCredentials.new(
+          client_id: client_creds["client_id"],
+          client_secret: client_creds["client_secret"],
+          access_token: token_data["access_token"],
+          refresh_token: token_data["refresh_token"],
+          expires_at: token_data["expiration_time_millis"] ? Time.at(token_data["expiration_time_millis"] / 1000) : nil
+        )
+      end
+
+      def load_client_credentials
+        creds_file = File.join(Configuration.data_dir, "client_credentials.json")
+        return nil unless File.exist?(creds_file)
+
+        JSON.parse(File.read(creds_file))
+      rescue JSON::ParserError
+        nil
+      end
+
+      def load_google_token_data
+        token_file = File.join(Configuration.data_dir, "google_tokens.yaml")
+        return nil unless File.exist?(token_file)
+
+        yaml_data = YAML.safe_load_file(token_file)
+        return nil unless yaml_data&.key?("default")
+
+        JSON.parse(yaml_data["default"])
+      rescue JSON::ParserError, Psych::SyntaxError
+        nil
+      end
+    end
+  end
+end

data/lib/rcal/command.rb

@@ -0,0 +1,33 @@
+require "cli/kit"
+
+module Rcal
+  class Command < CLI::Kit::BaseCommand
+    def call(args, command_name)
+      if help_requested?(args)
+        display_help
+        return
+      end
+
+      run(args, command_name)
+    end
+
+    # Subclasses implement this instead of call
+    def run(args, command_name)
+      raise NotImplementedError, "#{self.class} must implement #run"
+    end
+
+    private
+
+    def help_requested?(args)
+      args.any? { |arg| arg == "help" || arg == "-h" || arg == "--help" }
+    end
+
+    def display_help
+      if self.class.respond_to?(:help) && self.class.help
+        puts self.class.help
+      else
+        puts "No help available for this command."
+      end
+    end
+  end
+end