shoko 0.1.0

data/lib/shoko/adapters/output/ui/components/ui/text_utils.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require_relative '../../../terminal/text_metrics.rb'
+
+module Shoko
+  module Adapters::Output::Ui::Components
+    module UI
+      # Shared text layout utilities for terminal UI rendering.
+      module TextUtils
+        module_function
+
+        def wrap_text(text, width)
+          t = (text || '').to_s
+          w = width.to_i
+          return [''] if t.empty?
+          return [''] if w <= 0
+
+          Shoko::Adapters::Output::Terminal::TextMetrics.wrap_cells(t, w)
+        end
+
+        def truncate_text(text, max_length)
+          str = (text || '').to_s
+          w = max_length.to_i
+          return '' if w <= 0
+
+          return str if Shoko::Adapters::Output::Terminal::TextMetrics.visible_length(str) <= w
+
+          ellipsis = '...'
+          ellipsis_w = Shoko::Adapters::Output::Terminal::TextMetrics.visible_length(ellipsis)
+          return Shoko::Adapters::Output::Terminal::TextMetrics.truncate_to(str, w) if ellipsis_w >= w
+
+          base = Shoko::Adapters::Output::Terminal::TextMetrics.truncate_to(str, w - ellipsis_w)
+          base + ellipsis
+        end
+
+        def pad_right(text, width, pad: ' ')
+          Shoko::Adapters::Output::Terminal::TextMetrics.pad_right(text.to_s, width.to_i, pad: pad)
+        end
+
+        def pad_left(text, width, pad: ' ')
+          Shoko::Adapters::Output::Terminal::TextMetrics.pad_left(text.to_s, width.to_i, pad: pad)
+        end
+      end
+    end
+  end
+end

