flycal-cli 0.7.3 → 0.7.7

data/lib/flycal_cli/pipeline/aggregator.rb

@@ -0,0 +1,229 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/date"
+require "active_support/core_ext/integer"
+require "active_support/core_ext/time"
+
+module FlycalCli
+  module Pipeline
+    # Second pipeline layer: group events and compute aggregate metrics.
+    #
+    # Default group_by from timeframe:
+    #   day   — timeframe <= 7 days
+    #   week  — timeframe > 7 days and <= 30 days
+    #   month — timeframe > 30 days
+    #
+    # Override with params[:group_by_option] / --groupBy:
+    #   day | week | month | description
+    class Aggregator
+      HOURS_PER_WORKING_DAY = 8
+      ALLOWED_GROUP_BY = %w[day week month description].freeze
+
+      def call(params)
+        time_min = params[:time_min]
+        time_max = params[:time_max]
+        events = Array(params[:events])
+
+        timeframe_days = (time_max - time_min) / 86400.0
+        group_by = resolve_group_by(timeframe_days, params[:group_by_option])
+
+        params[:timeframe_days] = timeframe_days
+        params[:group_by] = group_by
+
+        ranges = events.filter_map do |ev|
+          next if ev[:start_at].nil? || ev[:end_at].nil?
+
+          [ev[:start_at], ev[:end_at]]
+        end
+
+        total_minutes = ranges.sum { |s, e| (e - s) / 60.0 }
+        params[:totals] = {
+          event_count: events.size,
+          total_minutes: total_minutes,
+          hours: (total_minutes / 60.0).floor,
+          minutes: (total_minutes % 60).round,
+          working_days: (total_minutes / 60.0 / HOURS_PER_WORKING_DAY).round(1)
+        }
+
+        params[:groups] =
+          case group_by
+          when "week" then weekly_groups(events, ranges, time_min, time_max)
+          when "month" then monthly_groups(events, ranges, time_min, time_max)
+          when "description" then description_groups(events, params[:description])
+          else daily_groups(events, ranges, time_min, time_max)
+          end
+
+        params
+      end
+
+      def self.resolve_group_by(timeframe_days, explicit = nil)
+        key = explicit.to_s.strip.downcase
+        unless key.empty?
+          unless ALLOWED_GROUP_BY.include?(key)
+            raise FlycalCli::Error,
+                  "Unsupported groupBy #{explicit.inspect}. Available: #{ALLOWED_GROUP_BY.join(", ")}"
+          end
+          return key
+        end
+
+        if timeframe_days > 30
+          "month"
+        elsif timeframe_days > 7
+          "week"
+        else
+          "day"
+        end
+      end
+
+      private
+
+      def resolve_group_by(timeframe_days, explicit)
+        self.class.resolve_group_by(timeframe_days, explicit)
+      end
+
+      def daily_groups(events, ranges, time_min, time_max)
+        groups = []
+        index = 1
+        current = time_min.to_date
+        end_date = time_max.to_date
+
+        while current <= end_date
+          day_start = [current.to_time, time_min].max
+          day_end = [(current + 1).to_time, time_max].min
+          mins = minutes_in_period(ranges, day_start, day_end)
+          groups << build_group(
+            index: index,
+            key: current.strftime("%Y-%m-%d"),
+            start_at: day_start,
+            end_at: day_end,
+            period_label_end: current,
+            total_minutes: mins,
+            events: events_in_period(events, day_start, day_end)
+          )
+          index += 1
+          current += 1
+        end
+
+        groups
+      end
+
+      def weekly_groups(events, ranges, time_min, time_max)
+        groups = []
+        index = 1
+        current = time_min.to_date.beginning_of_week(:monday)
+
+        while current.to_time < time_max
+          week_start = [current.to_time, time_min].max
+          week_end_date = current.end_of_week(:monday)
+          week_end = [week_end_date.to_time + 1.day, time_max].min
+          mins = minutes_in_period(ranges, week_start, week_end)
+          groups << build_group(
+            index: index,
+            key: "W#{index}",
+            start_at: week_start,
+            end_at: week_end,
+            period_label_end: week_end_date,
+            total_minutes: mins,
+            events: events_in_period(events, week_start, week_end)
+          )
+          index += 1
+          current += 7
+        end
+
+        groups
+      end
+
+      def monthly_groups(events, ranges, time_min, time_max)
+        groups = []
+        index = 1
+        current = time_min.to_date.beginning_of_month
+        end_date = time_max.to_date
+
+        while current <= end_date
+          month_start = current.beginning_of_month.to_time
+          month_end = (current.end_of_month + 1.day).to_time
+          period_start = [month_start, time_min].max
+          period_end = [month_end, time_max].min
+          mins = minutes_in_period(ranges, period_start, period_end)
+          last_day = period_end.to_date - 1
+          groups << build_group(
+            index: index,
+            key: current.strftime("%Y-%m"),
+            start_at: period_start,
+            end_at: period_end,
+            period_label_end: last_day,
+            total_minutes: mins,
+            month_name: "#{Locale.month_name(current)} #{current.year}",
+            events: events_in_period(events, period_start, period_end)
+          )
+          index += 1
+          current = current.next_month.beginning_of_month
+        end
+
+        groups
+      end
+
+      def description_groups(events, description_query)
+        patterns = DescriptionQuery.patterns(description_query)
+        if patterns.empty?
+          raise FlycalCli::Error,
+                "groupBy description requires --description with at least one term (e.g. rui|solver)."
+        end
+
+        patterns.each_with_index.map do |pattern, idx|
+          matched = events.select do |ev|
+            DescriptionQuery.match_term?(ev[:summary], ev[:description], pattern)
+          end
+          minutes = matched.sum { |ev| ev[:duration_minutes].to_f }
+          build_group(
+            index: idx + 1,
+            key: pattern,
+            start_at: nil,
+            end_at: nil,
+            period_label_end: nil,
+            total_minutes: minutes,
+            events: matched,
+            description: pattern
+          )
+        end
+      end
+
+      def build_group(index:, key:, start_at:, end_at:, period_label_end:, total_minutes:, events:,
+                      month_name: nil, description: nil)
+        {
+          index: index,
+          key: key,
+          start_at: start_at,
+          end_at: end_at,
+          period_label_end: period_label_end,
+          month_name: month_name,
+          description: description,
+          event_count: events.size,
+          total_minutes: total_minutes,
+          hours: (total_minutes / 60.0).round(1),
+          working_days: (total_minutes / 60.0 / HOURS_PER_WORKING_DAY).round(1),
+          events: events
+        }
+      end
+
+      def events_in_period(events, period_start, period_end)
+        events.select do |ev|
+          start_at = ev[:start_at]
+          end_at = ev[:end_at]
+          next false if start_at.nil? || end_at.nil?
+
+          end_at > period_start && start_at < period_end
+        end
+      end
+
+      def minutes_in_period(ranges, period_start, period_end)
+        ranges.sum do |ev_start, ev_end|
+          overlap_start = [ev_start, period_start].max
+          overlap_end = [ev_end, period_end].min
+          overlap_sec = overlap_end - overlap_start
+          overlap_sec > 0 ? overlap_sec / 60.0 : 0
+        end
+      end
+    end
+  end
+end

