qtimetrap 0.1.1 → 0.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1c354f5a65349384bd932fceb8f62cb7b43927c789b67bcd57a5c064baf6754f
-  data.tar.gz: a0b067c516cfc16874afcd1f98088e8e8dbf023c079bc26cdb390c2e6e0c6b58
+  metadata.gz: '018f44eb75f1594bcb9a78ac9f9cf8663901e2c3bf34d76f324f6e5a955da4d1'
+  data.tar.gz: b0c0f032ae783bb94d12061186c8430596ae7c5dbcef6497337113517bebc6b5
 SHA512:
-  metadata.gz: b8a21804d830a6b48bedd2bcd3bf53b7ddc00db6d9b38174a3c6ff0a7fc63dc7b41e61ba2ac301a4aeef5c9b9d432c096bd1c1bce614ada07fb7c50a19e4d840
-  data.tar.gz: ba9ba9ff36f90346913699562b13c0842281e5c27bab6e22f5e326638b9c49bfceca7f51039345d84a994831065c1a73bfe8891ebed147ddfea2abb0a534a11d
+  metadata.gz: 10055a894a818debb7f33541ca4146fe65eb46e0bb364f10d0d7d0cc8bee9d3ee0421658fd9848d186a264d4fa2bd9c1830c166c5e11cdf990ed39bdc5cb4bf7
+  data.tar.gz: c1b33688d08191603e914254c48a1405393dc21482041e8a9f7a5587dd104a012bd8e0ff3b0c5093be0a2743e0a2dd8982e9c0f32570fb599806ad454ee45e20

data/CHANGELOG.md

@@ -0,0 +1,48 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+## [0.1.3] - 2026-11-10
+
+### Performance
+- Cache archived-entry IDs during refresh.
+- Render the entry list incrementally and filter existing widgets instead of rebuilding the tree.
+- Create task editors only when activated to reduce initial widget construction.
+- Add a startup and interaction profiling script.
+
+## [0.1.2] - 2026-03-17
+
+### Added
+- Editable task reassignment for individual entries.
+- Archive mode with archive/restore flow for entry rows.
+- Multi-select project filtering in the sidebar with recent-activity ordering for projects and tasks.
+- Date/time range filtering for rendered entry nodes.
+- Custom RuboCop enforcement for Ruby-style Qt setter usage in `app/**`.
+
+### Changed
+- Switched project license to BSD-2-Clause.
+- Moved specs under `spec/qtimetrap/**` and removed the RuboCop todo file.
+- Improved README, packaging metadata, and release preparation.
+- Tracker inputs now take focus on direct click when editing is allowed.
+
+### Fixed
+- Preserved running tracker inputs when selecting sidebar tasks.
+- Closed inline editors on outside click without relying on application-level hit-testing workarounds.
+- Restored entry task editor styling and display-field behavior.
+- Reduced UI regressions around inline task editing, scrolling, and blur handling.
+
+## [0.1.1] - 2026-03-14
+
+### Added
+- Fedora/COPR packaging, desktop entry installation, and application icons.
+- Sidebar task filtering, multi-project filtering, and archive support groundwork.
+- Editable note and time updates for entry leaves.
+
+### Changed
+- Updated runtime dependency to newer `qt` releases in the 0.1 series.
+
+## [0.1.0] - 2026-03-05
+
+### Added
+- Initial release of QTimetrap as a Ruby gem with a Qt desktop UI.
+- MVVM application structure with Zeitwerk autoloading, themed QSS styling, and Timetrap integration.

data/README.md

@@ -19,7 +19,7 @@ QTimetrap follows an MVVM-style architecture with `Zeitwerk` autoloading and a R
 ## Requirements
 
 - Ruby `>= 3.2`
-- Qt bridge gem: `qt >= 0.1.4`
+- Qt bridge gem: `qt >= 0.1.7`
 - `timetrap` CLI available as `t` (or configured via env)
 
 ## Install
