calendar-assistant 0.2.1 → 0.3.0

data/lib/calendar_assistant/cli_helpers.rb

@@ -20,28 +20,30 @@ class CalendarAssistant
     end
 
     def self.now
-      CalendarAssistant::Event.new(GCal::Event.new start: GCal::EventDateTime.new(date_time: Time.now),
-                      end: GCal::EventDateTime.new(date_time: Time.now),
-                      summary: Rainbow("          now          ").inverse.faint)
+      CalendarAssistant::Event.new(
+        Google::Apis::CalendarV3::Event.new(start: Google::Apis::CalendarV3::EventDateTime.new(date_time: Time.now),
+                                            end: Google::Apis::CalendarV3::EventDateTime.new(date_time: Time.now),
+                                            summary: Rainbow("          now          ").inverse.faint)
+      )
     end
 
     def self.find_av_uri ca, timespec
       time = Chronic.parse timespec
       range = time..(time+5.minutes)
-      events = ca.find_events range
+      event_set = ca.find_events range
 
-      [Google::Apis::CalendarV3::Event::Response::ACCEPTED,
-       Google::Apis::CalendarV3::Event::Response::TENTATIVE,
-       Google::Apis::CalendarV3::Event::Response::NEEDS_ACTION,
+      [CalendarAssistant::Event::Response::ACCEPTED,
+       CalendarAssistant::Event::Response::TENTATIVE,
+       CalendarAssistant::Event::Response::NEEDS_ACTION,
       ].each do |response|
-        events.reverse.select do |event|
+        event_set.events.reverse.select do |event|
           event.response_status == response
         end.each do |event|
-          return [event, event.av_uri] if event.av_uri
+          return [event_set.new(event), event.av_uri] if event.av_uri
         end
       end
 
-      nil
+      event_set.new(nil)
     end
 
     class Out
@@ -80,78 +82,139 @@ class CalendarAssistant
         return false if event.start_date != Date.today
 
         if event.start_time > Time.now
-          puts ca.event_description(CLIHelpers.now)
+          puts event_description(CLIHelpers.now)
           return true
         end
 
         false
       end
 
-      def print_events ca, events, options={}
-        unless options[:omit_title]
-          puts Rainbow("#{ca.calendar.id} (all times in #{ca.calendar.time_zone})\n").italic
-          options = options.merge(omit_title: true)
+      def print_events ca, event_set, omit_title: false
+        unless omit_title
+          er = event_set.event_repository
+          puts Rainbow("#{er.calendar.id} (all times in #{er.calendar.time_zone})\n").italic
         end
 
-        if events.is_a?(Hash)
-          events.each do |key, value|
+        if event_set.is_a?(EventSet::Hash)
+          event_set.events.each do |key, value|
             puts Rainbow(key.to_s.capitalize + ":").bold.italic
-            print_events ca, value, options
+            print_events ca, event_set.new(value), omit_title: true
           end
           return
         end
 
-        events = Array(events)
+        events = Array(event_set.events)
         if events.empty?
           puts "No events in this time range."
           return
         end
 
         display_events = events.select do |event|
-          ! options[:commitments] || event.commitment?
+          ! ca.config.setting(CalendarAssistant::Config::Keys::Options::COMMITMENTS) || event.commitment?
         end
 
         printed_now = false
         display_events.each do |event|
           printed_now = print_now! ca, event, printed_now
-          puts ca.event_description(event)
-          pp event if options[:debug]
+          puts event_description(event)
+          pp event if ca.config.debug?
         end
 
         puts
       end
 
-      def print_available_blocks ca, events, options={}
-        unless options[:omit_title]
-          puts Rainbow(sprintf("%s\n- all times in %s\n- looking for blocks at least %s long\n",
-                               ca.calendar.id,
-                               ca.calendar.time_zone,
-                               ChronicDuration.output(ChronicDuration.parse(ca.config.setting(Config::Keys::Settings::MEETING_LENGTH))))
-                      ).italic
-          options = options.merge(omit_title: true)
+      def print_available_blocks ca, event_set, omit_title: false
+        ers = ca.config.attendees.map { |calendar_id| ca.event_repository calendar_id }
+        time_zones = ers.map { |er| er.calendar.time_zone }.uniq
+
+        unless omit_title
+          puts Rainbow(ers.map { |er| er.calendar.id }.join(", ")).italic
+          puts Rainbow(sprintf("- looking for blocks at least %s long",
+                               ChronicDuration.output(
+                                 ChronicDuration.parse(
+                                   ca.config.setting(Config::Keys::Settings::MEETING_LENGTH))))).italic
+          time_zones.each do |time_zone|
+            puts Rainbow(sprintf("- between %s and %s in %s",
+                                 ca.config.setting(Config::Keys::Settings::START_OF_DAY),
+                                 ca.config.setting(Config::Keys::Settings::END_OF_DAY),
+                                 time_zone,
+                                )).italic
+          end
+          puts
         end
 
-        if events.is_a?(Hash)
-          events.each do |key, value|
+        if event_set.is_a?(EventSet::Hash)
+          event_set.events.each do |key, value|
             puts(sprintf(Rainbow("Availability on %s:\n").bold,
                          key.strftime("%A, %B %-d")))
-            print_available_blocks ca, value, options
+            print_available_blocks ca, event_set.new(value), omit_title: true
             puts
           end
           return
         end
 
-        events = Array(events)
+        events = Array(event_set.events)
         if events.empty?
           puts "  (No available blocks in this time range.)"
           return
         end
 
         events.each do |event|
-          puts(sprintf(" • %s - %s",
-                       event.start.date_time.strftime("%-l:%M%P"),
-                       event.end.date_time.strftime("%-l:%M%P")))
-          pp event if options[:debug]
+          line = []
+          time_zones.each do |time_zone|
+            line << sprintf("%s - %s",
+                            event.start_time.in_time_zone(time_zone).strftime("%l:%M%P"),
+                            event.end_time.in_time_zone(time_zone).strftime("%l:%M%P %Z"))
+          end
+          line.uniq!
+          puts " • " + line.join(" / ") + Rainbow(" (" + event.duration + ")").italic
+          pp event if ca.config.debug?
+        end
+      end
+
+      def event_description event
+        s = sprintf("%-25.25s", event_date_description(event))
+
+        date_ansi_codes = []
+        date_ansi_codes << :bright if event.current?
+        date_ansi_codes << :faint if event.past?
+        s = date_ansi_codes.inject(Rainbow(s)) { |text, ansi| text.send ansi }
+
+        s += Rainbow(sprintf(" | %s", event.view_summary)).bold
+
+        attributes = []
+        unless event.private?
+          attributes << "recurring" if event.recurring?
+          attributes << "not-busy" unless event.busy?
+          attributes << "self" if event.self? && !event.private?
+          attributes << "1:1" if event.one_on_one?
+          attributes << "awaiting" if event.awaiting?
+        end
+
+        attributes << event.visibility if event.explicit_visibility?
+
+        s += Rainbow(sprintf(" (%s)", attributes.to_a.sort.join(", "))).italic unless attributes.empty?
+
+        s = Rainbow(Rainbow.uncolor(s)).faint.strike if event.declined?
+
+        s
+      end
+
+      def event_date_description event
+        if event.all_day?
+          start_date = event.start_date
+          end_date = event.end_date
+          if (end_date - start_date) <= 1
+            event.start.to_s
+          else
+            sprintf("%s - %s", start_date, end_date - 1.day)
+          end
+        else
+          if event.start_date == event.end_date
+            sprintf("%s - %s", event.start.date_time.strftime("%Y-%m-%d  %H:%M"), event.end.date_time.strftime("%H:%M"))
+          else
+            sprintf("%s  -  %s", event.start.date_time.strftime("%Y-%m-%d %H:%M"), event.end.date_time.strftime("%Y-%m-%d %H:%M"))
+          end
         end
       end
     end

data/lib/calendar_assistant/config.rb

@@ -1,30 +1,48 @@
-require "toml"
-
 class CalendarAssistant
   class Config
+    autoload :TokenStore, "calendar_assistant/config/token_store"
+
     class TomlParseFailure < CalendarAssistant::BaseException ; end
     class NoConfigFileToPersist < CalendarAssistant::BaseException ; end
     class NoTokensAuthorized < CalendarAssistant::BaseException ; end
     class AccessingHashAsScalar < CalendarAssistant::BaseException ; end
 
     CONFIG_FILE_PATH = File.join ENV["HOME"], ".calendar-assistant"
+    DEFAULT_CALENDAR_ID = "primary"
 
     module Keys
       TOKENS = "tokens"
       SETTINGS = "settings"
 
+      #
+      #  Settings are values that have a value in DEFAULT_SETTINGS below,
+      #  and which can be overridden by entries in the user config file
+      #
       module Settings
-        PROFILE = "profile"
-        MEETING_LENGTH = "meeting-length"
-        START_OF_DAY = "start-of-day"
-        END_OF_DAY = "end-of-day"
+        PROFILE = "profile"               # string
+        MEETING_LENGTH = "meeting-length" # ChronicDuration
+        START_OF_DAY = "start-of-day"     # BusinessTime
+        END_OF_DAY = "end-of-day"         # BusinessTime
+      end
+
+      #
+      #  Options are ephemeral command-line flag settings which _may_
+      #  have a value in DEFAULT_SETTINGS below
+      #
+      module Options
+        COMMITMENTS = "commitments" # bool
+        JOIN = "join"               # bool
+        ATTENDEES = "attendees"     # array of calendar ids (comma-delimited)
+        LOCAL_STORE = "local-store" # filename
+        DEBUG = "debug"             # bool
       end
     end
 
     DEFAULT_SETTINGS = {
-      Keys::Settings::MEETING_LENGTH => "30m", # ChronicDuration
-      Keys::Settings::START_OF_DAY => "9am", # Chronic
-      Keys::Settings::END_OF_DAY => "6pm", # Chronic
+      Keys::Settings::MEETING_LENGTH => "30m",            # ChronicDuration
+      Keys::Settings::START_OF_DAY => "9am",              # BusinessTime
+      Keys::Settings::END_OF_DAY => "6pm",                # BusinessTime
+      Keys::Options::ATTENDEES => [DEFAULT_CALENDAR_ID],  # array of calendar ids
     }
 
     attr_reader :config_file_path, :user_config, :options, :defaults
@@ -58,9 +76,23 @@ class CalendarAssistant
       @options = options
     end
 
+    def in_env &block
+      # this is totally not thread-safe
+      orig_b_o_d = BusinessTime::Config.beginning_of_workday
+      orig_e_o_d = BusinessTime::Config.end_of_workday
+      begin
+        BusinessTime::Config.beginning_of_workday = setting(Config::Keys::Settings::START_OF_DAY)
+        BusinessTime::Config.end_of_workday = setting(Config::Keys::Settings::END_OF_DAY)
+        yield
+      ensure
+        BusinessTime::Config.beginning_of_workday = orig_b_o_d
+        BusinessTime::Config.end_of_workday = orig_e_o_d
+      end
+    end
+
     def profile_name
       # CLI option takes precedence
-      return options["profile"] if options["profile"]
+      return options[Keys::Settings::PROFILE] if options[Keys::Settings::PROFILE]
 
       # then a configured preference takes precedence
       default = get([Keys::SETTINGS, Keys::Settings::PROFILE])
@@ -91,12 +123,26 @@ class CalendarAssistant
       Config.set_in_hash user_config, keypath, value
     end
 
+    #
+    #  note that, despite the name, this method returns both options
+    #  and settings
+    #
     def setting setting_name
       Config.find_in_hash(options, setting_name) ||
         Config.find_in_hash(user_config, [Keys::SETTINGS, setting_name]) ||
         Config.find_in_hash(defaults, setting_name)
     end
 
+    def settings
+      setting_names = CalendarAssistant::Config::Keys::Settings.constants.map do |k|
+        CalendarAssistant::Config::Keys::Settings.const_get k
+      end
+      setting_names.inject({}) do |settings, key|
+        settings[key] = setting key
+        settings
+      end
+    end
+
     def tokens
       Config.find_in_hash(user_config, Keys::TOKENS) ||
         Config.set_in_hash(user_config, Keys::TOKENS, {})
@@ -118,6 +164,21 @@ class CalendarAssistant
       end
     end
 
+    #
+    #  helper method for Keys::Options::ATTENDEES
+    #
+    def attendees
+      a = setting(Keys::Options::ATTENDEES)
+      if a.is_a?(String)
+        a = a.split(",")
+      end
+      a
+    end
+
+    def debug?
+      setting(Keys::Options::DEBUG)
+    end
+
     private
 
     def self.find_in_hash hash, keypath
@@ -150,5 +211,3 @@ class CalendarAssistant
     end
   end
 end
-
-require "calendar_assistant/config/token_store"

data/lib/calendar_assistant/date_helpers.rb

@@ -0,0 +1,16 @@
+class CalendarAssistant
+  module DateHelpers
+    def self.cast_dates attributes
+      attributes.each_with_object({}) do |(key, value), object|
+        if value.is_a?(Time) || value.is_a?(DateTime)
+          object[key] = Google::Apis::CalendarV3::EventDateTime.new(date_time: value)
+        elsif value.is_a?(Date)
+          object[key] = Google::Apis::CalendarV3::EventDateTime.new(date: value.to_s)
+        else
+          object[key] = value
+        end
+      end
+    end
+  end
+end
+

data/lib/calendar_assistant/event.rb

@@ -1,10 +1,42 @@
 class CalendarAssistant
   class Event < SimpleDelegator
+    #
+    #  constants describing enumerated attribute values
+    #  see https://developers.google.com/calendar/v3/reference/events
+    #
+    module RealResponse
+      DECLINED = "declined"
+      ACCEPTED = "accepted"
+      NEEDS_ACTION = "needsAction"
+      TENTATIVE = "tentative"
+    end
+
+    module Response
+      include RealResponse
+      SELF = "self" # not part of Google's API, but useful to represent meetings-for-myself
+    end
 
+    module Transparency
+      TRANSPARENT = "transparent"
+      OPAQUE = "opaque"
+    end
+
+    module Visibility
+      DEFAULT = "default"
+      PUBLIC = "public"
+      PRIVATE = "private"
+    end
+
+    #
+    #  constants describing behavior
+    #
     LOCATION_EVENT_REGEX = /^#{CalendarAssistant::EMOJI_WORLDMAP}/
 
+    #
+    #  methods
+    #
     def update **args
-      super
+      update!(**args)
       self
     end
 
@@ -13,14 +45,14 @@ class CalendarAssistant
     end
 
     def all_day?
-      !! start.to_date
+      start.try(:date) || self.end.try(:date)
     end
 
     def past?
       if all_day?
-        Date.today >= self.end.to_date
+        Date.today >= end_date
       else
-        Time.now >= self.end.date_time
+        Time.now >= end_time
       end
     end
 
@@ -30,18 +62,26 @@ class CalendarAssistant
 
     def future?
       if all_day?
-        self.start.to_date > Date.today
+        start_date > Date.today
       else
-        self.start.date_time > Time.now
+        start_time > Time.now
       end
     end
 
     def accepted?
-      response_status == GCal::Event::Response::ACCEPTED
+      response_status == CalendarAssistant::Event::Response::ACCEPTED
     end
 
     def declined?
-      response_status == GCal::Event::Response::DECLINED
+      response_status == CalendarAssistant::Event::Response::DECLINED
+    end
+
+    def awaiting?
+      response_status == CalendarAssistant::Event::Response::NEEDS_ACTION
+    end
+
+    def self?
+      response_status == CalendarAssistant::Event::Response::SELF
     end
 
     def one_on_one?
@@ -52,7 +92,7 @@ class CalendarAssistant
     end
 
     def busy?
-      transparency != GCal::Event::Transparency::TRANSPARENT
+      transparency != CalendarAssistant::Event::Transparency::TRANSPARENT
     end
 
     def commitment?
@@ -62,20 +102,24 @@ class CalendarAssistant
     end
 
     def private?
-      visibility == GCal::Event::Visibility::PRIVATE
+      visibility == CalendarAssistant::Event::Visibility::PRIVATE
     end
 
     def public?
-      visibility == GCal::Event::Visibility::PUBLIC
+      visibility == CalendarAssistant::Event::Visibility::PUBLIC
     end
 
     def explicit_visibility?
       private? || public?
     end
 
+    def recurring?
+      !!recurring_event_id
+    end
+
     def start_time
       if all_day?
-        start.to_date.beginning_of_day
+        start_date.beginning_of_day
       else
         start.date_time
       end
@@ -85,7 +129,23 @@ class CalendarAssistant
       if all_day?
         start.to_date
       else
-        start.date_time.to_date
+        start_time.to_date
+      end
+    end
+
+    def end_time
+      if all_day?
+        end_date.beginning_of_day
+      else
+        self.end.date_time
+      end
+    end
+
+    def end_date
+      if all_day?
+        self.end.to_date
+      else
+        end_time.to_date
       end
     end
 
@@ -94,5 +154,55 @@ class CalendarAssistant
       return "(no title)" if summary.nil? || summary.blank?
       summary
     end
+
+    def duration
+      if all_day?
+        days = (end_date - start_date).to_i
+        return "#{days}d"
+      end
+
+      p = ActiveSupport::Duration.build(end_time - start_time).parts
+      s = []
+      s << "#{p[:hours]}h" if p.has_key?(:hours)
+      s << "#{p[:minutes]}m" if p.has_key?(:minutes)
+      s.join(" ")
+    end
+
+    def human_attendees
+      return nil if attendees.nil?
+      attendees.select { |a| ! a.resource }
+    end
+
+    def attendee id
+      return nil if attendees.nil?
+      attendees.find do |attendee|
+        attendee.email == id
+      end
+    end
+
+    def response_status
+      return CalendarAssistant::Event::Response::SELF if attendees.nil?
+      attendees.each do |attendee|
+        return attendee.response_status if attendee.self
+      end
+      nil
+    end
+
+    def av_uri
+      @av_uri ||= begin
+                    description_link = CalendarAssistant::StringHelpers.find_uri_for_domain(description, "zoom.us")
+                    return description_link if description_link
+
+                    location_link = CalendarAssistant::StringHelpers.find_uri_for_domain(location, "zoom.us")
+                    return location_link if location_link
+
+                    return hangout_link if hangout_link
+                    nil
+                  end
+    end
+
+    def contains? time
+      start_time <= time && time < end_time
+    end
   end
-end
+end