data/lib/flycal_cli/pipeline/json_renderer.rb

@@ -0,0 +1,142 @@
+# frozen_string_literal: true
+
+require "json"
+
+module FlycalCli
+  module Pipeline
+    # Pretty-printed JSON output for search (API / tooling friendly).
+    class JsonRenderer < Renderer
+      def render(params)
+        payload = {
+          "params" => build_params(params),
+          "info" => build_info(params),
+          "items" => Array(params[:events]).map { |ev| serialize_event(ev) },
+          "groups" => build_groups(params)
+        }
+
+        JSON.pretty_generate(payload) + "\n"
+      end
+
+      private
+
+      def build_params(params)
+        out = {
+          "command" => params[:command] || "search",
+          "from" => format_time(params[:time_min]),
+          "to" => format_time(params[:time_max]),
+          "calendar" => params[:calendar],
+          "calendar_ids" => Array(params[:calendar_ids]),
+          "description" => params[:description],
+          "format" => params[:format] || "json",
+          "locale" => params[:locale] || Locale.current_locale,
+          "group_by" => params[:group_by],
+          "group_by_option" => blank_to_nil(params[:group_by_option]),
+          "from_option" => blank_to_nil(params[:from_option]),
+          "to_option" => blank_to_nil(params[:to_option]),
+          "in_option" => blank_to_nil(params[:in_option])
+        }
+
+        if params[:use_mock]
+          out["use_mock"] = true
+          out["mock_calendar"] = params[:mock_calendar]
+          out["mock_template"] = params[:mock_template]
+          out["mock_seed"] = params[:mock_seed]
+        end
+
+        out
+      end
+
+      def build_info(params)
+        totals = params[:totals] || {}
+        total_minutes = totals[:total_minutes].to_f
+        info = {
+          "events_found" => totals[:event_count].to_i,
+          "from" => format_time(params[:time_min]),
+          "to" => format_time(params[:time_max]),
+          "total_hours" => (total_minutes / 60.0).round(2),
+          "total_working_days" => totals[:working_days].to_f
+        }
+        info["mock_seed"] = params[:mock_seed] if params[:use_mock] && !params[:mock_seed].nil?
+        info
+      end
+
+      def build_groups(params)
+        type = params[:group_by].to_s
+        Array(params[:groups]).map do |group|
+          {
+            "type" => type,
+            "key" => group[:key],
+            "index" => group[:index],
+            "total_hours" => group[:hours],
+            "total_working_days" => group[:working_days],
+            "events_found" => group[:event_count] || Array(group[:events]).size,
+            "items" => Array(group[:events]).map { |ev| serialize_event(ev) }
+          }.tap do |g|
+            if type == "description"
+              g["description"] = group[:description] || group[:key]
+            else
+              g["from"] = format_group_boundary(group[:start_at])
+              g["to"] = format_group_boundary(group[:end_at])
+            end
+            g["month_name"] = group[:month_name] if group[:month_name]
+          end
+        end
+      end
+
+      # Shape inspired by Google Calendar API event resources.
+      def serialize_event(ev)
+        raw = ev[:raw]
+        payload = {
+          "summary" => ev[:summary],
+          "description" => ev[:description],
+          "start" => boundary_hash(ev[:start_at], all_day: ev[:all_day]),
+          "end" => boundary_hash(ev[:end_at], all_day: ev[:all_day]),
+          "calendarId" => ev[:calendar_id],
+          "calendarSummary" => ev[:calendar_name]
+        }
+
+        if raw
+          payload["id"] = raw.id if raw.respond_to?(:id) && raw.id
+          payload["status"] = raw.status if raw.respond_to?(:status) && raw.status
+          payload["htmlLink"] = raw.html_link if raw.respond_to?(:html_link) && raw.html_link
+          payload["created"] = format_time(raw.created) if raw.respond_to?(:created) && raw.created
+          payload["updated"] = format_time(raw.updated) if raw.respond_to?(:updated) && raw.updated
+          payload["location"] = raw.location if raw.respond_to?(:location) && raw.location
+          payload["iCalUID"] = raw.i_cal_uid if raw.respond_to?(:i_cal_uid) && raw.i_cal_uid
+        end
+
+        payload.compact
+      end
+
+      def boundary_hash(time, all_day:)
+        return nil if time.nil?
+
+        if all_day
+          { "date" => time.to_date.iso8601 }
+        else
+          { "dateTime" => format_time(time) }
+        end
+      end
+
+      def format_time(value)
+        return nil if value.nil?
+        return value.iso8601 if value.respond_to?(:iso8601)
+
+        value.to_s
+      end
+
+      # Compact local datetime used on group boundaries: YYYYMMDDTHHMMSS
+      def format_group_boundary(value)
+        return nil if value.nil?
+
+        t = value.respond_to?(:to_time) ? value.to_time : value
+        t.strftime("%Y%m%dT%H%M%S")
+      end
+
+      def blank_to_nil(value)
+        str = value.to_s
+        str.empty? ? nil : str
+      end
+    end
+  end
+end