@@ -38,9 +38,8 @@ Install required system libraries first:
 ### Fedora COPR
 
 ```bash
-sudo dnf copr enable cyjimmy264/ruby-qt
-sudo dnf copr enable cyjimmy264/ruby-qtimetrap
-sudo dnf install ruby-qt ruby-qtimetrap
+sudo dnf copr enable cyjimmy264/ruby-qt-stack
+sudo dnf install ruby-qtimetrap
 gem install timetrap
 qtimetrap
 ```

data/app/components/entries/branch_hierarchy_helpers.rb

@@ -8,10 +8,10 @@ module QTimetrap
 
       def build_children_container(parent_widget)
         container = QWidget.new(parent_widget)
-        container.set_object_name('entry_node_children')
+        container.object_name = 'entry_node_children'
         layout = QVBoxLayout.new(container)
         layout.set_contents_margins(0, 0, 0, 0)
-        layout.set_spacing(2)
+        layout.spacing = 2
         [container, layout]
       end
 
@@ -32,9 +32,9 @@ module QTimetrap
         binding = branch_bindings[node_id]
         return unless binding
 
-        binding.fetch(:children_container).set_visible(visible)
+        binding.fetch(:children_container).visible = visible
         text = branch_button_text(binding.fetch(:level), binding.fetch(:label), visible)
-        binding.fetch(:button).set_text(text)
+        binding.fetch(:button).text = text
       end
     end
   end

data/app/components/entries/entry_row_render_helpers.rb