data/lib/shoko/adapters/output/ui/constants/highlighting.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Shoko
+  module Adapters::Output::Ui
+    module Constants
+      # Text highlighting patterns used by reading renderers.
+      module Highlighting
+        HIGHLIGHT_WORDS = [
+          'Chinese poets', 'philosophers', 'Taoyuen-ming', 'celebrated', 'fragrance',
+          'plum-blossoms', 'Linwosing', 'Chowmushih'
+        ].freeze
+        HIGHLIGHT_PATTERNS = Regexp.union(HIGHLIGHT_WORDS)
+        # Matches basic quoted spans for optional highlighting. Supports:
+        # - ASCII quotes: "..." and '...'
+        # - Curly quotes: “...” and ‘...’
+        # - Guillemets: «...» and ‹...›
+        QUOTE_PATTERNS = /(["“„«‹][^"“”„«»‹›]*["”»›])|(['‘‚][^'‘’‚]*['’])/
+      end
+    end
+  end
+end

data/lib/shoko/adapters/output/ui/constants/messages.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Shoko
+  module Adapters::Output::Ui
+    module Constants
+      module Messages
+        BOOKMARK_ADDED = 'Bookmark added!'
+        BOOKMARK_DELETED = 'Bookmark deleted!'
+      end
+    end
+  end
+end

data/lib/shoko/adapters/output/ui/constants/themes.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+require_relative '../../terminal/terminal.rb'
+
+module Shoko
+  module Adapters::Output::Ui
+    module Constants
+      # Theme palettes used by the terminal render style system.
+      module Themes
+        DEFAULT_PALETTE = {
+          primary: Terminal::ANSI::WHITE,
+          accent: Terminal::ANSI::BRIGHT_CYAN,
+          heading: Terminal::ANSI::BRIGHT_GREEN,
+          dim: Terminal::ANSI::DIM,
+          quote: Terminal::ANSI::LIGHT_GREY,
+          code: Terminal::ANSI::YELLOW,
+          separator: Terminal::ANSI::GRAY,
+          prefix: Terminal::ANSI::GRAY,
+        }.freeze
+
+        THEMES = {
+          default: DEFAULT_PALETTE,
+          standard: DEFAULT_PALETTE,
+          gray: DEFAULT_PALETTE.merge(
+            primary: Terminal::ANSI::LIGHT_GREY,
+            accent: Terminal::ANSI::BRIGHT_WHITE,
+            quote: Terminal::ANSI::GRAY
+          ).freeze,
+          sepia: DEFAULT_PALETTE.merge(
+            primary: Terminal::ANSI::YELLOW,
+            accent: Terminal::ANSI::BRIGHT_YELLOW,
+            dim: Terminal::ANSI::DIM,
+            quote: Terminal::ANSI::BRIGHT_YELLOW
+          ).freeze,
+          grass: DEFAULT_PALETTE.merge(
+            primary: Terminal::ANSI::GREEN,
+            accent: Terminal::ANSI::BRIGHT_GREEN,
+            quote: Terminal::ANSI::GREEN
+          ).freeze,
+          cherry: DEFAULT_PALETTE.merge(
+            primary: Terminal::ANSI::RED,
+            accent: Terminal::ANSI::BRIGHT_RED,
+            quote: Terminal::ANSI::BRIGHT_RED
+          ).freeze,
+          sky: DEFAULT_PALETTE.merge(
+            primary: Terminal::ANSI::BLUE,
+            accent: Terminal::ANSI::BRIGHT_BLUE,
+            quote: Terminal::ANSI::BRIGHT_BLUE
+          ).freeze,
+          solarized: DEFAULT_PALETTE.merge(
+            primary: Terminal::ANSI::CYAN,
+            accent: Terminal::ANSI::BRIGHT_CYAN,
+            quote: Terminal::ANSI::BRIGHT_CYAN
+          ).freeze,
+          gruvbox: DEFAULT_PALETTE.merge(
+            primary: Terminal::ANSI::YELLOW,
+            accent: Terminal::ANSI::BRIGHT_GREEN,
+            quote: Terminal::ANSI::BRIGHT_YELLOW
+          ).freeze,
+          nord: DEFAULT_PALETTE.merge(
+            primary: Terminal::ANSI::BRIGHT_BLUE,
+            accent: Terminal::ANSI::BRIGHT_CYAN,
+            quote: Terminal::ANSI::BRIGHT_CYAN
+          ).freeze,
+        }.freeze
+
+        module_function
+
+        def palette_for(theme)
+          theme_key = theme&.to_sym
+          base = DEFAULT_PALETTE
+          return base unless theme_key
+
+          THEMES[theme_key] || base
+        end
+      end
+    end
+  end
+end

data/lib/shoko/adapters/output/ui/constants/ui_constants.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+require_relative '../../terminal/terminal.rb'
+
+module Shoko
+  module Adapters::Output::Ui
+    module Constants
+      # Centralized UI color and style definitions
+      module UI
+        # Dimensions
+        MIN_WIDTH = 60
+        MIN_HEIGHT = 20
+
+        # Base Colors
+        COLOR_TEXT_PRIMARY = Terminal::ANSI::WHITE
+        COLOR_TEXT_SECONDARY = Terminal::ANSI::GRAY
+        COLOR_TEXT_DIM = Terminal::ANSI::DIM
+        COLOR_TEXT_ACCENT = Terminal::ANSI::BRIGHT_CYAN
+        COLOR_TEXT_SUCCESS = Terminal::ANSI::GREEN
+        COLOR_TEXT_WARNING = Terminal::ANSI::YELLOW
+        COLOR_TEXT_ERROR = Terminal::ANSI::RED
+
+        # Backgrounds
+        BG_PRIMARY = Terminal::ANSI::BG_DARK
+        BG_ACCENT = Terminal::ANSI::BG_BRIGHT_YELLOW
+
+        # Borders & Dividers
+        BORDER_PRIMARY = Terminal::ANSI::GRAY
+        BORDER_ACCENT = Terminal::ANSI::BRIGHT_CYAN
+
+        # Selections & Highlights
+        SELECTION_POINTER = '▸ '
+        SELECTION_FG = Terminal::ANSI::BLACK
+        SELECTION_POINTER_COLOR = Terminal::ANSI::BRIGHT_GREEN
+        SELECTION_HIGHLIGHT = Terminal::ANSI::BRIGHT_WHITE
+
+        # Overlay/Highlight backgrounds
+        HIGHLIGHT_BG_ACTIVE = Terminal::ANSI::BG_GREY
+        HIGHLIGHT_BG_SAVED = Terminal::ANSI::BG_GREY
+
+        # Popup menu colors
+        POPUP_BG_DEFAULT = Terminal::ANSI::BG_SLATE
+        POPUP_BG_SELECTED = Terminal::ANSI::BG_SOFT_GREEN
+        POPUP_FG_DEFAULT = COLOR_TEXT_PRIMARY
+        POPUP_FG_SELECTED = Terminal::ANSI::BLACK
+
+        # Tooltip menu colors
+        TOOLTIP_BG_DEFAULT = POPUP_BG_DEFAULT
+        TOOLTIP_BG_SELECTED = "\e[48;2;255;135;135m"
+        TOOLTIP_FG_DEFAULT = "\e[38;2;255;135;135m"
+        TOOLTIP_FG_SELECTED = "\e[38;2;88;88;88m"
+
+        # Annotation editor overlay colors
+        ANNOTATION_PANEL_BG = "\e[48;2;88;88;88m"
+        ANNOTATION_HEADER_FG = "\e[38;2;255;135;135m"
+
+        # Toast notification colors
+        TOAST_ACCENT = "\e[38;2;255;135;135m"
+        TOAST_FG = "\e[38;2;255;255;255m"
+
+        # Icons
+        ICON_BOOK = '󰂺'
+        ICON_RECENT = '󰁯'
+        ICON_ANNOTATION = '󰠮'
+        ICON_SETTINGS = ''
+        ICON_QUIT = '󰿅'
+        ICON_OPEN = '󰷏'
+        ICON_TOC = '📖'
+        ICON_BOOKMARK = '🔖'
+        ICON_HELP = '❓'
+        ICON_SEARCH = ''
+        ICON_REFRESH = ''
+
+        SIDEBAR_BG = Terminal::ANSI::BG_DARK
+        SIDEBAR_SELECTION_BG = Terminal::ANSI::BG_BLUE
+        SIDEBAR_SELECTION_FG = Terminal::ANSI::BRIGHT_WHITE
+
+        BUTTON_BG_ACTIVE = Terminal::ANSI::BG_BRIGHT_GREEN
+        BUTTON_FG_ACTIVE = Terminal::ANSI::BLACK
+        BUTTON_BG_INACTIVE = Terminal::ANSI::BG_GREY
+        BUTTON_FG_INACTIVE = Terminal::ANSI::WHITE
+      end
+    end
+  end
+end

data/lib/shoko/adapters/output/ui/rendering/frame_coordinator.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Shoko
+  module Adapters::Output::Ui
+    module Rendering
+      # Coordinates frame lifecycle and provides a consistent surface + bounds
+      # for rendering. Centralizes start_frame/end_frame and terminal size updates.
+      class FrameCoordinator
+        def initialize(dependencies)
+          @dependencies = dependencies
+          @terminal_service = @dependencies.resolve(:terminal_service)
+          @state = @dependencies.resolve(:global_state)
+        end
+
+        # Yields a prepared [surface, bounds, width, height] within a started frame.
+        # Ensures end_frame is called, even on errors.
+        def with_frame
+          height, width = @terminal_service.size
+          @terminal_service.start_frame(width: width, height: height)
+          @state.update_terminal_size(width, height)
+          surface = @terminal_service.create_surface
+          bounds = Shoko::Adapters::Output::Ui::Components::Rect.new(x: 1, y: 1, width: width, height: height)
+          yield(surface, bounds, width, height)
+        ensure
+          @terminal_service.end_frame
+        end
+
+        # Renders the loading overlay component in a standalone frame.
+        def render_loading_overlay
+          height, width = @terminal_service.size
+          @terminal_service.start_frame(width: width, height: height)
+          surface = @terminal_service.create_surface
+          bounds = Shoko::Adapters::Output::Ui::Components::Rect.new(x: 1, y: 1, width: width, height: height)
+          overlay = Shoko::Adapters::Output::Ui::Components::Screens::LoadingOverlayComponent.new(@dependencies)
+          overlay.render(surface, bounds)
+        ensure
+          @terminal_service.end_frame
+        end
+      end
+    end
+  end
+end

data/lib/shoko/adapters/output/ui/rendering/reader_render_coordinator.rb

@@ -0,0 +1,169 @@
+# frozen_string_literal: true
+
+require_relative '../components/header_component'
+require_relative '../components/content_component'
+require_relative '../components/footer_component'
+require_relative '../components/sidebar_panel_component'
+require_relative '../components/layouts/vertical'
+require_relative '../components/layouts/horizontal'
+require_relative '../components/tooltip_overlay_component'
+require_relative '../../../../application/ui/reader_view_model_builder.rb'
+
+module Shoko
+  module Adapters::Output::Ui
+    module Rendering
+      # Coordinates render/layout setup and per-frame drawing for the reader.
+      class ReaderRenderCoordinator
+        Dependencies = Struct.new(
+          :controller,
+          :state,
+          :dependencies,
+          :terminal_service,
+          :frame_coordinator,
+          :render_pipeline,
+          :ui_controller,
+          :wrapping_service,
+          :pagination,
+          :doc,
+          keyword_init: true
+        )
+
+        RenderComponents = Struct.new(
+          :header,
+          :content,
+          :footer,
+          :sidebar,
+          :main_layout,
+          :root_layout,
+          :overlay,
+          keyword_init: true
+        )
+
+        def initialize(dependencies:)
+          @deps = dependencies
+          @components = RenderComponents.new
+        end
+
+        def build_component_layout
+          vm_proc = -> { create_view_model }
+          components.header = Shoko::Adapters::Output::Ui::Components::HeaderComponent.new(vm_proc)
+          components.content = Shoko::Adapters::Output::Ui::Components::ContentComponent.new(deps.controller)
+          components.footer = Shoko::Adapters::Output::Ui::Components::FooterComponent.new(vm_proc)
+          components.sidebar = Shoko::Adapters::Output::Ui::Components::SidebarPanelComponent.new(deps.state, deps.dependencies)
+          components.main_layout = Shoko::Adapters::Output::Ui::Components::Layouts::Vertical.new([
+                                                                       components.header,
+                                                                       components.content,
+                                                                       components.footer,
+                                                                     ])
+
+          rebuild_root_layout
+          build_overlay
+        end
+
+        def rebuild_root_layout
+          components.root_layout = if deps.state.get(%i[reader sidebar_visible])
+                                     Shoko::Adapters::Output::Ui::Components::Layouts::Horizontal.new(components.sidebar, components.main_layout)
+                                   else
+                                     components.main_layout
+                                   end
+        end
+
+        def draw_screen
+          height, width = deps.terminal_service.size
+          tick_notifications
+          handle_resize(width, height) if size_changed?(width, height)
+
+          deps.frame_coordinator.with_frame do |surface, root_bounds, _w, _h|
+            mode = deps.state.get(%i[reader mode])
+            mode_component = deps.ui_controller.current_mode
+            if mode == :annotation_editor && mode_component
+              deps.render_pipeline.render_mode_component(mode_component, surface, root_bounds)
+            else
+              deps.render_pipeline.render_layout(surface, root_bounds, components.root_layout, components.overlay)
+            end
+          end
+        end
+
+        def refresh_highlighting
+          draw_screen
+        end
+
+        def force_redraw
+          components.content&.invalidate
+        end
+
+        def render_loading_overlay
+          deps.frame_coordinator.render_loading_overlay
+        end
+
+        def apply_theme_palette
+          theme = Shoko::Application::Selectors::ConfigSelectors.theme(deps.state) || :default
+          palette = Shoko::Adapters::Output::Ui::Constants::Themes.palette_for(theme)
+          Shoko::Adapters::Output::Ui::Components::RenderStyle.configure(palette)
+        rescue StandardError
+          Shoko::Adapters::Output::Ui::Components::RenderStyle.configure(Shoko::Adapters::Output::Ui::Constants::Themes::DEFAULT_PALETTE)
+        end
+
+        def sidebar_component
+          components.sidebar
+        end
+
+        def sidebar_bounds(total_width, total_height)
+          sidebar = components.sidebar
+          return nil unless sidebar
+
+          sidebar.sidebar_bounds_for(total_width, total_height)
+        end
+
+        private
+
+        attr_reader :deps, :components
+
+        def create_view_model
+          builder = Shoko::Application::UI::ReaderViewModelBuilder.new(deps.state, deps.doc)
+          builder.build(deps.pagination.page_info)
+        end
+
+        def size_changed?(width, height)
+          deps.state.terminal_size_changed?(width, height)
+        end
+
+        def handle_resize(width, height)
+          deps.pagination.refresh_after_resize(width: width, height: height)
+          clear_wrapping_cache
+        end
+
+        def clear_wrapping_cache
+          prior_width = deps.state.get(%i[reader last_width])
+          return unless prior_width&.positive?
+
+          deps.wrapping_service&.clear_cache_for_width(prior_width)
+        rescue StandardError
+          # best-effort cache clear
+        end
+
+        def build_overlay
+          coord = deps.dependencies.resolve(:coordinate_service)
+          components.overlay = Shoko::Adapters::Output::Ui::Components::TooltipOverlayComponent.new(
+            deps.controller,
+            coordinate_service: coord
+          )
+        end
+
+        def tick_notifications
+          notification_service&.tick(deps.state)
+        end
+
+        def notification_service
+          return @notification_service if defined?(@notification_service)
+
+          @notification_service = begin
+            deps.dependencies.resolve(:notification_service)
+          rescue StandardError
+            nil
+          end
+        end
+      end
+    end
+  end
+end

data/lib/shoko/adapters/output/ui/rendering/render_pipeline.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require_relative '../../../../application/selectors/reader_selectors.rb'
+
+module Shoko
+  module Adapters::Output::Ui
+    module Rendering
+      # RenderPipeline encapsulates the high-level rendering steps for
+      # component-driven frames and full-screen mode components.
+      class RenderPipeline
+        def initialize(dependencies)
+          @dependencies = dependencies
+          @state = @dependencies.resolve(:global_state)
+        end
+
+        # Render the standard layout + overlay path
+        def render_layout(surface, bounds, layout, overlay)
+          # Clear rendered lines for the new frame so overlays can rely on state
+          @state.dispatch(Shoko::Application::Actions::ClearRenderedLinesAction.new)
+
+          dim_layout = annotation_overlay_active?
+
+          if dim_layout
+            surface.with_dimmed { layout.render(surface, bounds) }
+          else
+            layout.render(surface, bounds)
+          end
+
+          overlay.render(surface, bounds)
+        end
+
+        # Render a dedicated full-screen component (e.g., editor)
+        def render_mode_component(component, surface, bounds)
+          surface.fill(bounds, ' ')
+          component.render(surface, bounds)
+        end
+
+        # Generic component render helper for non-reader screens (menu, dialogs)
+        def render_component(surface, bounds, component)
+          surface.fill(bounds, ' ')
+          component.render(surface, bounds)
+        end
+
+        private
+
+        def annotation_overlay_active?
+          overlay = Shoko::Application::Selectors::ReaderSelectors.annotation_editor_overlay(@state)
+          overlay.respond_to?(:visible?) && overlay.visible?
+        rescue StandardError
+          false
+        end
+      end
+    end
+  end
+end

data/lib/shoko/adapters/storage/atomic_file_writer.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+require 'tempfile'
+
+module Shoko
+  module Adapters::Storage
+    # Provides atomic, fsync-backed file writes to avoid partial/corrupt files.
+    class AtomicFileWriter
+      def self.write(path, data, binary: false)
+        write_using(path, binary:) do |io|
+          io.write(data)
+        end
+      end
+
+      def self.write_using(path, binary: false)
+        dir = File.dirname(path)
+        FileUtils.mkdir_p(dir)
+        tempfile = Tempfile.new(['shoko', File.basename(path)], dir)
+        tempfile.binmode if binary
+        yield(tempfile)
+        tempfile.flush
+        tempfile.fsync
+        temp_path = tempfile.path
+        tempfile.close
+        File.rename(temp_path, path)
+      ensure
+        if tempfile
+          begin
+            tempfile.close unless tempfile.closed?
+          rescue StandardError
+            # ignore cleanup errors
+          end
+          begin
+            tempfile.unlink if tempfile.path && File.exist?(tempfile.path)
+          rescue StandardError
+            # ignore cleanup errors
+          end
+        end
+      end
+    end
+  end
+end

data/lib/shoko/adapters/storage/background_worker.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require_relative '../monitoring/logger.rb'
+
+module Shoko
+  module Adapters::Storage
+    # Single-thread worker with monitored queue and graceful shutdown semantics.
+    class BackgroundWorker
+      def initialize(name: 'shoko-worker')
+        @name = name
+        @queue = Queue.new
+        @shutdown = false
+        @mutex = Mutex.new
+        @thread = spawn_thread
+      end
+
+      def submit(&block)
+        raise ArgumentError, 'block required' unless block
+
+        @mutex.synchronize do
+          raise WorkerStoppedError, 'worker is shutting down' if @shutdown
+
+          @queue << block
+        end
+      end
+
+      def shutdown(timeout: 2.0)
+        thread = nil
+        @mutex.synchronize do
+          return if @shutdown
+
+          @shutdown = true
+          thread = @thread
+          @queue << nil if thread&.alive?
+        end
+        thread&.join(timeout)
+      ensure
+        @thread = nil
+      end
+
+      class WorkerStoppedError < StandardError; end
+
+      private
+
+      def spawn_thread
+        Thread.new do
+          Thread.current.name = @name if Thread.current.respond_to?(:name=)
+          loop do
+            job = @queue.pop
+            break if job.nil? && @shutdown
+
+            next unless job
+
+            begin
+              job.call
+            rescue StandardError => e
+              Adapters::Monitoring::Logger.error('Background worker job failed',
+                                           worker: @name,
+                                           error: e.message)
+            end
+          end
+        end
+      end
+    end
+  end
+end