qtimetrap 0.1.1

data/app/view_models/entry_nodes_builder.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+module QTimetrap
+  module ViewModels
+    # Builds hierarchical week/day/project/entry nodes for entries list UI.
+    class EntryNodesBuilder
+      def initialize(entries:, selected_project:)
+        @entries = entries
+        @selected_project = selected_project
+      end
+
+      def build
+        nodes = week_groups.map { |week_start, entries| week_node(week_start, entries) }
+        nodes.empty? ? [empty_node] : nodes
+      end
+
+      private
+
+      attr_reader :entries, :selected_project
+
+      def week_groups
+        entries.group_by { |entry| week_start_for(entry.day) }.sort_by { |week_start, _| week_start }.reverse
+      end
+
+      def week_node(week_start, week_entries)
+        total = Services::Formatters.seconds_to_hms(week_entries.sum(&:duration_seconds))
+        week_end = week_start + 6
+        {
+          id: "week:#{week_start}",
+          type: :week,
+          label: "Week #{week_start.strftime('%b %-d')} - #{week_end.strftime('%b %-d')}  Total: #{total}",
+          children: day_nodes(week_entries)
+        }
+      end
+
+      def day_nodes(week_entries)
+        week_entries.group_by(&:day).keys.sort.reverse.map do |day|
+          day_entries = week_entries.select { |entry| entry.day == day }
+          total = Services::Formatters.seconds_to_hms(day_entries.sum(&:duration_seconds))
+          {
+            id: "day:#{day}",
+            type: :day,
+            label: "#{day.strftime('%a, %b %-d')}  Total: #{total}",
+            children: project_nodes(day, day_entries)
+          }
+        end
+      end
+
+      def project_nodes(day, day_entries)
+        grouped = day_entries.group_by { |entry| [entry.project, entry.task] }
+        grouped
+          .sort_by { |_key, items| latest_start_time(items) }
+          .reverse
+          .map do |(project, task), items|
+            total = Services::Formatters.seconds_to_hms(items.sum(&:duration_seconds))
+            {
+              id: "project:#{day}:#{project}:#{task}",
+              type: :project,
+              label: "#{project} | #{task} (#{items.size}) #{total}",
+              children: entry_detail_nodes(items)
+            }
+          end
+      end
+
+      def entry_detail_nodes(items)
+        items.sort_by { |entry| entry.start_time || Time.at(0) }.reverse.each_with_index.map do |entry, index|
+          entry_node(entry, index)
+        end
+      end
+
+      def entry_node(entry, index)
+        note = entry.note.strip
+        display_note = note.empty? ? '(no note)' : note
+        start_label, end_label = Services::Formatters.time_bounds(entry)
+        duration = Services::Formatters.seconds_to_hms(entry.duration_seconds)
+        {
+          id: "entry:#{entry.id || index}",
+          type: :entry,
+          entry_id: entry.id || index,
+          project_name: entry.project,
+          task_name: entry.task.to_s,
+          start_label: start_label,
+          end_label: end_label,
+          prefix: duration,
+          note: note,
+          label: "#{start_label} - #{end_label}  #{duration}  #{display_note}",
+          children: []
+        }
+      end
+
+      def latest_start_time(items)
+        items.map { |entry| entry.start_time || Time.at(0) }.max
+      end
+
+      def empty_node
+        {
+          id: "empty:#{selected_project}",
+          type: :empty,
+          label: "No entries for filter: #{selected_project}",
+          children: []
+        }
+      end
+
+      def week_start_for(day)
+        day - ((day.wday + 6) % 7)
+      end
+    end
+  end
+end

data/app/view_models/main_view_model.rb

