shoko 0.1.3 → 0.1.5

data/lib/shoko/adapters/storage/repositories/storage/bookmark_file_store.rb

@@ -1,108 +1,93 @@
 # frozen_string_literal: true
 
-require 'json'
-require 'fileutils'
 require 'time'
-
-require_relative '../../../output/terminal/terminal_sanitizer.rb'
-require_relative '../../../../core/models/bookmark.rb'
-require_relative '../../../../core/models/bookmark_data.rb'
-require_relative 'file_store_utils'
-require_relative '../../config_paths'
-# Domain storage helpers should operate via injected services to avoid reaching into infrastructure.
+require_relative '../../../../shared/text_sanitizer'
+require_relative '../../../../core/models/bookmark'
+require_relative '../../../../core/models/bookmark_data'
+require_relative 'base_file_store'
 
 module Shoko
-  module Adapters::Storage::Repositories::Storage
-    # File-backed bookmark storage isolated under Domain.
-    # Persists bookmarks to ${XDG_CONFIG_HOME:-~/.config}/shoko/bookmarks.json
-    class BookmarkFileStore
-      FILE_NAME = 'bookmarks.json'
-
-      def initialize(file_writer:)
-        @file_writer = file_writer
-      end
-
-      def add(bookmark_data)
-        unless bookmark_data.is_a?(Shoko::Core::Models::BookmarkData)
-          raise ArgumentError, 'bookmark_data must be BookmarkData'
-        end
-
-        all = load_all
-        path = bookmark_data.path.to_s
-        list = all[path] || []
-        entry = {
-          'chapter' => bookmark_data.chapter,
-          'line_offset' => bookmark_data.line_offset,
-          'text' => sanitize_text(bookmark_data.text),
-          'timestamp' => Time.now.iso8601,
-        }
-        list << entry
-        all[path] = list
-        save_all(all)
-        entry
-      end
-
-      def get(path)
-        all = load_all
-        list = all[path.to_s] || []
-        list.map do |h|
-          safe = h.is_a?(Hash) ? h.dup : {}
-          safe['text'] = sanitize_text(safe['text'])
-          Shoko::Core::Models::Bookmark.from_h(safe)
-        end
-      rescue StandardError
-        []
-      end
+  module Adapters
+    module Storage
+      module Repositories
+        module Storage
+          # File-backed bookmark storage isolated under Domain.
+          # Persists bookmarks to ${XDG_CONFIG_HOME:-~/.config}/shoko/bookmarks.json
+          class BookmarkFileStore < BaseFileStore
+            FILE_NAME = 'bookmarks.json'
 
-      def delete(path, bookmark)
-        all = load_all
-        key = path.to_s
-        list = all[key] || []
-        # Delete by matching serialized representation
-        predicate = if bookmark.respond_to?(:to_h)
-                      target = bookmark.to_h
-                      ->(stored_entry) { equivalent?(stored_entry, target) }
-                    else
-                      # Best-effort: match by position
-                      chapter = bookmark.respond_to?(:chapter_index) ? bookmark.chapter_index : bookmark[:chapter_index]
-                      offset = bookmark.respond_to?(:line_offset) ? bookmark.line_offset : bookmark[:line_offset]
-                      lambda { |stored_entry|
-                        stored_entry['chapter'] == chapter && stored_entry['line_offset'] == offset
-                      }
-                    end
-        list.reject!(&predicate)
-        list.empty? ? all.delete(key) : all[key] = list
-        save_all(all)
-        true
-      rescue StandardError
-        false
-      end
+            def add(bookmark_data)
+              unless bookmark_data.is_a?(Shoko::Core::Models::BookmarkData)
+                raise ArgumentError, 'bookmark_data must be BookmarkData'
+              end
 
-      private
+              all = load_all
+              path = bookmark_data.path.to_s
+              list = all[path] || []
+              entry = {
+                'chapter' => bookmark_data.chapter,
+                'line_offset' => bookmark_data.line_offset,
+                'text' => sanitize_text(bookmark_data.text),
+                'timestamp' => Time.now.iso8601,
+              }
+              list << entry
+              all[path] = list
+              save_all(all)
+              entry
+            end
 
-      attr_reader :file_writer
+            def get(path)
+              all = load_all
+              list = all[path.to_s] || []
+              list.map do |h|
+                safe = h.is_a?(Hash) ? h.dup : {}
+                safe['text'] = sanitize_text(safe['text'])
+                Shoko::Core::Models::Bookmark.from_h(safe)
+              end
+            end
 