@@ -0,0 +1,196 @@
+# frozen_string_literal: true
+
+module QTimetrap
+  module Entries
+    # Builds editable entry rows in small GUI-thread steps.
+    module EntryRowRenderHelpers
+      private
+
+      def start_entry_row_render(node, level, layout:, parent_widget:)
+        row = build_entry_row(parent_widget)
+        apply_entry_widget_styles(row, ListComponent::ENTRY_ROW_STYLE_IDS)
+        row_layout = build_entry_row_layout(row)
+        layout.add_widget(row)
+        entry_rows << row
+        entry_id = node.fetch(:entry_id, node.fetch(:id))
+        entry_rows_by_id[entry_id] = row
+        project_branch_id = container_branch_ids[parent_widget.handle.address]
+        entry_row_parent_branches[entry_id] = project_branch_id
+        project_branch_entry_ids[project_branch_id] << entry_id if project_branch_id
+        row_visible = visible_entry_ids.nil? || visible_entry_ids.key?(entry_id)
+        row_filter_state[entry_id] = row_visible
+        row.visible = row_visible
+
+        context = {
+          node: node,
+          level: level,
+          row: row,
+          row_layout: row_layout,
+          parent_layout: layout,
+          parent_widget: parent_widget
+        }
+        enqueue_entry_row_stage(context, :time_group)
+      end
+
+      def enqueue_entry_row_stage(context, stage, index = nil)
+        render_queue << [:entry_stage, stage, context, index]
+      end
+
+      def process_entry_row_stage(context, stage, index)
+        case stage
+        when :time_group then create_entry_time_group(context)
+        when :start_time then create_entry_start_time(context)
+        when :time_separator then create_entry_time_separator(context)
+        when :end_time then create_entry_end_time(context)
+        when :bind_start_time then bind_entry_start_time(context)
+        when :bind_end_time then bind_entry_end_time(context)
+        when :prefix then create_entry_prefix(context)
+        when :task_container then create_task_container(context)
+        when :task_display then create_task_display(context)
+        when :note_input then create_entry_note(context)
+        when :note_bind_mouse then bind_entry_note_mouse(context)
+        when :note_bind_key then bind_entry_note_key(context)
+        when :note_bind_return then bind_entry_note_return(context)
+        when :note_bind_focus then bind_entry_note_focus(context)
+        when :archive_button then create_entry_archive_button(context)
+        when :finish then finish_entry_row(context)
+        end
+      end
+
+      def create_entry_time_group(context)
+        group = QWidget.new(context.fetch(:row))
+        group.object_name = 'entry_node_entry_time_group'
+        layout = QHBoxLayout.new(group)
+        layout.set_contents_margins(0, 0, 0, 0)
+        layout.spacing = 4
+        context[:time_group] = group
+        context[:time_layout] = layout
+        context.fetch(:row_layout).add_widget(group)
+        enqueue_entry_row_stage(context, :start_time)
+      end
+
+      def create_entry_start_time(context)
+        node = context.fetch(:node)
+        input = build_entry_time_input(
+          context.fetch(:row),
+          object_name: 'entry_node_entry_start',
+          value: node.fetch(:start_label, '--:--'),
+          placeholder: '--:--'
+        )
+        context[:start_input] = input
+        context.fetch(:time_layout).add_widget(input)
+        enqueue_entry_row_stage(context, :time_separator)
+      end
+
+      def create_entry_time_separator(context)
+        separator = build_entry_time_separator(context.fetch(:time_group))
+        context[:time_layout].add_widget(separator)
+        enqueue_entry_row_stage(context, :end_time)
+      end
+
+      def create_entry_end_time(context)
+        node = context.fetch(:node)
+        input = build_entry_time_input(
+          context.fetch(:row),
+          object_name: 'entry_node_entry_end',
+          value: node.fetch(:end_label, 'running'),
+          placeholder: 'running'
+        )
+        context[:end_input] = input
+        context.fetch(:time_layout).add_widget(input)
+        enqueue_entry_row_stage(context, :bind_start_time)
+      end
+
+      def bind_entry_start_time(context)
+        bind_single_time_input(
+          context.fetch(:start_input),
+          resolve_entry_id(context.fetch(:node)),
+          context.fetch(:start_input),
+          context.fetch(:end_input)
+        )
+        enqueue_entry_row_stage(context, :bind_end_time)
+      end
+
+      def bind_entry_end_time(context)
+        bind_single_time_input(
+          context.fetch(:end_input),
+          resolve_entry_id(context.fetch(:node)),
+          context.fetch(:start_input),
+          context.fetch(:end_input)
+        )
+        enqueue_entry_row_stage(context, :prefix)
+      end
+
+      def create_entry_prefix(context)
+        label = build_entry_prefix_label(context.fetch(:row), context.fetch(:node), context.fetch(:level))
+        context.fetch(:row_layout).add_widget(label)
+        enqueue_entry_row_stage(context, :task_container)
+      end
+
+      def create_task_container(context)
+        container = QWidget.new(context.fetch(:row))
+        container.object_name = 'entry_node_entry_task_container'
+        build_entry_task_layout(container)
+        context[:task_container] = container
+        context.fetch(:row_layout).add_widget(container)
+        enqueue_entry_row_stage(context, :task_display)
+      end
+
+      def create_task_display(context)
+        node = context.fetch(:node)
+        task_name = node.fetch(:task_name, '').to_s
+        display = build_entry_task_display(context.fetch(:task_container), task_name)
+        context[:task_name] = task_name
+        context[:task_display] = display
+        task_container = context.fetch(:task_container)
+        register_task_widgets(task_container, display, nil, nil)
+        register_task_editor_config(task_container, node: context.fetch(:node), task_name: task_name)
+        display.on(:mouse_button_press) { |_| activate_entry_task_input(task_container) }
+        enqueue_entry_row_stage(context, :note_input)
+      end
+
+      def create_entry_note(context)
+        input = build_entry_note_input_widget(context.fetch(:row), context.fetch(:node))
+        context[:note_input] = input
+        context.fetch(:row_layout).add_widget(input)
+        enqueue_entry_row_stage(context, :note_bind_mouse)
+      end
+
+      def bind_entry_note_mouse(context)
+        input = context.fetch(:note_input)
+        input.on(:mouse_button_press) { |_| activate_entry_note_input(input) }
+        enqueue_entry_row_stage(context, :note_bind_key)
+      end
+
+      def bind_entry_note_key(context)
+        input = context.fetch(:note_input)
+        entry_id = resolve_entry_id(context.fetch(:node))
+        input.on(:key_press) { |event| handle_entry_note_key_press(input, entry_id, event) }
+        enqueue_entry_row_stage(context, :note_bind_return)
+      end
+
+      def bind_entry_note_return(context)
+        input = context.fetch(:note_input)
+        entry_id = resolve_entry_id(context.fetch(:node))
+        input.connect('returnPressed') { |_| handle_entry_note_commit(input, entry_id) }
+        enqueue_entry_row_stage(context, :note_bind_focus)
+      end
+
+      def bind_entry_note_focus(context)
+        context.fetch(:note_input).on(:focus_out) { |_| handle_entry_note_focus_out(context.fetch(:note_input)) }
+        enqueue_entry_row_stage(context, :archive_button)
+      end
+
+      def create_entry_archive_button(context)
+        button = build_entry_archive_button(context.fetch(:row), context.fetch(:node))
+        context.fetch(:row_layout).add_widget(button)
+        enqueue_entry_row_stage(context, :finish)
+      end
+
+      def finish_entry_row(context)
+        context.fetch(:row_layout).set_stretch(2, 1)
+        context.fetch(:row_layout).set_stretch(3, 2)
+      end
+    end
+  end
+end

