shoko 0.1.3 → 0.1.5

data/lib/shoko/adapters/output/ui/components/screens/library_screen_component.rb

@@ -1,205 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'base_screen_component'
-require_relative '../../constants/ui_constants'
-require_relative '../ui/list_helpers'
-require_relative '../ui/text_utils'
-
-module Shoko
-  module Adapters::Output::Ui::Components
-    module Screens
-      # LibraryScreenComponent renders the cached library view with
-      # sortable columns and paging of visible items.
-      class LibraryScreenComponent < BaseScreenComponent
-        include UI::TextUtils
-
-        Item = Struct.new(:title, :authors, :year, :last_accessed, :size_bytes, :open_path, :epub_path,
-                          keyword_init: true)
-        ItemRenderCtx = Struct.new(:row, :width, :book, :index, :selected, keyword_init: true)
-
-        def initialize(state, dependencies)
-          super(dependencies)
-          @state = state
-          @catalog = dependencies.resolve(:catalog_service)
-          @items = nil
-          # Observe selection changes to support scrolling
-          @state.add_observer(self, %i[menu browse_selected])
-        end
-
-        def state_changed(_path, _old, _new)
-          invalidate
-        end
-
-        def do_render(surface, bounds)
-          items = load_items
-          selected = Shoko::Application::Selectors::MenuSelectors.browse_selected(@state) || 0
-
-          render_header(surface, bounds)
-
-          if items.empty?
-            render_empty(surface, bounds)
-          else
-            render_library(surface, bounds, items, selected)
-          end
-
-          render_footer(surface, bounds)
-        end
-
-        private
-
-        def load_items
-          return @items if @items
-
-          entries = Array(@catalog.cached_library_entries)
-          @items = entries.map do |entry|
-            Item.new(
-              title: entry[:title] || entry['title'],
-              authors: entry[:authors] || entry['authors'],
-              year: entry[:year] || entry['year'],
-              last_accessed: entry[:last_accessed] || entry['last_accessed'],
-              size_bytes: entry[:size_bytes] || entry['size_bytes'] || @catalog.size_for(entry[:open_path] || entry['open_path']),
-              open_path: entry[:open_path] || entry['open_path'],
-              epub_path: entry[:epub_path] || entry['epub_path']
-            )
-          end
-        end
-
-        def render_header(surface, bounds)
-          write_header(surface, bounds, "#{Adapters::Output::Ui::Constants::UI::COLOR_TEXT_ACCENT} Library (Cached)#{Terminal::ANSI::RESET}")
-        end
-
-        def render_empty(surface, bounds)
-          write_empty_message(surface, bounds, "#{Adapters::Output::Ui::Constants::UI::COLOR_TEXT_DIM}No cached books yet#{Terminal::ANSI::RESET}")
-        end
-
-        def render_library(surface, bounds, items, selected)
-          list_start = 4
-          width = bounds.width
-          height = bounds.height
-          list_height = height - list_start - 2
-          return if list_height <= 0
-
-          draw_list_header(surface, bounds, width, list_start)
-          list_start += 2
-          list_height -= 2
-
-          items_per_page = list_height
-          start_index, visible_items = UI::ListHelpers.slice_visible(items, items_per_page, selected)
-
-          current_row = list_start
-          visible_items.each_with_index do |book, i|
-            break if current_row >= height - 1
-
-            ctx = ItemRenderCtx.new(row: current_row, width: width, book: book,
-                                    index: start_index + i, selected: selected)
-            render_library_item(surface, bounds, ctx)
-            current_row += 1
-          end
-        end
-
-        def draw_list_header(surface, bounds, width, row)
-          dims = compute_column_widths(width)
-
-          headers = [
-            pad_right('Title', dims[:title_w]),
-            pad_right('Author(s)', dims[:author_w]),
-            pad_right('Year', dims[:year_w]),
-            pad_right('Last accessed', dims[:last_w]),
-            pad_left('Size', dims[:size_w]),
-          ].join(' ' * dims[:gap])
-          header_style = Terminal::ANSI::BOLD + Terminal::ANSI::LIGHT_GREY
-          header_line = header_style + (' ' * dims[:pointer_w]) + headers + Terminal::ANSI::RESET
-          surface.write(bounds, row, 1, header_line)
-          divider = '─' * [width - 2, 1].max
-          divider_line = Adapters::Output::Ui::Constants::UI::COLOR_TEXT_DIM + divider + Terminal::ANSI::RESET
-          surface.write(bounds, row + 1, 1, divider_line)
-        end
-
-        def render_library_item(surface, bounds, ctx)
-          is_selected = (ctx.index == ctx.selected)
-          dims = compute_column_widths(ctx.width)
-
-          pointer = is_selected ? '▸ ' : '  '
-          book = ctx.book
-          t_w = dims[:title_w]
-          a_w = dims[:author_w]
-          y_w = dims[:year_w]
-          l_w = dims[:last_w]
-          s_w = dims[:size_w]
-          title_col = pad_right(truncate_text((book.title || 'Unknown').to_s, t_w), t_w)
-          author_col = pad_right(truncate_text((book.authors || '').to_s, a_w), a_w)
-          year_col = pad_right((book.year || '').to_s[0, 4], y_w)
-          last_col = pad_right(truncate_text(relative_accessed_label(book.last_accessed), l_w), l_w)
-          size_col = pad_left(format_size(book.size_bytes), s_w)
-
-          line = [title_col, author_col, year_col, last_col, size_col].join(' ' * dims[:gap])
-          style = is_selected ? Adapters::Output::Ui::Constants::UI::SELECTION_HIGHLIGHT : Adapters::Output::Ui::Constants::UI::COLOR_TEXT_PRIMARY
-          surface.write(bounds, ctx.row, 1, style + pointer + line + Terminal::ANSI::RESET)
-        end
-
-        def compute_column_widths(total_width)
-          pointer_w = 2
-          gap = 2
-          remaining = total_width - pointer_w - (gap * 4)
-          year_w = 6
-          last_w = 16
-          size_w = 8
-          author_w = [(remaining * 0.25).to_i, 12].max.clamp(12, remaining - 20 - year_w - last_w - size_w)
-          title_w = [remaining - author_w - year_w - last_w - size_w, 20].max
-          { pointer_w: pointer_w, gap: gap, title_w: title_w, author_w: author_w,
-            year_w: year_w, last_w: last_w, size_w: size_w }
-        end
-
-        def format_size(bytes)
-          mb = (bytes.to_f / (1024 * 1024)).round(1)
-          format('%.1f MB', mb)
-        end
-
-        def relative_accessed_label(iso)
-          return '' unless iso
-
-          t = begin
-            Time.parse(iso)
-          rescue StandardError
-            nil
-          end
-          return '' unless t
-
-          seconds = (Time.now - t).to_i
-          minutes = seconds / 60
-          hours = seconds / 3600
-          days = seconds / 86_400
-          weeks = days / 7
-
-          if hours < 1
-            minutes <= 1 ? 'a minute ago' : "#{minutes} minutes ago"
-          elsif days < 1
-            hours == 1 ? 'an hour ago' : "#{hours} hours ago"
-          elsif days == 1
-            'yesterday'
-          elsif days < 7
-            "#{days} days ago"
-          else
-            weeks == 1 ? 'a week ago' : "#{weeks} weeks ago"
-          end
-        end
-
-        def render_footer(surface, bounds)
-          write_footer(surface, bounds,
-                       "#{Adapters::Output::Ui::Constants::UI::COLOR_TEXT_DIM}↑↓ Navigate • Enter Open • ESC Back#{Terminal::ANSI::RESET}")
-        end
-
-        public
-
-        # Public accessor for items to avoid reflective access from MainMenu
-        def items
-          load_items
-        end
-
-        def invalidate_cache!
-          @items = nil
-        end
-      end
-    end
-  end
-end