@@ -0,0 +1,135 @@
+# frozen_string_literal: true
+
+require 'date'
+
+module QTimetrap
+  module ViewModels
+    # Coordinates tracker data and exposes presentation-ready state for UI.
+    class MainViewModel
+      include MainViewModelEntryTaskHelpers
+      include MainViewModelEntryNoteHelpers
+      include MainViewModelEntryTimeHelpers
+      include MainViewModelSheetHelpers
+      include MainViewModelTaskFilterHelpers
+      include MainViewModelTimeRangeFilterHelpers
+      include MainViewModelArchiveModeHelpers
+
+      EPOCH_TIME = Time.at(0)
+
+      attr_reader :selected_project, :selected_projects, :selected_tasks, :entries, :current_started_at, :current_sheet,
+                  :time_filter_from_at, :time_filter_to_at
+
+      def initialize(gateway: Services::TimetrapGateway.new, archived_entries_store: Services::ArchivedEntriesStore.new)
+        @gateway = gateway
+        @archived_entries_store = archived_entries_store
+        initialize_state
+      end
+
+      def refresh!
+        @current_started_at = gateway.active_started_at
+        @entries = gateway.entries
+        @current_sheet = detect_current_sheet
+        reset_archive_mode_caches!
+        normalize_selected_projects!
+        seed_current_fields_from_sheet!
+        normalize_selected_tasks!
+        self
+      end
+
+      def select_project(project, sync_current_fields: true)
+        select_projects([project], primary_project: project, sync_current_fields: sync_current_fields)
+      end
+
+      def select_projects(projects, primary_project:, sync_current_fields: true)
+        normalized = Array(projects).map(&:to_s).reject(&:empty?).uniq
+        normalized = ['* ALL'] if normalized.empty? || normalized.include?('* ALL')
+        @selected_projects = normalized
+        @selected_project = normalized.include?(primary_project) ? primary_project : normalized.first
+        @selected_tasks = []
+        return unless sync_current_fields
+
+        apply_selected_project_to_current_field!
+        self.current_task_input = latest_task_for_project(@selected_project)
+      end
+
+      def start_tracking(sheet)
+        value = normalize_text(sheet).strip
+        raise ArgumentError, 'Task is required' if value.empty?
+
+        gateway.start(value)
+        @current_started_at = Time.now unless current_started_at
+      end
+
+      def stop_tracking
+        gateway.stop
+        @current_started_at = nil
+      end
+
+      def week_total_seconds
+        start_of_week = Date.today - ((Date.today.wday + 6) % 7)
+        filtered_entries.sum do |entry|
+          entry.day >= start_of_week ? entry.duration_seconds : 0
+        end
+      end
+
+      def total_seconds
+        filtered_entries.sum(&:duration_seconds)
+      end
+
+      def summary_line
+        "Week total: #{Services::Formatters.seconds_to_hms(week_total_seconds)} | " \
+          "Total: #{Services::Formatters.seconds_to_hms(total_seconds)}"
+      end
+
+      def running_timer_line(now: Time.now)
+        return '00:00:00' unless current_started_at
+
+        Services::Formatters.seconds_to_hms(now.to_i - current_started_at.to_i)
+      end
+
+      def running_current_sheet? = !current_started_at.nil?
+
+      def entry_nodes
+        EntryNodesBuilder.new(entries: filtered_entries, selected_project: selected_project).build
+      end
+
+      private
+
+      attr_reader :gateway, :archived_entries_store
+
+      def initialize_state
+        @selected_project = '* ALL'
+        @selected_projects = ['* ALL']
+        @selected_tasks = []
+        @entries = []
+        @current_started_at = nil
+        @current_sheet = nil
+        @time_filter_from_at = nil
+        @time_filter_to_at = nil
+        @archive_mode = false
+        reset_archive_mode_caches!
+      end
+
+      def detect_current_sheet
+        running_sheet || latest_sheet
+      end
+
+      def running_sheet = newest_entry(entries.select(&:running?))&.sheet
+
+      def latest_sheet = newest_entry(entries)&.sheet
+
+      def newest_entry(collection)
+        collection.max_by { |entry| entry.start_time || EPOCH_TIME }
+      end
+
+      def latest_task_for_project(project)
+        return '' if project == '* ALL'
+
+        entry = newest_entry(entries.select { |item| item.project == project })
+        entry ? entry.task.to_s : ''
+      end
+
+      def normalize_text(value) = value.to_s
+    end
+  end
+end