data/app/components/entries/leaf_archive_helpers.rb

@@ -8,12 +8,12 @@ module QTimetrap
 
       def build_entry_archive_button(row, node)
         QPushButton.new(row).tap do |button|
-          button.set_object_name('entry_node_entry_archive')
-          button.set_text('🗃')
-          button.set_tool_tip('Toggle archive state')
-          button.set_focus_policy(Qt::NoFocus)
-          button.set_fixed_width(28)
-          button.set_fixed_height(24)
+          button.object_name = 'entry_node_entry_archive'
+          button.text = '🗃'
+          button.tool_tip = 'Toggle archive state'
+          button.focus_policy = Qt::NoFocus
+          button.fixed_width = 28
+          button.fixed_height = 24
           entry_id = resolve_entry_id(node)
           button.connect('clicked') { |_| on_entry_archive&.call(entry_id) }
         end

data/app/components/entries/leaf_note_helpers.rb

@@ -8,6 +8,7 @@ module QTimetrap
 
       def render_entry_leaf_node(node, level, layout:, parent_widget:)
         row = build_entry_row(parent_widget)
+        apply_entry_widget_styles(row, ListComponent::ENTRY_ROW_STYLE_IDS)
         row_layout = build_entry_row_layout(row)
         start_input, end_input = add_entry_time_widgets(row_layout, row, node)
         add_entry_row_widgets(row_layout, row, node, level)
@@ -31,33 +32,38 @@ module QTimetrap
 
       def build_entry_row(parent_widget)
         QWidget.new(parent_widget).tap do |row|
-          row.set_object_name('entry_node_entry_row')
-          row.set_fixed_width(branch_button_width)
-          row.set_fixed_height(32)
+          row.object_name = 'entry_node_entry_row'
+          row.fixed_width = branch_button_width
+          row.fixed_height = 32
         end
       end
 
       def build_entry_row_layout(row)
         QHBoxLayout.new(row).tap do |layout|
           layout.set_contents_margins(8, 0, 8, 0)
-          layout.set_spacing(6)
+          layout.spacing = 6
         end
       end
 
       def build_entry_prefix_label(row, node, level)
         QLabel.new(row).tap do |prefix_label|
