qtimetrap 0.1.1

data/app/components/tracker_controls/layout_builder.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+module QTimetrap
+  module TrackerControls
+    # Builds tracker controls widget tree and wires all button callbacks.
+    class LayoutBuilder
+      include QtUiHelpers
+      include LayoutHelpers
+
+      def initialize(parent:, callbacks:)
+        @parent = parent
+        @callbacks = callbacks
+      end
+
+      def build
+        @widget = QWidget.new(parent)
+        root = build_root_layout
+        root.add_widget(build_topbar)
+        start_button, stop_button = build_tracker_row(root)
+        refresh_button = build_actions_row(root)
+        connect_actions(start_button, stop_button, refresh_button)
+        ui_payload
+      end
+
+      private
+
+      attr_reader :parent, :widget, :callbacks
+
+      def build_topbar
+        topbar = QWidget.new(widget)
+        topbar.set_object_name('topbar')
+        layout = QHBoxLayout.new(topbar)
+        configure_topbar_layout(layout, topbar)
+        topbar
+      end
+
+      def build_tracker_row(root_layout)
+        row = QWidget.new(widget)
+        row.set_object_name('tracker_row')
+        layout = QHBoxLayout.new(row)
+        layout.set_contents_margins(14, 12, 14, 12)
+        layout.set_spacing(8)
+        start_button, stop_button = add_tracker_row_widgets(layout, row)
+        root_layout.add_widget(row)
+        [start_button, stop_button]
+      end
+
+      def build_actions_row(root_layout)
+        row = QWidget.new(widget)
+        layout = QHBoxLayout.new(row)
+        layout.set_contents_margins(0, 0, 0, 0)
+        layout.set_spacing(8)
+        refresh_button = add_actions_row_widgets(layout, row)
+        root_layout.add_widget(row)
+        refresh_button
+      end
+
+      def build_task_input(parent_widget)
+        QLineEdit.new(parent_widget).tap do |input|
+          input.set_object_name('task_input')
+          input.set_placeholder_text('What are you working on?')
+          input.set_focus_policy(Qt::ClickFocus)
+          input.text = ''
+        end
+      end
+
+      def build_project_input(parent_widget)
+        QLineEdit.new(parent_widget).tap do |input|
+          input.set_object_name('project_input')
+          input.set_placeholder_text('your project')
+          input.set_focus_policy(Qt::ClickFocus)
+          input.text = ''
+          input.set_fixed_width(190)
+        end
+      end
+
+      def connect_actions(start_button, stop_button, refresh_button)
+        connect_start_stop(start_button, stop_button)
+        connect_theme_refresh(refresh_button)
+        connect_project_input
+      end
+
+      def connect_start_stop(start_button, stop_button)
+        start_button.connect('clicked') do |_|
+          callbacks.fetch(:on_start).call(@task_input.text.to_s, @project_input.text.to_s)
+        end
+        stop_button.connect('clicked') { |_| callbacks.fetch(:on_stop).call }
+      end
+
+      def connect_theme_refresh(refresh_button)
+        @theme_button.connect('clicked') { |_| callbacks.fetch(:on_switch_theme).call }
+        refresh_button.connect('clicked') { |_| callbacks.fetch(:on_refresh).call }
+      end
+
+      def connect_project_input
+        @project_input.connect('textChanged(QString)') { |text| callbacks.fetch(:on_project_change).call(text.to_s) }
+      end
+    end
+  end
+end

