qtimetrap 0.1.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 1c354f5a65349384bd932fceb8f62cb7b43927c789b67bcd57a5c064baf6754f
+  data.tar.gz: a0b067c516cfc16874afcd1f98088e8e8dbf023c079bc26cdb390c2e6e0c6b58
+SHA512:
+  metadata.gz: b8a21804d830a6b48bedd2bcd3bf53b7ddc00db6d9b38174a3c6ff0a7fc63dc7b41e61ba2ac301a4aeef5c9b9d432c096bd1c1bce614ada07fb7c50a19e4d840
+  data.tar.gz: ba9ba9ff36f90346913699562b13c0842281e5c27bab6e22f5e326638b9c49bfceca7f51039345d84a994831065c1a73bfe8891ebed147ddfea2abb0a534a11d

data/LICENSE

@@ -0,0 +1,25 @@
+BSD 2-Clause License
+
+Copyright (c) 2026, Maksim Veynberg
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

data/README.md

@@ -0,0 +1,92 @@
+# QTimetrap
+
+Desktop UI for [Timetrap](https://github.com/samg/timetrap), built with Ruby + Qt.
+
+QTimetrap follows an MVVM-style architecture with `Zeitwerk` autoloading and a Rails-like project structure.
+
+![QTimetrap screenshot](docs/screenshots/main.png)
+
+## Features
+
+- Expandable entries tree: `week -> day -> project/task -> time entry`.
+- Start/stop tracking from UI (single button based on running state).
+- Edit entry `note`, `start`, and `end` directly in the list.
+- Project/task sidebar with multi-select task filtering.
+- Date-time interval filtering (`FROM`/`TO`) with live apply.
+- Archive mode (soft-hide entries via local archive store, no destructive Timetrap delete).
+- Theme switch (`light`/`dark`) with persistent selection.
+
+## Requirements
+
+- Ruby `>= 3.2`
+- Qt bridge gem: `qt >= 0.1.4`
+- `timetrap` CLI available as `t` (or configured via env)
+
+## Install
+
+### RubyGems
+
+```bash
+gem install qtimetrap timetrap
+qtimetrap
+```
+
+Note: `qtimetrap` depends on the `qt` gem with native extensions.  
+Install required system libraries first:
+<https://github.com/CyJimmy264/qt?tab=readme-ov-file#system-requirements>.
+
+### Fedora COPR
+
+```bash
+sudo dnf copr enable cyjimmy264/ruby-qt
+sudo dnf copr enable cyjimmy264/ruby-qtimetrap
+sudo dnf install ruby-qt ruby-qtimetrap
+gem install timetrap
+qtimetrap
+```
+
+## Run
+
+```bash
+bundle install
+bundle exec bin/qtimetrap
+```
+
+If `qt` is already installed in your current `rbenv` shell, you can also run:
+
+```bash
+bin/qtimetrap
+```
+
+## Configuration
+
+- `QTIMETRAP_ENV`: app environment (`development` by default)
+- `TIMETRAP_BIN`: timetrap CLI command (`t` by default)
+- `QTIMETRAP_THEME`: initial theme (`light` by default)
+- `QTIMETRAP_RELOAD=1`: enable Zeitwerk reloading in development
+
+Persisted settings:
+
+- Theme: `~/.config/qtimetrap/config.yml`
+- Archived entry ids: `~/.local/share/qtimetrap/archived_entries.yml`
+
+(`$XDG_CONFIG_HOME` / `$XDG_DATA_HOME` are respected.)
+
+## Development
+
+```bash
+rspec
+gem build qtimetrap.gemspec
+```
+
+Main directories:
+
+- `app/models`, `app/services`, `app/view_models`
+- `app/views`, `app/components`
+- `app/styles/themes/{light,dark}/*.qss`
+- `config/`, `lib/`, `spec/`
+
+## Packaging
+
+- Fedora/COPR assets: `packaging/rpm`
+- Debian/Launchpad assets: `packaging/deb`

data/Rakefile

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+require 'bundler/gem_tasks'
+require 'fileutils'
+
+# Installs QTimetrap desktop entry and icon theme assets under ~/.local/share.
+module DesktopInstall
+  module_function
+
+  def root
+    File.expand_path(__dir__)
+  end
+
+  def home
+    Dir.home
+  end
+
+  def applications_dir
+    File.join(home, '.local', 'share', 'applications')
+  end
+
+  def icons_root
+    File.join(home, '.local', 'share', 'icons', 'hicolor')
+  end
+
+  def desktop_file
+    File.join(applications_dir, 'qtimetrap.desktop')
+  end
+
+  def icon_svg_src
+    File.join(root, 'app', 'assets', 'icons', 'qtimetrap-icon.svg')
+  end
+
+  def icon_png_sizes
+    {
+      '128x128' => File.join(root, 'app', 'assets', 'icons', 'qtimetrap-icon-128.png'),
+      '256x256' => File.join(root, 'app', 'assets', 'icons', 'qtimetrap-icon-256.png'),
+      '512x512' => File.join(root, 'app', 'assets', 'icons', 'qtimetrap-icon-512.png')
+    }
+  end
+
+  def exec_path
+    rbenv_shim = File.join(home, '.rbenv', 'shims', 'qtimetrap')
+    ENV.fetch('QTIMETRAP_DESKTOP_EXEC', File.executable?(rbenv_shim) ? rbenv_shim : 'qtimetrap')
+  end
+
+  def install!
+    FileUtils.mkdir_p(applications_dir)
+    install_icons!
+    File.write(desktop_file, desktop_entry)
+    validate_desktop_file!
+    refresh_icon_cache!
+    puts "Installed desktop entry: #{desktop_file}"
+  end
+
+  def install_icons!
+    FileUtils.mkdir_p(File.join(icons_root, 'scalable', 'apps'))
+    FileUtils.cp(icon_svg_src, File.join(icons_root, 'scalable', 'apps', 'qtimetrap.svg'))
+    icon_png_sizes.each do |size, src|
+      next unless File.file?(src)
+
+      target_dir = File.join(icons_root, size, 'apps')
+      FileUtils.mkdir_p(target_dir)
+      FileUtils.cp(src, File.join(target_dir, 'qtimetrap.png'))
+    end
+  end
+
+  def desktop_entry
+    <<~DESKTOP
+      [Desktop Entry]
+      Type=Application
+      Version=1.0
+      Name=QTimetrap
+      Comment=Desktop Timetrap UI on Qt
+      Exec=#{exec_path}
+      Icon=qtimetrap
+      Terminal=false
+      Categories=Office;
+      StartupNotify=true
+      StartupWMClass=qtimetrap
+      X-KDE-StartupNotify=true
+    DESKTOP
+  end
+
+  def validate_desktop_file!
+    return unless system('sh', '-lc', 'command -v desktop-file-validate >/dev/null 2>&1')
+    return if system('desktop-file-validate', desktop_file)
+
+    abort("desktop-file-validate failed for #{desktop_file}")
+  end
+
+  def refresh_icon_cache!
+    return unless system('sh', '-lc', 'command -v gtk-update-icon-cache >/dev/null 2>&1')
+    return unless File.file?(File.join(icons_root, 'index.theme'))
+
+    system('gtk-update-icon-cache', '-q', '-t', icons_root)
+  end
+end
+
+namespace :desktop do
+  desc 'Install QTimetrap desktop entry into ~/.local/share/applications'
+  task :install do
+    DesktopInstall.install!
+  end
+end

data/app/assets/icons/qtimetrap-icon.svg

@@ -0,0 +1,123 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<svg
+   width="512"
+   height="512"
+   viewBox="0 0 512 512"
+   fill="none"
+   version="1.1"
+   id="svg8"
+   sodipodi:docname="qtimetrap-icon.svg"
+   inkscape:version="1.4.3 (0d15f75042, 2025-12-25)"
+   xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
+   xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
+   xmlns="http://www.w3.org/2000/svg"
+   xmlns:svg="http://www.w3.org/2000/svg">
+  <sodipodi:namedview
+     id="namedview8"
+     pagecolor="#ffffff"
+     bordercolor="#000000"
+     borderopacity="0.25"
+     inkscape:showpageshadow="2"
+     inkscape:pageopacity="0.0"
+     inkscape:pagecheckerboard="0"
+     inkscape:deskcolor="#d1d1d1"
+     inkscape:zoom="0.21728516"
+     inkscape:cx="-775.47865"
+     inkscape:cy="1320.8449"
+     inkscape:window-width="1920"
+     inkscape:window-height="1136"
+     inkscape:window-x="0"
+     inkscape:window-y="0"
+     inkscape:window-maximized="1"
+     inkscape:current-layer="svg8" />
+  <defs
+     id="defs4">
+    <linearGradient
+       id="bg"
+       x1="64"
+       y1="48"
+       x2="448"
+       y2="464"
+       gradientUnits="userSpaceOnUse">
+      <stop
+         stop-color="#0EA5E9"
+         id="stop1" />
+      <stop
+         offset="1"
+         stop-color="#2563EB"
+         id="stop2" />
+    </linearGradient>
+    <linearGradient
+       id="ring"
+       x1="132"
+       y1="118"
+       x2="386"
+       y2="394"
+       gradientUnits="userSpaceOnUse">
+      <stop
+         stop-color="#E0F2FE"
+         id="stop3" />
+      <stop
+         offset="1"
+         stop-color="#BAE6FD"
+         id="stop4" />
+    </linearGradient>
+  </defs>
+  <rect
+     x="40"
+     y="40"
+     width="432"
+     height="432"
+     rx="108"
+     fill="url(#bg)"
+     id="rect4" />
+  <!-- Q ring -->
+  <circle
+     cx="252"
+     cy="248"
+     r="128"
+     stroke="url(#ring)"
+     stroke-width="36"
+     id="circle4" />
+  <!-- Q tail -->
+  <path
+     d="m 333.45169,346.65618 60,58"
+     stroke="#e0f2fe"
+     stroke-width="34"
+     stroke-linecap="round"
+     id="path4" />
+  <!-- clock hands -->
+  <path
+     d="m 256.08439,253.93795 59.98108,-59.12082"
+     stroke="#e0f2fe"
+     stroke-width="22"
+     stroke-linecap="round"
+     id="path5" />
+  <path
+     d="m 245.67191,250.30113 -47,-30"
+     stroke="#e0f2fe"
+     stroke-width="22"
+     stroke-linecap="round"
+     id="path6" />
+  <circle
+     cx="253.72585"
+     cy="252.60225"
+     r="14"
+     fill="#e0f2fe"
+     id="circle6" />
+  <!-- extra-thick check with dark-green outline -->
+  <path
+     d="m 53.12809,385.47416 74,68 106,-114"
+     stroke="#14532d"
+     stroke-width="88"
+     stroke-linecap="round"
+     stroke-linejoin="round"
+     id="path7" />
+  <path
+     d="m 53.12809,385.47416 74,68 106,-114"
+     stroke="#22c55e"
+     stroke-width="60"
+     stroke-linecap="round"
+     stroke-linejoin="round"
+     id="path8" />
+</svg>

data/app/components/entries/branch_hierarchy_helpers.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module QTimetrap
+  module Entries
+    # Hierarchical branch container/show-hide helpers for entries tree UI.
+    module BranchHierarchyHelpers
+      private
+
+      def build_children_container(parent_widget)
+        container = QWidget.new(parent_widget)
+        container.set_object_name('entry_node_children')
+        layout = QVBoxLayout.new(container)
+        layout.set_contents_margins(0, 0, 0, 0)
+        layout.set_spacing(2)
+        [container, layout]
+      end
+
+      def register_branch_binding(node_id:, button:, children_container:, label:, level:)
+        branch_bindings[node_id] = {
+          button: button,
+          children_container: children_container,
+          label: label,
+          level: level
+        }
+      end
+
+      def apply_all_branch_states
+        branch_bindings.each_key { |node_id| apply_branch_state(node_id, expanded.fetch(node_id, true)) }
+      end
+
+      def apply_branch_state(node_id, visible)
+        binding = branch_bindings[node_id]
+        return unless binding
+
+        binding.fetch(:children_container).set_visible(visible)
+        text = branch_button_text(binding.fetch(:level), binding.fetch(:label), visible)
+        binding.fetch(:button).set_text(text)
+      end
+    end
+  end
+end

data/app/components/entries/leaf_archive_helpers.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module QTimetrap
+  module Entries
+    # Entry-leaf helpers for archive action button.
+    module LeafArchiveHelpers
+      private
+
+      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)
+          entry_id = resolve_entry_id(node)
+          button.connect('clicked') { |_| on_entry_archive&.call(entry_id) }
+        end
+      end
+    end
+  end
+end