data/lib/flycal_cli/pipeline/params.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module FlycalCli
+  module Pipeline
+    # Mutable bag of CLI + derived parameters passed through the pipeline.
+    class Params
+      def initialize(initial = {})
+        @data = {}
+        initial.each { |k, v| self[k] = v }
+      end
+
+      def [](key)
+        @data[key.to_sym]
+      end
+
+      def []=(key, value)
+        @data[key.to_sym] = value
+      end
+
+      def fetch(key, default = nil, &block)
+        if block
+          @data.fetch(key.to_sym, &block)
+        else
+          @data.fetch(key.to_sym, default)
+        end
+      end
+
+      def key?(key)
+        @data.key?(key.to_sym)
+      end
+
+      def merge!(other)
+        other.each { |k, v| self[k] = v }
+        self
+      end
+
+      def to_h
+        @data.dup
+      end
+
+      def each(&block)
+        @data.each(&block)
+      end
+    end
+  end
+end

data/lib/flycal_cli/pipeline/renderer.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module FlycalCli
+  module Pipeline
+    # Third pipeline layer: render aggregated results to a chosen format.
+    class Renderer
+      FORMATS = {
+        "text" => "FlycalCli::Pipeline::TextRenderer",
+        "json" => "FlycalCli::Pipeline::JsonRenderer"
+      }.freeze
+
+      def self.for(format)
+        key = format.to_s.strip.downcase
+        key = "text" if key.empty?
+        class_name = FORMATS[key]
+        raise FlycalCli::Error, "Unsupported format #{format.inspect}. Available: #{FORMATS.keys.join(", ")}" unless class_name
+
+        Object.const_get(class_name).new
+      end
+
+      # @return [String] rendered output
+      def render(params)
+        raise NotImplementedError, "#{self.class}#render must be implemented"
+      end
+    end
+  end
+end