data/app/components/tracker_controls/layout_helpers.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+module QTimetrap
+  module TrackerControls
+    # Extracted helper methods for tracker controls layout assembly.
+    module LayoutHelpers
+      TITLE_SLOGANS = [
+        'Track time, ship value',
+        'Small steps, big output',
+        'Focus. Build. Finish.',
+        'Consistency beats intensity',
+        "Today's minutes, tomorrow's results",
+        'Make progress visible',
+        'Do the next right task'
+      ].freeze
+
+      private
+
+      def build_root_layout
+        QVBoxLayout.new(widget).tap do |layout|
+          layout.set_contents_margins(0, 8, 0, 0)
+          layout.set_spacing(14)
+        end
+      end
+
+      def configure_topbar_layout(layout, topbar)
+        layout.set_contents_margins(16, 8, 16, 8)
+        layout.set_spacing(8)
+        layout.add_widget(build_label(topbar, 'title_label', random_title_slogan))
+        layout.add_stretch(1)
+        @clock_label = build_label(topbar, 'clock_label', nil, width: 220)
+        @clock_label.set_alignment(Qt::AlignCenter)
+        layout.add_widget(@clock_label)
+      end
+
+      def add_tracker_row_widgets(layout, row)
+        @task_input = build_task_input(row)
+        @project_input = build_project_input(row)
+        @timer_label = build_label(row, 'timer_label', '00:00:00', width: 120)
+        @timer_label.set_alignment(Qt::AlignCenter)
+        @start_button = build_button(row, 'start_button', 'START', 64, 48)
+        @stop_button = build_button(row, 'stop_button', 'STOP', 64, 48)
+        @stop_button.hide
+        [@task_input, @project_input, @timer_label, @start_button, @stop_button].each { |item| layout.add_widget(item) }
+        [@start_button, @stop_button]
+      end
+
+      def add_actions_row_widgets(layout, row)
+        @summary_label = build_label(row, 'summary_label', nil, height: 42)
+        @summary_label.set_alignment(Qt::AlignCenter)
+        @theme_button = build_button(row, 'theme_button', 'THEME', 112, 34)
+        refresh_button = build_button(row, 'refresh_button', 'REFRESH', 110, 34)
+        layout.add_widget(@summary_label)
+        layout.add_stretch(1)
+        layout.add_widget(@theme_button)
+        layout.add_widget(refresh_button)
+        refresh_button
+      end
+
+      def ui_payload
+        ui_core_payload.merge(ui_controls_payload)
+      end
+
+      def ui_core_payload
+        {
+          widget: @widget,
+          task_input: @task_input,
+          clock_label: @clock_label,
+          timer_label: @timer_label
+        }
+      end
+
+      def ui_controls_payload
+        {
+          summary_label: @summary_label,
+          project_input: @project_input,
+          theme_button: @theme_button,
+          start_button: @start_button,
+          stop_button: @stop_button
+        }
+      end
+
+      def random_title_slogan
+        TITLE_SLOGANS.sample
+      end
+    end
+  end
+end

data/app/models/null_settings_store.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module QTimetrap
+  module Models
+    # No-op settings persistence implementation used as a safe fallback.
+    class NullSettingsStore
+      def write_theme_name(_theme_name); end
+      def read_window_geometry; end
+      def write_window_geometry(left:, top:, width:, height:); end
+    end
+  end
+end

data/app/models/time_entry.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require 'time'
+
+module QTimetrap
+  module Models
+    # Immutable time tracking entry model used across view and services.
+    class TimeEntry
+      attr_reader :id, :note, :sheet, :start_time, :end_time
+
+      def initialize(id:, note:, sheet:, start_time:, end_time:)
+        @id = id
+        @note = note.to_s
+        @sheet = sheet.to_s
+        @start_time = start_time
+        @end_time = end_time
+      end
+
+      def running?
+        end_time.nil?
+      end
+
+      def duration_seconds(now: Time.now)
+        return 0 unless start_time
+
+        finish = end_time || now
+        [finish.to_i - start_time.to_i, 0].max
+      end
+
+      def project
+        split_sheet.first
+      end
+
+      def task
+        split_sheet.last
+      end
+
+      def day
+        (start_time || Time.now).to_date
+      end
+
+      private
+
+      def split_sheet
+        raw = sheet.strip
+        return ['(default)', '(default task)'] if raw.empty?
+
+        parts = raw.split('|', 2)
+        return [raw, '(default task)'] unless parts.size == 2
+
+        project = parts.first.strip
+        task = parts.last.strip
+        project = '(default)' if project.empty?
+        task = '(default task)' if task.empty?
+        [project, task]
+      end
+    end
+  end
+end