data/app/components/entries/leaf_note_helpers.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+module QTimetrap
+  module Entries
+    # Entry-leaf row builders for editable note nodes.
+    module LeafNoteHelpers
+      private
+
+      def render_entry_leaf_node(node, level, layout:, parent_widget:)
+        row = build_entry_row(parent_widget)
+        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)
+        bind_entry_time_input_events(start_input, end_input, resolve_entry_id(node))
+        apply_entry_row_stretch(row_layout)
+        entry_rows << row
+        layout.add_widget(row)
+      end
+
+      def add_entry_row_widgets(row_layout, row, node, level)
+        row_layout.add_widget(build_entry_prefix_label(row, node, level))
+        row_layout.add_widget(build_entry_task_input(row, node))
+        row_layout.add_widget(build_entry_note_input(row, node))
+        row_layout.add_widget(build_entry_archive_button(row, node))
+      end
+
+      def apply_entry_row_stretch(row_layout)
+        row_layout.set_stretch(2, 1)
+        row_layout.set_stretch(3, 2)
+      end
+
+      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)
+        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)
+        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))}")
+        end
+      end
+
+      def build_entry_note_input(row, node)
+        QLineEdit.new(row).tap do |note_input|
+          note_input.set_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))
+        end
+      end
+
+      def bind_entry_note_input_events(note_input, entry_id)
+        note_input.on(:mouse_button_press) { |_| activate_entry_note_input(note_input) }
+        note_input.on(:key_press) { |event| handle_entry_note_key_press(note_input, entry_id, event) }
+        note_input.connect('returnPressed') { |_| handle_entry_note_commit(note_input, entry_id) }
+        note_input.on(:focus_out) { |_| handle_entry_note_focus_out(note_input) }
+      end
+
+      def resolve_entry_id(node)
+        node.fetch(:entry_id, node.fetch(:id).to_s.sub('entry:', ''))
+      end
+
+      def handle_entry_note_commit(note_input, entry_id)
+        return if note_input.is_read_only
+
+        note = note_input.text.to_s
+        deactivate_entry_note_input(note_input)
+        return unless on_entry_note_change
+
+        on_entry_note_change.call(entry_id, note)
+      end
+
+      def activate_entry_note_input(note_input)
+        note_input.set_read_only(false)
+        note_input.set_focus
+      end
+
+      def deactivate_entry_note_input(note_input)
+        note_input.set_read_only(true)
+        note_input.clear_focus
+      end
+
+      def handle_entry_note_key_press(note_input, entry_id, event)
+        return unless enter_key?(event)
+
+        handle_entry_note_commit(note_input, entry_id)
+      end
+
+      def handle_entry_note_focus_out(note_input)
+        deactivate_entry_note_input(note_input)
+      end
+
+      def enter_key?(event)
+        key = event_key_code(event)
+        [Qt::Key_Return, Qt::Key_Enter].include?(key)
+      end
+
+      def event_key_code(event)
+        return event[:a] if event.is_a?(Hash) && event.key?(:a)
+        return event['a'] if event.is_a?(Hash) && event.key?('a')
+
+        event.respond_to?(:key) ? event.key : nil
+      end
+    end
+  end
+end