-      def equivalent?(stored_entry, target)
-        stored_entry['chapter'] == target['chapter'] &&
-          stored_entry['line_offset'] == target['line_offset'] &&
-          (stored_entry['text'].to_s == target['text'].to_s)
-      end
+            def delete(path, bookmark)
+              all = load_all
+              key = path.to_s
+              list = all[key] || []
+              # Delete by matching serialized representation
+              predicate = bookmark_predicate(bookmark)
+              list.reject!(&predicate)
+              list.empty? ? all.delete(key) : all[key] = list
+              save_all(all)
+              true
+            end
 
-      def sanitize_text(text)
-        Shoko::Adapters::Output::Terminal::TerminalSanitizer.sanitize(text.to_s, preserve_newlines: false, preserve_tabs: false)
-      end
+            private
 
-      def load_all
-        FileStoreUtils.load_json_or_empty(file_path)
-      end
+            def equivalent?(stored_entry, target)
+              stored_entry['chapter'] == target['chapter'] &&
+                stored_entry['line_offset'] == target['line_offset'] &&
+                (stored_entry['text'].to_s == target['text'].to_s)
+            end
 
-      def save_all(data)
-        payload = JSON.pretty_generate(data)
-        file_writer.write(file_path, payload)
-      end
+            def bookmark_predicate(bookmark)
+              case bookmark
+              when Shoko::Core::Models::Bookmark
+                target = bookmark.to_h
+                ->(stored_entry) { equivalent?(stored_entry, target) }
+              when Hash
+                chapter = bookmark[:chapter_index] || bookmark['chapter_index'] || bookmark[:chapter] || bookmark['chapter']
+                offset = bookmark[:line_offset] || bookmark['line_offset']
+                lambda { |stored_entry|
+                  stored_entry['chapter'] == chapter && stored_entry['line_offset'] == offset
+                }
+              else
+                raise ArgumentError, 'bookmark must be a Bookmark or Hash'
+              end
+            end
 
-      def file_path
-        Adapters::Storage::ConfigPaths.config_path(FILE_NAME)
+            def sanitize_text(text)
+              Shoko::Shared::TextSanitizer.sanitize(text.to_s, preserve_newlines: false,
+                                                               preserve_tabs: false)
+            end
+          end
+        end
       end
     end
   end

data/lib/shoko/adapters/storage/repositories/storage/file_store_utils.rb

@@ -3,17 +3,21 @@
 require 'json'
 
 module Shoko
-  module Adapters::Storage::Repositories::Storage
-    # Small, shared helpers for file-backed JSON stores.
-    module FileStoreUtils
-      module_function
+  module Adapters
+    module Storage
+      module Repositories
+        module Storage
+          # Small, shared helpers for file-backed JSON stores.
+          module FileStoreUtils
+            module_function
 
-      def load_json_or_empty(file_path)
-        return {} unless File.exist?(file_path)
+            def load_json_or_empty(file_path)
+              return {} unless File.exist?(file_path)
 
-        JSON.parse(File.read(file_path))
-      rescue StandardError
-        {}
+              JSON.parse(File.read(file_path))
+            end
+          end
+        end
       end
     end
   end

data/lib/shoko/adapters/storage/repositories/storage/progress_file_store.rb

@@ -1,58 +1,42 @@
 # frozen_string_literal: true
 
-require 'json'
-require 'fileutils'
 require 'time'
-require_relative 'file_store_utils'
-require_relative '../../config_paths'
-# Domain storage helpers should operate via injected services to avoid reaching into infrastructure.
+require_relative 'base_file_store'
 
 module Shoko