data/app/services/archived_entries_store.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+require 'yaml'
+
+module QTimetrap
+  module Services
+    # Persists archived Timetrap entry ids in a local app-owned store.
+    class ArchivedEntriesStore
+      def initialize(path: default_path)
+        @path = path
+      end
+
+      def archived_ids
+        read_ids
+      end
+
+      def archived?(entry_id)
+        read_ids.include?(Integer(entry_id))
+      rescue ArgumentError, TypeError
+        false
+      end
+
+      def archive(entry_id)
+        id = Integer(entry_id)
+        ids = read_ids
+        return if ids.include?(id)
+
+        ids << id
+        write_ids(ids)
+      rescue ArgumentError, TypeError
+        nil
+      end
+
+      def unarchive(entry_id)
+        id = Integer(entry_id)
+        ids = read_ids
+        return unless ids.delete(id)
+
+        write_ids(ids)
+      rescue ArgumentError, TypeError
+        nil
+      end
+
+      private
+
+      attr_reader :path
+
+      def read_ids
+        return [] unless File.exist?(path)
+
+        payload = YAML.safe_load_file(path, permitted_classes: [], aliases: false)
+        return [] unless payload.is_a?(Hash)
+
+        Array(payload['archived_entry_ids']).filter_map { |value| Integer(value) }.uniq.sort
+      rescue Psych::SyntaxError, ArgumentError, TypeError
+        []
+      end
+
+      def write_ids(ids)
+        FileUtils.mkdir_p(File.dirname(path))
+        File.write(path, { 'archived_entry_ids' => ids.uniq.sort }.to_yaml)
+      end
+
+      def default_path
+        data_home = ENV.fetch('XDG_DATA_HOME', File.join(Dir.home, '.local', 'share'))
+        File.join(data_home, 'qtimetrap', 'archived_entries.yml')
+      end
+    end
+  end
+end

data/app/services/formatters.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module QTimetrap
+  module Services
+    # Stateless value formatters used by view models and UI rendering.
+    module Formatters
+      module_function
+
+      def seconds_to_hms(seconds)
+        seconds = [seconds.to_i, 0].max
+        hours = seconds / 3600
+        minutes = (seconds % 3600) / 60
+        secs = seconds % 60
+        format('%<h>02d:%<m>02d:%<s>02d', h: hours, m: minutes, s: secs)
+      end
+
+      def time_range(entry)
+        start_label, finish_label = time_bounds(entry)
+        "#{start_label} - #{finish_label}"
+      end
+
+      def time_bounds(entry)
+        start_label = entry.start_time ? entry.start_time.strftime('%H:%M') : '--:--'
+        finish_label = entry.end_time ? entry.end_time.strftime('%H:%M') : 'running'
+        [start_label, finish_label]
+      end
+    end
+  end
+end

data/app/services/settings_store.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+require 'yaml'
+
+module QTimetrap
+  module Services
+    # Persists lightweight UI settings in a YAML file under user config.
+    class SettingsStore
+      def initialize(path: default_path)
+        @path = path
+      end
+
+      def read_theme_name
+        data['theme']
+      end
+
+      def write_theme_name(theme_name)
+        value = theme_name.to_s.strip
+        return if value.empty?
+
+        payload = data.merge('theme' => value)
+        FileUtils.mkdir_p(File.dirname(path))
+        File.write(path, payload.to_yaml)
+      end
+
+      def read_window_geometry
+        value = data['window']
+        return nil unless value.is_a?(Hash)
+
+        geometry = stringify_keys(value)
+        parse_window_geometry(geometry)
+      end
+
+      def write_window_geometry(left:, top:, width:, height:)
+        payload = data.merge(
+          'window' => {
+            'left' => Integer(left),
+            'top' => Integer(top),
+            'width' => Integer(width),
+            'height' => Integer(height)
+          }
+        )
+        FileUtils.mkdir_p(File.dirname(path))
+        File.write(path, payload.to_yaml)
+      end
+
+      private
+
+      attr_reader :path
+
+      def data
+        return {} unless File.exist?(path)
+
+        loaded = YAML.safe_load_file(path, permitted_classes: [], aliases: false)
+        loaded.is_a?(Hash) ? stringify_keys(loaded) : {}
+      rescue Psych::SyntaxError
+        {}
+      end
+
+      def stringify_keys(hash)
+        hash.each_with_object({}) { |(k, v), memo| memo[k.to_s] = v }
+      end
+
+      def parse_window_geometry(geometry)
+        left = Integer(geometry['left'] || geometry['x'])
+        top = Integer(geometry['top'] || geometry['y'])
+        width = Integer(geometry['width'])
+        height = Integer(geometry['height'])
+        return nil unless width.positive? && height.positive?
+
+        { left: left, top: top, width: width, height: height }
+      rescue ArgumentError, TypeError
+        nil
+      end
+
+      def default_path
+        config_home = ENV.fetch('XDG_CONFIG_HOME', File.join(Dir.home, '.config'))
+        File.join(config_home, 'qtimetrap', 'config.yml')
+      end
+    end
+  end
+end