data/lib/flycal_cli/pipeline/retriever.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module FlycalCli
+  module Pipeline
+    # First pipeline layer: fetch calendar events for the requested timeframe.
+    class Retriever
+      def initialize(calendar_service)
+        @service = calendar_service
+      end
+
+      # Expects params: :calendar_ids, :time_min, :time_max, optional :description
+      # Writes: :events (normalized), :calendar_names
+      def call(params)
+        calendar_ids = Array(params[:calendar_ids])
+        time_min = params[:time_min]
+        time_max = params[:time_max]
+        query = params[:description]
+
+        calendar_list = @service.list_calendars
+        calendar_names = calendar_list.to_h { |c| [c.id, c.summary || c.id] }
+        params[:calendar_names] = calendar_names
+
+        raw = @service.list_all_events(
+          calendar_ids,
+          time_min: time_min,
+          time_max: time_max,
+          query: query
+        )
+
+        params[:events] = raw.map { |item| normalize_event(item, calendar_names) }
+        params
+      end
+
+      private
+
+      def normalize_event(item, calendar_names)
+        event = item[:event]
+        cal_id = item[:calendar_id]
+        start_at = to_time(event.start&.date_time || event.start&.date)
+        end_at = to_time(event.end&.date_time || event.end&.date)
+        minutes =
+          if start_at && end_at && end_at > start_at
+            (end_at - start_at) / 60.0
+          else
+            0.0
+          end
+
+        {
+          calendar_id: cal_id,
+          calendar_name: calendar_names[cal_id] || cal_id,
+          summary: event.summary,
+          description: event.description,
+          start_at: start_at,
+          end_at: end_at,
+          duration_minutes: minutes,
+          all_day: !event.start&.date.nil? && event.start&.date_time.nil?,
+          raw: event
+        }
+      end
+
+      def to_time(value)
+        return nil if value.nil?
+        return value if value.is_a?(Time)
+        return value.to_time if value.respond_to?(:to_time) && !value.is_a?(String)
+
+        Time.parse(value.to_s)
+      rescue ArgumentError
+        nil
+      end
+    end
+  end
+end

data/lib/flycal_cli/pipeline/search_pipeline.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module FlycalCli
+  module Pipeline
+    # Orchestrates Retriever → Aggregator → Renderer for search.
+    class SearchPipeline
+      def initialize(calendar_service)
+        @service = calendar_service
+      end
+
+      def run(params)
+        Retriever.new(@service).call(params)
+        Aggregator.new.call(params)
+        Renderer.for(params[:format]).render(params)
+      end
+    end
+  end
+end