-  module Adapters::Storage::Repositories::Storage
-    # File-backed progress storage under Domain.
-    # Persists progress to ${XDG_CONFIG_HOME:-~/.config}/shoko/progress.json
-    class ProgressFileStore
-      FILE_NAME = 'progress.json'
-
-      def initialize(file_writer:)
-        @file_writer = file_writer
-      end
-
-      def save(path, chapter_index, line_offset)
-        all = load_all
-        all[path.to_s] = {
-          'chapter' => chapter_index,
-          'line_offset' => line_offset,
-          'timestamp' => Time.now.iso8601,
-        }
-        save_all(all)
-        true
-      rescue StandardError
-        false
-      end
-
-      def load(path)
-        all = load_all
-        all[path.to_s]
-      rescue StandardError
-        nil
-      end
-
-      def load_all
-        FileStoreUtils.load_json_or_empty(file_path)
-      end
-
-      private
-
-      attr_reader :file_writer
-
-      def save_all(data)
-        payload = JSON.pretty_generate(data)
-        file_writer.write(file_path, payload)
-      end
-
-      def file_path
-        Adapters::Storage::ConfigPaths.config_path(FILE_NAME)
+  module Adapters
+    module Storage
+      module Repositories
+        module Storage
+          # File-backed progress storage under Domain.
+          # Persists progress to ${XDG_CONFIG_HOME:-~/.config}/shoko/progress.json
+          class ProgressFileStore < BaseFileStore
+            FILE_NAME = 'progress.json'
+
+            def save(path, chapter_index, line_offset)
+              all = load_all
+              all[path.to_s] = {
+                'chapter' => chapter_index,
+                'line_offset' => line_offset,
+                'timestamp' => Time.now.iso8601,
+              }
+              save_all(all)
+              true
+            rescue Shoko::Error
+              raise
+            end
+
+            def load(path)
+              all = load_all
+              all[path.to_s]
+            rescue Shoko::Error
+              raise
+            end
+
+            # Make load_all public for this store (needed by repository)
+            public :load_all
+          end
+        end
       end
     end
   end

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