data/app/components/entries/leaf_task_helpers.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module QTimetrap
+  module Entries
+    # Entry-leaf helpers for editable task combo-box controls.
+    module LeafTaskHelpers
+      private
+
+      def build_entry_task_input(row, node)
+        QComboBox.new(row).tap do |task_input|
+          task_input.set_object_name('entry_node_entry_task')
+          task_input.set_editable(true)
+          task_input.instance_variable_set(:@qtimetrap_task_line_edit, build_entry_task_line_edit(row))
+          task_input.set_line_edit(entry_task_line_edit(task_input))
+          task_input.set_placeholder_text('task')
+          task_input.set_minimum_width(220)
+          populate_entry_task_options(task_input, node)
+          bind_entry_task_input_events(task_input, resolve_entry_id(node))
+        end
+      end
+
+      def build_entry_task_line_edit(row)
+        QLineEdit.new(row).tap do |line_edit|
+          line_edit.set_object_name('entry_node_entry_task_input')
+        end
+      end
+
+      def populate_entry_task_options(task_input, node)
+        current_task = node.fetch(:task_name, '').to_s
+        suggestions = Array(task_suggestions_for_project&.call(node.fetch(:project_name, '').to_s))
+        options = ([current_task] + suggestions.map(&:to_s)).reject(&:empty?).uniq
+        options.each { |task_name| task_input.add_item(task_name) }
+        task_input.set_current_text(current_task)
+        deactivate_entry_task_input(task_input)
+      end
+
+      def bind_entry_task_input_events(task_input, entry_id)
+        input = entry_task_line_edit(task_input)
+        input.on(:mouse_button_press) { |_| activate_entry_task_input(task_input) }
+        input.on(:key_press) { |event| handle_entry_task_key_press(task_input, entry_id, event) }
+        input.connect('returnPressed') { |_| handle_entry_task_commit(task_input, entry_id) }
+        input.on(:focus_out) { |_| handle_entry_task_focus_out(task_input) }
+        task_input.connect('textActivated') { |_| handle_entry_task_commit(task_input, entry_id, force: true) }
+      end
+
+      def activate_entry_task_input(task_input)
+        entry_task_line_edit(task_input).set_read_only(false)
+        task_input.set_focus
+      end
+
+      def deactivate_entry_task_input(task_input)
+        entry_task_line_edit(task_input).set_read_only(true)
+        task_input.clear_focus
+      end
+
+      def handle_entry_task_key_press(task_input, entry_id, event)
+        return unless enter_key?(event)
+
+        handle_entry_task_commit(task_input, entry_id)
+      end
+
+      def handle_entry_task_commit(task_input, entry_id, force: false)
+        return if entry_task_line_edit(task_input).is_read_only && !force
+
+        task_name = task_input.current_text.to_s
+        deactivate_entry_task_input(task_input)
+        return unless on_entry_task_change
+
+        on_entry_task_change.call(entry_id, task_name)
+      end
+
+      def handle_entry_task_focus_out(task_input)
+        deactivate_entry_task_input(task_input)
+      end
+
+      def entry_task_line_edit(task_input)
+        task_input.instance_variable_get(:@qtimetrap_task_line_edit)
+      end
+    end
+  end
+end