data/app/services/timetrap_gateway.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'open3'
+
+begin
+  require 'timetrap'
+rescue LoadError
+  # CLI fallback is supported.
+end
+
+module QTimetrap
+  module Services
+    # Integrates with Timetrap via Ruby API or CLI fallback.
+    class TimetrapGateway
+      include TimetrapGatewayStartHelpers
+      include TimetrapGatewayUpdateTaskHelpers
+      include TimetrapGatewayUpdateTimeHelpers
+      include TimetrapGatewayUpdateNoteHelpers
+      include TimetrapGatewayQueryHelpers
+
+      def initialize(bin: ENV.fetch('TIMETRAP_BIN', 't'), logger: TimetrapGatewayLogger.new)
+        @bin = bin
+        @logger = logger
+      end
+
+      def entries
+        if api_available?
+          logger.log_api(operation: 'entries', input: {}, output: 'requested')
+          result = entries_from_api
+          logger.log_api(operation: 'entries', input: {}, output: { count: result.size })
+          return result
+        end
+
+        entries_from_cli
+      end
+
+      def active_started_at
+        if api_available?
+          logger.log_api(operation: 'active_started_at', input: {}, output: 'requested')
+          result = active_started_at_from_api
+          logger.log_api(operation: 'active_started_at', input: {}, output: result&.iso8601)
+          return result
+        end
+
+        _active, started_at = active_from_cli
+        started_at
+      end
+
+      def start(sheet, checkin_note = nil)
+        normalized_sheet, normalized_checkin_note = normalize_start_inputs(sheet, checkin_note)
+        return if normalized_sheet.empty?
+
+        if api_available?
+          logger.log_api(
+            operation: 'start',
+            input: { sheet: normalized_sheet, checkin_note: normalized_checkin_note },
+            output: 'requested'
+          )
+          result = start_via_api(normalized_sheet, normalized_checkin_note)
+          logger.log_api(operation: 'start', input: {}, output: result.to_s)
+          return result
+        end
+
+        start_via_cli(normalized_sheet, normalized_checkin_note)
+      end
+
+      def stop
+        if api_available?
+          logger.log_api(operation: 'stop', input: {}, output: 'requested')
+          active = Timetrap::Timer.active_entry
+          Timetrap::Timer.stop(active) if active
+          logger.log_api(operation: 'stop', input: {}, output: active ? 'stopped' : 'noop')
+          return
+        end
+
+        run('out')
+      end
+
+      private
+
+      def api_available?
+        defined?(Timetrap::Entry) && defined?(Timetrap::Timer)
+      end
+
+      attr_reader :bin, :logger
+    end
+  end
+end