data/app/view_models/main_view_model_archive_mode_helpers.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+module QTimetrap
+  module ViewModels
+    # Archive-mode specific filtering and projections for MainViewModel.
+    module MainViewModelArchiveModeHelpers
+      EMPTY_ARRAY = [].freeze
+
+      def project_names
+        ['* ALL', *ordered_project_names_for_mode]
+      end
+
+      def task_names_for_selected_project
+        return [] unless selected_projects == [selected_project]
+        return [] if selected_project == '* ALL'
+
+        task_names_for_project(selected_project)
+      end
+
+      def task_names_for_project(project)
+        normalized_project = normalize_text(project).strip
+        return [] if normalized_project.empty? || normalized_project == '* ALL'
+
+        ordered_task_names_by_project.fetch(normalized_project, EMPTY_ARRAY)
+      end
+
+      def archive_mode?
+        @archive_mode
+      end
+
+      def archive_mode=(enabled)
+        @archive_mode = [true, 1].include?(enabled)
+        reset_archive_mode_caches!
+        normalize_selected_projects!
+        normalize_selected_tasks!
+      end
+
+      def archive_entry(entry_id)
+        archived_entries_store.archive(entry_id)
+        reset_archive_mode_caches!
+      end
+
+      def unarchive_entry(entry_id)
+        archived_entries_store.unarchive(entry_id)
+        reset_archive_mode_caches!
+      end
+
+      private
+
+      def entries_for_mode
+        entries.select { |entry| archived_entries_store.archived?(entry.id) == archive_mode? }
+      end
+
+      def ordered_project_names_for_mode
+        @ordered_project_names_for_mode ||= ordered_project_names(entries_for_mode)
+      end
+
+      def ordered_task_names_by_project
+        @ordered_task_names_by_project ||= build_ordered_task_names_by_project
+      end
+
+      def ordered_project_names(collection)
+        collection
+          .group_by(&:project)
+          .sort_by { |project, project_entries| sort_key(project, project_entries) }
+          .map(&:first)
+      end
+
+      def ordered_task_names(collection)
+        collection
+          .group_by { |entry| entry.task.to_s }
+          .reject { |task, _| task.empty? }
+          .sort_by { |task, task_entries| sort_key(task, task_entries) }
+          .map(&:first)
+      end
+
+      def sort_key(name, grouped_entries)
+        newest_started_at = newest_entry(grouped_entries)&.start_time || EPOCH_TIME
+        [-newest_started_at.to_i, name]
+      end
+
+      def build_ordered_task_names_by_project
+        entries_for_mode
+          .group_by(&:project)
+          .transform_values { |project_entries| ordered_task_names(project_entries) }
+      end
+
+      def normalize_selected_projects!
+        available = project_names
+        normalized = Array(@selected_projects).map(&:to_s).reject(&:empty?).uniq & available
+        normalized = ['* ALL'] if normalized.empty? || normalized.include?('* ALL')
+        @selected_projects = normalized
+        @selected_project = normalized.include?(@selected_project) ? @selected_project : normalized.first
+      end
+
+      def reset_archive_mode_caches!
+        @ordered_project_names_for_mode = nil
+        @ordered_task_names_by_project = nil
+      end
+    end
+  end
+end