data/lib/shoko/adapters/output/ui/components/screens/loading_overlay_component.rb

@@ -1,49 +0,0 @@
-# frozen_string_literal: true
-
-require_relative '../base_component'
-require_relative '../../../terminal/text_metrics.rb'
-
-module Shoko
-  module Adapters::Output::Ui::Components
-    module Screens
-      # Simple progress/loading overlay rendered as a component.
-      # Draws a single-row progress bar; expects progress in state at [:ui, :loading_progress].
-      class LoadingOverlayComponent < BaseComponent
-        include Adapters::Output::Ui::Constants::UI
-
-        def do_render(surface, bounds)
-          width  = bounds.width
-          height = bounds.height
-
-          state = @dependencies.resolve(:global_state)
-          message = state.get(%i[ui loading_message]).to_s.strip
-
-          message_row = 1
-          bar_row = message.empty? ? 2 : message_row + 2
-          bar_row = [bar_row, height - 1].min
-          bar_col = 2
-          bar_width = (width - (bar_col + 1)).clamp(10, width - bar_col)
-
-          progress = (state.get(%i[ui loading_progress]) || 0.0).to_f
-          progress = progress.clamp(0.0, 1.0)
-          filled = (bar_width * progress).round
-
-          unless message.empty?
-            label = Shoko::Adapters::Output::Terminal::TextMetrics.truncate_to(message, width - 2)
-            label_col = [(width - Shoko::Adapters::Output::Terminal::TextMetrics.visible_length(label)) / 2, 1].max
-            surface.write(bounds, message_row, label_col, "#{COLOR_TEXT_DIM}#{label}#{Terminal::ANSI::RESET}")
-          end
-
-          track = if bar_width.positive?
-                    (Terminal::ANSI::BRIGHT_GREEN + ('━' * filled)) +
-                      (Terminal::ANSI::GRAY + ('━' * (bar_width - filled))) +
-                      Terminal::ANSI::RESET
-                  else
-                    ''
-                  end
-          surface.write(bounds, bar_row, bar_col, track)
-        end
-      end
-    end
-  end
-end