@@ -0,0 +1,301 @@
+# frozen_string_literal: true
+
+require_relative '../../core/ports/outbound/dictionary_repository'
+require_relative 'config_paths'
+
+module Shoko
+  module Adapters
+    module Storage
+      # SQLite adapter for dictionary database operations.
+      # Implements the DictionaryRepository port interface.
+      class SqliteDictionaryAdapter
+        include Core::Ports::Outbound::DictionaryRepository
+
+        LANGUAGE_CODES = {
+          'german' => 'de', 'english' => 'en',
+          'russian' => 'ru', 'chinese' => 'zh',
+          'de' => 'de', 'en' => 'en', 'ru' => 'ru', 'zh' => 'zh'
+        }.freeze
+
+        FUZZY_LENGTH_TOLERANCE = 3
+        FUZZY_CANDIDATE_LIMIT = 500
+
+        def initialize(databases_path: nil, logger: nil)
+          @databases_path = if databases_path && !databases_path.to_s.strip.empty?
+                              File.expand_path(databases_path.to_s)
+                            else
+                              default_databases_path
+                            end
+          @connection_cache = {}
+          @logger = logger
+        end
+
+        # Search for a word in the dictionary
+        def search(word, source_lang:, target_lang:, mode: :exact, limit: 10)
+          db_path = database_path_for(source_lang, target_lang)
+          return [] unless db_path && File.exist?(db_path)
+
+          with_connection(db_path) do |db|
+            case mode
+            when :exact
+              simple_search(db, word, partial: false, limit: limit)
+            when :partial
+              simple_search(db, word, partial: true, limit: limit)
+            when :grouped
+              grouped_search(db, word, partial: false, limit: limit)
+            when :detailed
+              detailed_search(db, word, partial: false, limit: limit)
+            when :fuzzy
+              fuzzy_search_internal(db, word, limit: limit)
+            else
+              simple_search(db, word, partial: false, limit: limit)
+            end
+          end
+        end
+
+        # Perform fuzzy search for similar words
+        def fuzzy_search(word, source_lang:, target_lang:, limit: 30)
+          db_path = database_path_for(source_lang, target_lang)
+          return [] unless db_path && File.exist?(db_path)
+
+          with_connection(db_path) do |db|
+            fuzzy_search_internal(db, word, limit: limit)
+          end
+        end
+
+        # Get available language pairs by scanning database files
+        def available_language_pairs
+          return [] unless @databases_path && Dir.exist?(@databases_path)
+
+          Dir.glob(File.join(@databases_path, '*.sqlite3')).filter_map do |path|
+            basename = File.basename(path, '.sqlite3')
+            parts = basename.split('-')
+            next unless parts.length == 2
+
+            { source: parts[0], target: parts[1] }
+          end
+        end
+
+        # Check if a language pair database exists
+        def language_pair_available?(source_lang, target_lang)
+          path = database_path_for(source_lang, target_lang)
+          path && File.exist?(path)
+        end
+
+        # Get database file path for a language pair
+        def database_path_for(source_lang, target_lang)
+          source_code = normalize_lang_code(source_lang)
+          target_code = normalize_lang_code(target_lang)
+          return nil unless source_code && target_code
+
+          File.join(@databases_path, "#{source_code}-#{target_code}.sqlite3")
+        end
+
+        private
+
+        def default_databases_path
+          self.class.default_databases_path
+        end
+
+        def self.default_databases_path
+          ConfigPaths.config_path('dictionary')
+        end
+
+        def self.databases_present?(databases_path = nil)
+          path = if databases_path && !databases_path.to_s.strip.empty?
+                   File.expand_path(databases_path.to_s)
+                 else
+                   default_databases_path
+                 end
+          return false unless path && Dir.exist?(path)
+
+          Dir.glob(File.join(path, '*.sqlite3')).any?
+        rescue Shoko::Error
+          raise
+        end
+
+        def self.sqlite3_available?
+          Shoko::Shared::OptionalDependency.require_gem!('sqlite3')
+          true
+        rescue Shoko::DependencyUnavailableError, Shoko::Error
+          raise
+        end
+
+        def normalize_lang_code(lang)
+          LANGUAGE_CODES[lang&.downcase]
+        end
+
+        def with_connection(db_path)
+          require_sqlite3!
+          # Simple connection management - create new connection each time
+          # to avoid threading issues
+          db = SQLite3::Database.new(db_path)
+          db.results_as_hash = true
+          begin
+            yield db
+          ensure
+            db.close
+          end
+        rescue SQLite3::Exception => e
+          log_error('sqlite_dictionary_error', path: db_path, error: e.message)
+          raise Shoko::Core::Ports::Outbound::DictionaryRepository::RepositoryError.new(
+            code: classify_sqlite_failure(e),
+            message: e.message,
+            details: { path: db_path, error_class: e.class.name }
+          )
+        end
+
+        def simple_search(db, word, partial:, limit:)
+          query = build_search_query('translation_grouped',
+                                     'written_rep, sense_list, trans_list, score, importance',
+                                     partial: partial)
+          search_term = partial ? "%#{word}%" : word
+          params = partial ? [search_term, limit] : [search_term]
+
+          db.execute(query, params)
+        end
+
+        def grouped_search(db, word, partial:, limit:)
+          query = build_search_query('translation_grouped', '*', partial: partial)
+          search_term = partial ? "%#{word}%" : word
+          params = partial ? [search_term, limit] : [search_term]
+
+          db.execute(query, params)
+        end
+
+        def detailed_search(db, word, partial:, limit:)
+          query = build_search_query('translation', '*', partial: partial)
+          search_term = partial ? "%#{word}%" : word
+          params = partial ? [search_term, limit] : [search_term]
+
+          db.execute(query, params)
+        end
+
+        def build_search_query(table, columns, partial:)
+          operator = partial ? 'LIKE' : '='
+          limit_clause = partial ? 'LIMIT ?' : ''
+
+          <<~SQL
+            SELECT #{columns}
+            FROM #{table}
+            WHERE written_rep #{operator} ? COLLATE NOCASE
+            ORDER BY score DESC, importance DESC
+            #{limit_clause}
+          SQL
+        end
+
+        def fuzzy_search_internal(db, word, limit:)
+          candidates = fetch_fuzzy_candidates(db, word)
+          scored = score_candidates(word, candidates)
+          filter_and_sort_fuzzy(scored, limit)
+        end
+
+        def fetch_fuzzy_candidates(db, word)
+          first_char = word.downcase[0]
+          min_len = [word.length - FUZZY_LENGTH_TOLERANCE, 1].max
+          max_len = word.length + FUZZY_LENGTH_TOLERANCE
+
+          query = <<~SQL
+            SELECT DISTINCT written_rep
+            FROM simple_translation
+            WHERE lower(written_rep) LIKE ?
+            OR length(written_rep) BETWEEN ? AND ?
+            LIMIT ?
+          SQL
+
+          db.execute(query, ["#{first_char}%", min_len, max_len, FUZZY_CANDIDATE_LIMIT])
+        end
+
+        def score_candidates(word, candidates)
+          word_lower = word.downcase
+          normalized_word = normalize_for_comparison(word)
+
+          candidates.map do |row|
+            candidate = row['written_rep']
+            similarity = calculate_similarity(word_lower, normalized_word, candidate)
+            { word: candidate, similarity: similarity }
+          end
+        end
+
+        def calculate_similarity(word_lower, normalized_word, candidate)
+          candidate_lower = candidate.downcase
+          candidate_normalized = normalize_for_comparison(candidate)
+
+          distance_raw = levenshtein_distance(word_lower, candidate_lower)
+          distance_normalized = levenshtein_distance(normalized_word, candidate_normalized)
+          best_distance = [distance_raw, distance_normalized].min
+
+          max_len = [word_lower.length, candidate.length].max
+          1.0 - (best_distance.to_f / max_len)
+        end
+
+        def normalize_for_comparison(word)
+          word.unicode_normalize(:nfkd)
+              .downcase
+              .tr('äöüß', 'aous')
+              .tr('éèê', 'eee')
+        end
+
+        def filter_and_sort_fuzzy(scored, limit)
+          scored
+            .select { |r| r[:similarity] > 0.4 }
+            .sort_by { |r| [-r[:similarity], r[:word].length, r[:word]] }
+            .take(limit)
+        end
+
+        def levenshtein_distance(source, target)
+          return target.length if source.empty?
+          return source.length if target.empty?
+
+          matrix = Array.new(source.length + 1) { Array.new(target.length + 1) }
+
+          (0..source.length).each { |i| matrix[i][0] = i }
+          (0..target.length).each { |j| matrix[0][j] = j }
+
+          (1..source.length).each do |i|
+            (1..target.length).each do |j|
+              cost = source[i - 1] == target[j - 1] ? 0 : 1
+              matrix[i][j] = [
+                matrix[i - 1][j] + 1,
+                matrix[i][j - 1] + 1,
+                matrix[i - 1][j - 1] + cost,
+              ].min
+            end
+          end
+
+          matrix[source.length][target.length]
+        end
+
+        def log_error(event, **data)
+          @logger&.error(event, **data)
+        rescue Shoko::Error
+          # Silently ignore
+        end
+
+        def require_sqlite3!
+          Shoko::Shared::OptionalDependency.require_gem!('sqlite3')
+        rescue Shoko::DependencyUnavailableError => e
+          raise Shoko::DependencyUnavailableError, <<~MSG
+            Dictionary lookup requires the optional gem 'sqlite3'.
+
+            Install:
+              gem install sqlite3
+            On Void Linux you may also need:
+              sudo xbps-install -S sqlite-devel
+
+            #{e.message}
+          MSG
+        end
+
+        def classify_sqlite_failure(error)
+          message = error.message.to_s.downcase
+          return :corrupt_data if message.include?('database disk image is malformed') || message.include?('malformed')
+          return :invalid_data if message.include?('file is not a database') || message.include?('no such table')
+          return :permission_denied if message.include?('permission denied')
+
+          :internal
+        end
+      end
+    end
+  end
+end