data/app/view_models/main_view_model_entry_note_helpers.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module QTimetrap
+  module ViewModels
+    # Entry note update behavior for MainViewModel.
+    module MainViewModelEntryNoteHelpers
+      def update_entry_note(entry_id, note)
+        normalized_id = entry_id.to_i
+        return if normalized_id.zero?
+
+        gateway.update_note(normalized_id, note.to_s)
+        @entries = entries.map { |entry| updated_entry_with_note(entry, normalized_id, note.to_s) }
+      end
+
+      private
+
+      def updated_entry_with_note(entry, entry_id, note)
+        return entry unless entry.id.to_i == entry_id
+
+        Models::TimeEntry.new(
+          id: entry.id,
+          note: note,
+          sheet: entry.sheet,
+          start_time: entry.start_time,
+          end_time: entry.end_time
+        )
+      end
+    end
+  end
+end

data/app/view_models/main_view_model_entry_task_helpers.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module QTimetrap
+  module ViewModels
+    # Entry task move behavior for MainViewModel.
+    module MainViewModelEntryTaskHelpers
+      def update_entry_task(entry_id, task_name)
+        normalized_id = entry_id.to_i
+        return if normalized_id.zero?
+
+        entry = find_entry_for_task_update(normalized_id)
+        normalized_task = normalize_target_task(task_name)
+        gateway.update_task(normalized_id, target_sheet_for_entry(entry, normalized_task))
+        self.current_task_input = normalized_task if entry.running?
+        refresh!
+      end
+
+      private
+
+      def find_entry_for_task_update(entry_id)
+        entry = entries.find { |item| item.id.to_i == entry_id }
+        raise ArgumentError, "Entry not found: #{entry_id}" unless entry
+
+        entry
+      end
+
+      def normalize_target_task(task_name)
+        value = normalize_text(task_name).strip
+        raise ArgumentError, 'Task is required' if value.empty?
+
+        value
+      end
+
+      def target_sheet_for_entry(entry, task_name)
+        "#{entry.project}|#{task_name}"
+      end
+    end
+  end
+end

data/app/view_models/main_view_model_entry_time_helpers.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module QTimetrap
+  module ViewModels
+    # Entry time update behavior for MainViewModel.
+    module MainViewModelEntryTimeHelpers
+      def update_entry_time(entry_id, start_text, end_text)
+        normalized_id = entry_id.to_i
+        return if normalized_id.zero?
+
+        entry = entries.find { |item| item.id.to_i == normalized_id }
+        raise ArgumentError, "Entry not found: #{normalized_id}" unless entry
+
+        start_time = parse_entry_clock_value(entry.start_time, start_text)
+        end_time = parse_entry_clock_value(entry.end_time || entry.start_time, end_text)
+
+        gateway.update_time(normalized_id, start_time: start_time, end_time: end_time)
+        refresh!
+      end
+
+      private
+
+      def parse_entry_clock_value(reference_time, value)
+        text = value.to_s.strip
+        return nil if text.empty? || text == 'running'
+
+        hour, min = parse_clock_components(text, value)
+
+        base = reference_time || Time.now
+        Time.new(base.year, base.month, base.day, hour, min, 0, base.utc_offset)
+      end
+
+      def parse_clock_components(text, original_value)
+        match = text.match(/\A(\d{1,2}):(\d{2})\z/)
+        raise ArgumentError, "Invalid time value: #{original_value}" unless match
+
+        hour = match[1].to_i
+        min = match[2].to_i
+        raise ArgumentError, "Invalid time value: #{original_value}" if hour > 23 || min > 59
+
+        [hour, min]
+      end
+    end
+  end
+end