data/lib/flycal_cli/pipeline/text_renderer.rb

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+
+module FlycalCli
+  module Pipeline
+    # Shell text output — preserves the historical flycal search formatting.
+    class TextRenderer < Renderer
+      HOURS_PER_WORKING_DAY = Aggregator::HOURS_PER_WORKING_DAY
+
+      def render(params)
+        lines = []
+        lines.concat(event_lines(params))
+        lines << ""
+        lines.concat(summary_lines(params))
+        lines.join("\n") + "\n"
+      end
+
+      private
+
+      def event_lines(params)
+        Array(params[:events]).map do |ev|
+          start_str = format_datetime(ev[:start_at])
+          end_str = format_datetime(ev[:end_at])
+          desc = ev[:summary] || "(no title)"
+          if ev[:summary].nil? && ev[:description]
+            desc = ev[:description].to_s.slice(0, 80)
+          end
+          "#{ev[:calendar_name]} | #{start_str} | #{end_str} | #{desc}"
+        end
+      end
+
+      def summary_lines(params)
+        totals = params[:totals] || {}
+        time_min = params[:time_min]
+        time_max = params[:time_max]
+        from_str = time_min.strftime("%a %Y-%m-%d %H:%M")
+        to_str = time_max.strftime("%a %Y-%m-%d %H:%M")
+
+        lines = []
+        lines << "---"
+        lines << "From: #{from_str} | To: #{to_str}"
+        lines << "Events found: #{totals[:event_count]}"
+        lines << "Total time occupied: #{format_duration(totals[:total_minutes].to_f)}"
+        lines << "Mock seed: #{params[:mock_seed]}" if params[:use_mock] && !params[:mock_seed].nil?
+
+        case params[:group_by]
+        when "week"
+          lines << ""
+          lines << "By week:"
+          lines.concat(week_group_lines(params[:groups]))
+        when "month"
+          lines << ""
+          lines << "By month:"
+          lines.concat(month_group_lines(params[:groups]))
+        when "day"
+          if explicit_group_by?(params, "day")
+            lines << ""
+            lines << "By day:"
+            lines.concat(day_group_lines(params[:groups]))
+          end
+        when "description"
+          lines << ""
+          lines << "By description:"
+          lines.concat(description_group_lines(params[:groups]))
+        end
+
+        lines
+      end
+
+      def explicit_group_by?(params, value)
+        params[:group_by_option].to_s.strip.downcase == value
+      end
+
+      def day_group_lines(groups)
+        Array(groups).map do |g|
+          day_str = format_date_with_day(g[:start_at])
+          "  #{bold(g[:index])}. #{day_str}: #{format_hours_and_days(g[:hours], g[:working_days])}"
+        end
+      end
+
+      def week_group_lines(groups)
+        Array(groups).map do |g|
+          start_str = format_date_with_day(g[:start_at])
+          end_str = format_date_with_day(g[:period_label_end])
+          "  #{bold(g[:index])}. #{start_str} - #{end_str}: #{format_hours_and_days(g[:hours], g[:working_days])}"
+        end
+      end
+
+      def month_group_lines(groups)
+        Array(groups).map do |g|
+          start_str = format_date_with_day(g[:start_at])
+          end_str = format_date_with_day(g[:period_label_end])
+          "  #{g[:index]}. #{g[:month_name]} (#{start_str} - #{end_str}): #{format_hours_and_days(g[:hours], g[:working_days])}"
+        end
+      end
+
+      def description_group_lines(groups)
+        Array(groups).map do |g|
+          label = g[:description] || g[:key]
+          "  #{bold(g[:index])}. #{label}: #{g[:event_count]} events, #{format_hours_and_days(g[:hours], g[:working_days])}"
+        end
+      end
+
+      def format_datetime(dt)
+        return "-" if dt.nil?
+        return dt if dt.is_a?(String)
+
+        "#{Locale.day_abbr(dt)} #{dt.strftime("%Y-%m-%d %H:%M")}"
+      end
+
+      def format_date_with_day(dt)
+        return "-" if dt.nil?
+
+        t = dt.respond_to?(:to_time) ? dt.to_time : dt
+        "#{Locale.day_abbr(t)} #{t.strftime("%Y-%m-%d")}"
+      end
+
+      def format_duration(total_minutes)
+        hours = (total_minutes / 60).floor
+        mins = (total_minutes % 60).round
+        working_days = (total_minutes / 60.0 / HOURS_PER_WORKING_DAY).round(1)
+        "#{bold(hours)}h #{bold(mins)}min (#{bold(working_days)} working days)"
+      end
+
+      def format_hours_and_days(hours, working_days)
+        "#{bold(hours)}h (#{bold(working_days)} working days)"
+      end
+
+      def bold(str)
+        "\e[1m#{str}\e[0m"
+      end
+    end
+  end
+end

data/lib/flycal_cli/pipeline.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require "flycal_cli/pipeline/params"
+require "flycal_cli/pipeline/retriever"
+require "flycal_cli/pipeline/aggregator"
+require "flycal_cli/pipeline/renderer"
+require "flycal_cli/pipeline/text_renderer"
+require "flycal_cli/pipeline/json_renderer"
+require "flycal_cli/pipeline/search_pipeline"
+
+module FlycalCli
+  module Pipeline
+  end
+end

data/lib/flycal_cli/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module FlycalCli
-  VERSION = '0.7.3'
+  VERSION = '0.7.7'
 end