data/lib/shoko/adapters/output/ui/components/screens/menu_screen_component.rb

@@ -1,107 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'base_screen_component'
-require_relative '../../constants/ui_constants'
-
-module Shoko
-  module Adapters::Output::Ui::Components
-    module Screens
-      # Component-based renderer for the main menu screen
-      class MenuScreenComponent < BaseScreenComponent
-        MenuItemCtx = Struct.new(:row, :item, :index, :selected, :indent, keyword_init: true)
-
-        def initialize(state)
-          super()
-          @state = state
-          @state.add_observer(self, %i[menu selected])
-        end
-
-        MENU_ITEMS = [
-          { icon: '', label: 'Browse Library' },
-          { icon: '', label: 'Library' },
-          { icon: '', label: 'Annotations' },
-          { icon: '', label: 'Download Books' },
-          { icon: '', label: 'Settings' },
-          { icon: '', label: 'Quit' },
-        ].freeze
-
-        def do_render(surface, bounds)
-          selected = Shoko::Application::Selectors::MenuSelectors.selected(@state) || 0
-
-          render_menu_items(surface, bounds, selected)
-        end
-
-        private
-
-        def render_menu_items(surface, bounds, selected)
-          metrics = layout_metrics(bounds)
-
-          MENU_ITEMS.each_with_index do |item, index|
-            row = metrics[:start_row] + (index * metrics[:row_height])
-            break if row >= metrics[:max_row]
-
-            ctx = MenuItemCtx.new(row: row, item: item, index: index,
-                                  selected: selected, indent: metrics[:indent])
-            render_menu_item(surface, bounds, ctx)
-          end
-        end
-
-        def render_menu_item(surface, bounds, ctx)
-          item = ctx.item
-          row = ctx.row
-          indent = ctx.indent
-
-          colors = row_colors(ctx.index == ctx.selected)
-
-          surface.write(bounds, row, indent,
-                        formatted_row(item[:icon], item[:label], colors))
-        end
-
-        def layout_metrics(bounds)
-          height = bounds.height
-          width  = bounds.width
-          content_width = menu_content_width
-          indent = ((width - content_width) / 2).floor
-          indent = indent.clamp(2, [width - content_width, 0].max)
-          row_height = 2
-          {
-            indent: indent,
-            row_height: row_height,
-            start_row: [(height - (MENU_ITEMS.size * row_height)) / 2, 4].max,
-            max_row: height - 4,
-          }
-        end
-
-        def formatted_row(icon, label, colors)
-          icon_col = icon.to_s
-          text = label
-          "#{colors[:prefix]}#{colors[:fg]}#{icon_col}  #{text}#{Terminal::ANSI::RESET}"
-        end
-
-        def row_colors(selected)
-          if selected
-            {
-              prefix: Terminal::ANSI::BOLD,
-              fg: Adapters::Output::Ui::Constants::UI::COLOR_TEXT_ACCENT,
-            }
-          else
-            {
-              prefix: '',
-              fg: Adapters::Output::Ui::Constants::UI::COLOR_TEXT_PRIMARY,
-            }
-          end
-        end
-
-        def menu_content_width
-          max_label = MENU_ITEMS.map { |item| display_width(item[:label]) }.max
-          icon_width = MENU_ITEMS.map { |item| display_width(item[:icon]) }.max
-          icon_width + 2 + max_label
-        end
-
-        def display_width(text)
-          Shoko::Adapters::Output::Terminal::TextMetrics.visible_length(text.to_s)
-        end
-      end
-    end
-  end
-end

data/lib/shoko/adapters/output/ui/components/screens/settings_screen_component.rb