data/app/view_models/main_view_model_sheet_helpers.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module QTimetrap
+  module ViewModels
+    # Current sheet/project/task presentation and composition helpers.
+    module MainViewModelSheetHelpers
+      def current_sheet_label(*)
+        current_project_name
+      end
+
+      def current_sheet_input
+        current_task_input
+      end
+
+      def current_project_name
+        @current_project_name || project_from_sheet.to_s
+      end
+
+      def current_task_input
+        @current_task_input || task_from_sheet.to_s
+      end
+
+      def current_task_input=(task_name)
+        @current_task_input = normalize_text(task_name).strip
+      end
+
+      def current_project_name=(project_name)
+        @current_project_name = normalize_text(project_name).strip
+      end
+
+      def sheet_for_task_input(task_input)
+        project = current_project_name
+        project = selected_project if project.to_s.empty? && selected_project != '* ALL'
+        project = normalize_text(project).strip
+        task = normalize_text(task_input).strip
+        raise ArgumentError, 'Project is required' if project.empty? || project == '* ALL'
+        raise ArgumentError, 'Task is required' if task.empty?
+
+        "#{project}|#{task}"
+      end
+
+      private
+
+      def project_from_sheet
+        split_current_sheet&.first
+      end
+
+      def task_from_sheet
+        split_current_sheet&.last.to_s
+      end
+
+      def split_current_sheet
+        raw = current_sheet.to_s.strip
+        return nil if raw.empty?
+
+        if raw.include?('|')
+          project, task = raw.split('|', 2).map(&:strip)
+          return [project, task]
+        end
+
+        [raw, '']
+      end
+
+      def seed_current_fields_from_sheet!
+        @current_project_name = project_from_sheet.to_s if @current_project_name.nil?
+        @current_task_input = task_from_sheet.to_s if @current_task_input.nil?
+      end
+
+      def apply_selected_project_to_current_field!
+        @current_project_name = selected_project == '* ALL' ? project_from_sheet.to_s : selected_project.to_s
+      end
+    end
+  end
+end

data/app/view_models/main_view_model_task_filter_helpers.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module QTimetrap
+  module ViewModels
+    # Task filter behavior for MainViewModel.
+    module MainViewModelTaskFilterHelpers
+      def select_tasks(tasks)
+        normalized = Array(tasks).map(&:to_s).reject(&:empty?).uniq
+        @selected_tasks = task_filter_disabled? ? [] : (normalized & task_names_for_selected_project)
+      end
+
+      def filtered_entries
+        scoped = entries_for_selected_project
+        scoped = apply_selected_tasks_filter(scoped)
+        apply_time_range_filter(scoped)
+      end
+
+      private
+
+      def entries_for_selected_project
+        return entries_for_mode if selected_projects == ['* ALL']
+
+        entries_for_mode.select { |entry| selected_projects.include?(entry.project) }
+      end
+
+      def apply_selected_tasks_filter(scoped)
+        return scoped if selected_tasks.empty?
+
+        scoped.select { |entry| selected_tasks.include?(entry.task.to_s) }
+      end
+
+      def apply_time_range_filter(scoped)
+        return scoped if @time_filter_from_at.nil? && @time_filter_to_at.nil?
+
+        scoped.select { |entry| entry_in_selected_time_range?(entry) }
+      end
+
+      def entry_in_selected_time_range?(entry)
+        start_at = entry.start_time
+        return false unless start_at
+        return false if @time_filter_from_at && start_at < @time_filter_from_at
+        return false if @time_filter_to_at && start_at > @time_filter_to_at
+
+        true
+      end
+
+      def normalize_selected_tasks!
+        return @selected_tasks = [] if task_filter_disabled?
+
+        @selected_tasks &= task_names_for_selected_project
+      end
+
+      def task_filter_disabled?
+        selected_projects != [selected_project] || selected_project == '* ALL'
+      end
+    end
+  end
+end

data/app/view_models/main_view_model_time_range_filter_helpers.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module QTimetrap
+  module ViewModels
+    # Date-time range filter behavior for MainViewModel.
+    module MainViewModelTimeRangeFilterHelpers
+      def update_time_range_filter(from_at:, to_at:)
+        validate_time_range!(from_at, to_at)
+        @time_filter_from_at = from_at
+        @time_filter_to_at = to_at
+      end
+
+      private
+
+      def validate_time_range!(from_at, to_at)
+        return unless from_at && to_at
+        return unless from_at > to_at
+
+        raise ArgumentError, 'Date-time filter FROM must be less than or equal to TO'
+      end
+    end
+  end
+end