data/app/services/timetrap_gateway_logger.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+require 'json'
+require 'time'
+
+module QTimetrap
+  module Services
+    # Writes Timetrap gateway input/output events to local log file.
+    class TimetrapGatewayLogger
+      DEFAULT_LOG_PATH = File.join(Dir.home, '.local', 'log', 'qtimetrap', 'timetrap_gateway.log')
+
+      def initialize(path: DEFAULT_LOG_PATH)
+        @path = path
+      end
+
+      def log_cli(bin:, args:, success:, output:)
+        write(
+          kind: 'cli',
+          bin: bin.to_s,
+          input: Array(args).map(&:to_s),
+          success: success ? true : false,
+          output: output.to_s
+        )
+      end
+
+      def log_api(operation:, input:, output:, success: true)
+        write(
+          kind: 'api',
+          operation: operation.to_s,
+          input: input,
+          success: success ? true : false,
+          output: output
+        )
+      end
+
+      private
+
+      attr_reader :path
+
+      def write(payload)
+        ensure_log_dir!
+        line = JSON.generate(payload.merge(at: Time.now.utc.iso8601))
+        File.open(path, 'a') { |file| file.puts(line) }
+      rescue StandardError
+        nil
+      end
+
+      def ensure_log_dir!
+        FileUtils.mkdir_p(File.dirname(path))
+      end
+    end
+  end
+end

data/app/services/timetrap_gateway_query_helpers.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+module QTimetrap
+  module Services
+    # Query/run helpers for TimetrapGateway CLI and API data reads.
+    module TimetrapGatewayQueryHelpers
+      private
+
+      def entries_from_api
+        Timetrap::Entry.order(:start).all.map do |entry|
+          Models::TimeEntry.new(
+            id: entry.id,
+            note: entry.note,
+            sheet: entry.sheet,
+            start_time: entry[:start],
+            end_time: entry[:end]
+          )
+        end
+      end
+
+      def entries_from_cli
+        ok, output = run('display', '--format', 'json')
+        return [] unless ok
+
+        output = normalize_text(output)
+        rows = parse_rows(output)
+        return [] unless rows
+
+        rows.map { |row| build_entry(row) }
+      rescue JSON::ParserError
+        []
+      end
+
+      def active_started_at_from_api
+        active = Timetrap::Timer.active_entry
+        active ? active[:start] : nil
+      end
+
+      def active_from_cli
+        ok, output = run('now')
+        return [nil, nil] unless ok
+
+        output = normalize_text(output)
+        match = output.match(/(\d{4}-\d{2}-\d{2} [0-9:]+ [+-]\d{4})/)
+        [true, (match ? parse_time(match[1]) : nil)]
+      end
+
+      def run(*args)
+        normalized_args = normalize_command_args(args)
+        output, status = with_unbundled_env { Open3.capture2e(bin, *normalized_args) }
+        log_cli_result(args: normalized_args, success: status.success?, output: output)
+      rescue Errno::ENOENT
+        log_cli_result(args: args, success: false, output: "Command not found: #{bin}")
+      rescue StandardError => e
+        log_cli_result(args: args, success: false, output: "#{e.class}: #{e.message}")
+      end
+
+      def normalize_command_args(args)
+        args.map { |arg| arg.is_a?(String) ? normalize_text(arg) : arg }
+      end
+
+      def log_cli_result(args:, success:, output:)
+        normalized_output = normalize_text(output)
+        logger.log_cli(bin: bin, args: args, success: success, output: normalized_output)
+        [success, normalized_output]
+      end
+
+      def parse_time(value)
+        Time.parse(value)
+      rescue ArgumentError, TypeError
+        nil
+      end
+
+      def parse_rows(output)
+        rows = JSON.parse(output)
+        rows.is_a?(Array) ? rows : nil
+      end
+
+      def build_entry(row)
+        Models::TimeEntry.new(
+          id: row['id'],
+          note: row['note'],
+          sheet: row['sheet'],
+          start_time: parse_time(row['start']),
+          end_time: parse_time(row['end'])
+        )
+      end
+
+      def normalize_text(value)
+        value.to_s.encode('UTF-8', invalid: :replace, undef: :replace, replace: '').scrub('')
+      end
+
+      def with_unbundled_env
+        return yield unless defined?(Bundler) && Bundler.respond_to?(:with_unbundled_env)
+
+        Bundler.with_unbundled_env do
+          return yield
+        end
+      end
+    end
+  end
+end