@@ -1,238 +0,0 @@
-# frozen_string_literal: true
-
-require_relative '../base_component'
-require_relative '../../constants/ui_constants'
-require_relative '../../../terminal/text_metrics.rb'
-
-module Shoko
-  module Adapters::Output::Ui::Components
-    module Screens
-      # Settings screen component for configuration management
-      class SettingsScreenComponent < BaseComponent
-        include Adapters::Output::Ui::Constants::UI
-
-        SettingsItem = Struct.new(:action, :icon, :label, keyword_init: true)
-
-        SETTINGS_ITEMS = [
-          SettingsItem.new(action: :back_to_menu, icon: '', label: 'Go Back'),
-          SettingsItem.new(action: :toggle_view_mode, icon: '', label: 'View Mode'),
-          SettingsItem.new(action: :cycle_line_spacing, icon: '', label: 'Line Spacing'),
-          SettingsItem.new(action: :toggle_page_numbering_mode, icon: '', label: 'Page Numbering Mode'),
-          SettingsItem.new(action: :toggle_page_numbers, icon: '', label: 'Page Numbers'),
-          SettingsItem.new(action: :toggle_highlight_quotes, icon: '', label: 'Text Highlighting'),
-          SettingsItem.new(action: :toggle_kitty_images, icon: '', label: 'Kitty Images'),
-          SettingsItem.new(action: :wipe_cache, icon: '', label: 'Wipe Cache'),
-        ].freeze
-
-        ItemCtx = Struct.new(:row, :item, :value_text, :value_color, :index, :selected, :indent, keyword_init: true)
-
-        def initialize(state, catalog_service = nil)
-          super()
-          @state = state
-          @catalog = catalog_service
-        end
-
-        def do_render(surface, bounds)
-          surface.write(bounds, 1, 2, "#{COLOR_TEXT_ACCENT}Settings#{Terminal::ANSI::RESET}")
-
-          selected = @state.get(%i[menu settings_selected]) || 1
-          text_values = setting_value_map
-          render_settings(surface, bounds, selected, text_values)
-        end
-
-        def preferred_height(_available_height)
-          :fill
-        end
-
-        private
-
-        def render_settings(surface, bounds, selected, text_values)
-          metrics = layout_metrics(bounds, text_values)
-          indent = metrics[:indent]
-          max_index = SETTINGS_ITEMS.length - 1
-          cursor = selected.clamp(0, max_index)
-          row = metrics[:start_row]
-          insert_toggle_gap = false
-
-          SETTINGS_ITEMS.each_with_index do |item, index|
-            break if row >= metrics[:max_row]
-
-            action = item.action
-            is_selected = cursor == index
-            case action
-            when :toggle_view_mode
-              row = render_button_group(surface, bounds, item, row, indent, is_selected,
-                                        current_view_mode, view_mode_buttons)
-              insert_toggle_gap = false
-            when :cycle_line_spacing
-              row = render_button_group(surface, bounds, item, row, indent, is_selected,
-                                        current_line_spacing, line_spacing_buttons)
-              insert_toggle_gap = false
-            when :toggle_page_numbering_mode
-              row = render_button_group(surface, bounds, item, row, indent, is_selected,
-                                        current_page_numbering_mode, page_numbering_buttons)
-              insert_toggle_gap = true
-            else
-              if toggled_action?(action) && insert_toggle_gap
-                row += 1
-                insert_toggle_gap = false
-              end
-              value_text, value_color = text_values[action]
-              ctx = ItemCtx.new(row: row, item: item, value_text: value_text, value_color: value_color,
-                                index: index, selected: is_selected, indent: indent)
-              row = render_text_item(surface, bounds, ctx)
-            end
-          end
-        end
-
-        def render_text_item(surface, bounds, ctx)
-          text = formatted_row(ctx.item, ctx.value_text, ctx.value_color, ctx.selected)
-          row = ctx.row
-          surface.write(bounds, row, ctx.indent, text)
-          row + 2
-        end
-
-        def formatted_row(item, value_text, value_color, selected)
-          label = label_text(item)
-          colors = row_colors(selected)
-          line = "#{colors[:prefix]}#{colors[:fg]}#{label}"
-          line = "#{line}#{Terminal::ANSI::RESET}  #{value_color}#{value_text}" if value_text && !value_text.to_s.empty?
-          "#{line}#{Terminal::ANSI::RESET}"
-        end
-
-        def row_colors(selected)
-          if selected
-            { prefix: Terminal::ANSI::BOLD, fg: COLOR_TEXT_ACCENT }
-          else
-            { prefix: '', fg: COLOR_TEXT_PRIMARY }
-          end
-        end
-
-        def label_text(item)
-          "#{item.icon}  #{item.label}"
-        end
-
-        def layout_metrics(bounds, text_values)
-          height = bounds.height
-          width = bounds.width
-          label_width = SETTINGS_ITEMS.map { |item| display_width(label_text(item)) }.max || 0
-          text_value_width = text_values.values.map { |value| display_width(Array(value).first) }.max || 0
-          button_width = [
-            button_group_width(view_mode_buttons),
-            button_group_width(line_spacing_buttons),
-            button_group_width(page_numbering_buttons),
-          ].max || 0
-          content_width = label_width + 2 + [text_value_width, button_width].max
-          available = width - content_width
-          indent = (available / 2).floor
-          indent = indent.clamp(2, [available, 0].max)
-          {
-            indent: indent,
-            start_row: [(height - 16) / 2, 4].max,
-            max_row: height - 3,
-          }
-        end
-
-        def display_width(text)
-          Shoko::Adapters::Output::Terminal::TextMetrics.visible_length(text.to_s)
-        end
-
-        def setting_value_map
-          {
-            back_to_menu: ['Return to main menu', COLOR_TEXT_DIM],
-            toggle_page_numbers: toggle_page_number_value,
-            toggle_highlight_quotes: toggle_highlight_value,
-            toggle_kitty_images: toggle_kitty_images_value,
-            wipe_cache: ['Removes EPUB + scan caches', COLOR_TEXT_WARNING],
-          }
-        end
-
-        def render_button_group(surface, bounds, item, row, indent, selected, current_value, buttons)
-          colors = row_colors(selected)
-          label = "#{colors[:prefix]}#{colors[:fg]}#{label_text(item)}#{Terminal::ANSI::RESET}"
-          surface.write(bounds, row, indent, label)
-          buttons_line = button_row(buttons, current_value)
-          next_row = row + 1
-          surface.write(bounds, next_row, indent, buttons_line) if next_row < bounds.height
-          row + 3
-        end
-
-        def button_row(buttons, current_value)
-          buttons.map { |value, label| button_string(label, value == current_value) }.join(' ')
-        end
-
-        def button_string(label, active)
-          bg = active ? BUTTON_BG_ACTIVE : BUTTON_BG_INACTIVE
-          fg = active ? BUTTON_FG_ACTIVE : BUTTON_FG_INACTIVE
-          "#{bg}#{fg} #{label} #{Terminal::ANSI::RESET}"
-        end
-
-        def button_group_width(buttons)
-          buttons.sum do |_value, label|
-            Shoko::Adapters::Output::Terminal::TextMetrics.visible_length(label) + 2
-          end + (buttons.length - 1)
-        end
-
-        def toggled_action?(action)
-          %i[toggle_page_numbers toggle_highlight_quotes toggle_kitty_images].include?(action)
-        end
-
-        def view_mode_buttons
-          [[:split, 'Split'], [:single, 'Single']]
-        end
-
-        def line_spacing_buttons
-          [[:normal, 'Normal'], [:relaxed, 'Relaxed'], [:compact, 'Compact']]
-        end
-
-        def page_numbering_buttons
-          [[:absolute, 'Absolute'], [:dynamic, 'Dynamic']]
-        end
-
-        def current_view_mode
-          @state.get(%i[config view_mode]) || :split
-        end
-
-        def current_line_spacing
-          @state.get(%i[config line_spacing]) || :compact
-        end
-
-        def current_page_numbering_mode
-          @state.get(%i[config page_numbering_mode]) || :dynamic
-        end
-
-        def toggle_page_number_value
-          text = format_page_numbers
-          color = text == 'Enabled' ? COLOR_TEXT_SUCCESS : COLOR_TEXT_WARNING
-          [text, color]
-        end
-
-        def toggle_highlight_value
-          text = format_highlight_quotes
-          color = text == 'On' ? COLOR_TEXT_SUCCESS : COLOR_TEXT_WARNING
-          [text, color]
-        end
-
-        def format_page_numbers
-          @state.get(%i[config show_page_numbers]) ? 'Enabled' : 'Disabled'
-        end
-
-        def format_highlight_quotes
-          value = @state.get(%i[config highlight_quotes])
-          if value.nil? || !!value
-            'On'
-          else
-            'Off'
-          end
-        end
-
-        def toggle_kitty_images_value
-          enabled = !@state.get(%i[config kitty_images]).nil?
-          text = enabled ? 'Enabled' : 'Disabled'
-          color = enabled ? COLOR_TEXT_SUCCESS : COLOR_TEXT_DIM
-          [text, color]
-        end
-      end
-    end
-  end
-end