-          prefix_label.set_object_name('entry_node_entry_prefix')
-          prefix_label.set_text("#{indent(level)}#{node.fetch(:prefix, node.fetch(:label))}")
+          prefix_label.object_name = 'entry_node_entry_prefix'
+          prefix_label.text = "#{indent(level)}#{node.fetch(:prefix, node.fetch(:label))}"
         end
       end
 
       def build_entry_note_input(row, node)
+        build_entry_note_input_widget(row, node).tap do |note_input|
+          bind_entry_note_input_events(note_input, resolve_entry_id(node))
+        end
+      end
+
+      def build_entry_note_input_widget(row, node)
         QLineEdit.new(row).tap do |note_input|
-          note_input.set_object_name('entry_node_entry_note')
+          note_input.object_name = 'entry_node_entry_note'
           note_input.text = node.fetch(:note, '')
-          note_input.set_placeholder_text('(no note)')
-          note_input.set_read_only(true)
-          bind_entry_note_input_events(note_input, resolve_entry_id(node))
+          note_input.placeholder_text = '(no note)'
+          note_input.read_only = true
         end
       end
 
@@ -83,12 +89,12 @@ module QTimetrap
       end
 
       def activate_entry_note_input(note_input)
-        note_input.set_read_only(false)
+        note_input.read_only = false
         note_input.set_focus
       end
 
       def deactivate_entry_note_input(note_input)
-        note_input.set_read_only(true)
+        note_input.read_only = true
         note_input.clear_focus
       end
 

data/app/components/entries/leaf_task_display_helpers.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module QTimetrap
+  module Entries
+    # Display-field helpers for entry task controls.
+    module LeafTaskDisplayHelpers
+      private
+
+      def sync_task_display_field(task_input, task_name)
+        task_input.text = task_name
+        task_input.tool_tip = task_name
+      end
+    end
+  end
+end

data/app/components/entries/leaf_task_editor_state_helpers.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module QTimetrap
+  module Entries
+    # State transitions for entry task display/editor widgets.
+    module LeafTaskEditorStateHelpers
+      private
+
+      def activate_entry_task_input(task_container)
+        close_previous_task_editor(task_container)
+        editor, editor_input = ensure_entry_task_editor(task_container)
+        show_entry_task_editor(task_container)
+        self.active_task_container = task_container
+        editor_input.read_only = false
+        editor.set_focus
+        editor_input.set_focus
+        editor.show_popup
+      end
+
+      def deactivate_entry_task_input(task_container)
+        editor = entry_task_editor(task_container)
+        editor_input = entry_task_editor_line_edit(editor)
+        editor_input.read_only = true
+        editor.hide_popup
+        editor.clear_focus
+        show_entry_task_display(task_container)
+      end
+
+      def handle_entry_task_focus_out(task_container)
+        return unless task_container
+
+        reset_entry_task_editor(task_container)
+        deactivate_entry_task_input(task_container)
+        return unless active_task_container
+        return unless task_container_matches?(active_task_container, task_container)
+
+        self.active_task_container = nil
+      end
+
+      def close_previous_task_editor(task_container)
+        return unless active_task_container
+        return if task_container_matches?(active_task_container, task_container)
+
+        handle_entry_task_focus_out(active_task_container)
+      end
+
+      def reset_entry_task_editor(task_container)
+        entry_task_editor(task_container).current_text = entry_task_display_input(task_container).text.to_s
+      end
+
+      def show_entry_task_editor(task_container)
+        entry_task_display_input(task_container).hide
+        entry_task_editor(task_container).show
+      end
+
+      def show_entry_task_display(task_container)
+        entry_task_editor(task_container).hide
+        entry_task_display_input(task_container).show
+      end
+
+      def sync_entry_task_display(task_container, task_name)
+        sync_task_display_field(entry_task_display_input(task_container), task_name)
+        entry_task_editor(task_container).current_text = task_name
+        entry_task_editor(task_container).tool_tip = task_name
+      end
+    end
+  end
+end