data/lib/shoko/adapters/support/lifecycle_helpers.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+require_relative '../../shared/text_sanitizer'
+
+module Shoko
+  module Adapters
+    module Support
+      # Shared lifecycle helpers used by importers and cache pipeline stages.
+      module LifecycleHelpers
+        private
+
+        def report(message, progress: nil)
+          reporter = @progress_reporter
+          return unless reporter
+          return if message.nil? || message.to_s.strip.empty?
+
+          reporter.update_status(message: message, progress: progress)
+        rescue Shoko::Error
+          raise
+        end
+
+        def instrument(label, &)
+          instrumentation = @instrumentation
+          if instrumentation
+            instrumentation.measure(label, &)
+          else
+            yield
+          end
+        end
+
+        def fallback_title_from_path(path, strip_suffixes: [], trim_parenthetical: false, &sanitizer)
+          base = File.basename(path.to_s)
+          stripped = strip_compound_suffix(base, strip_suffixes)
+          stripped = File.basename(stripped, File.extname(stripped)) if stripped == base
+          stripped = stripped.tr('_', ' ').strip
+          stripped = trim_parenthetical_suffix(stripped) if trim_parenthetical
+          sanitize_title_text(stripped, &sanitizer)
+        rescue Shoko::Error
+          base.to_s
+        end
+
+        def strip_compound_suffix(value, suffixes)
+          text = value.to_s
+          Array(suffixes).each do |suffix|
+            normalized = suffix.to_s
+            next if normalized.empty?
+
+            if text.downcase.end_with?(normalized.downcase)
+              return text[0...-normalized.length]
+            end
+          end
+          text
+        end
+
+        def trim_parenthetical_suffix(text)
+          matched = text.to_s.match(/\A(.+?)\s*\(.*\)\s*\z/)
+          matched ? matched[1].strip : text
+        end
+
+        def sanitize_title_text(text)
+          value = block_given? ? yield(text.to_s) : Shoko::Shared::TextSanitizer.sanitize(
+            text.to_s,
+            preserve_newlines: false,
+            preserve_tabs: false
+          )
+          value.to_s
+        rescue Shoko::Error
+          text.to_s
+        end
+      end
+    end
+  end
+end