kotoshu 0.3.0

data/lib/kotoshu/dictionary/plain_text.rb

@@ -0,0 +1,282 @@
+# frozen_string_literal: true
+
+require "open-uri"
+require_relative "base"
+
+module Kotoshu
+  module Dictionary
+    # Plain text dictionary backend.
+    #
+    # This dictionary reads from simple plain text word lists,
+    # with support for comments and various formatting options.
+    #
+    # File format:
+    # - One word per line
+    # - Lines starting with # are comments
+    # - Empty lines are ignored
+    # - Supports multi-word phrases (e.g., "New York")
+    #
+    # @example Creating from a file
+    #   dict = PlainText.new("words.txt", language_code: "en-US")
+    #   dict.lookup?("hello")  # => true
+    #
+    # @example Creating from a URL
+    #   dict = PlainText.new("https://raw.githubusercontent.com/kotoshu/dictionaries/main/en_US/words.txt",
+    #                        language_code: "en-US")
+    #
+    # @example Creating from an array
+    #   dict = PlainText.from_words(%w[hello world test], language_code: "en")
+    class PlainText < Base
+      # @return [String] The path to the dictionary file (or nil if created from array)
+      attr_reader :path
+
+      # @return [Boolean] Whether lookups are case-sensitive
+      attr_reader :case_sensitive
+
+      # @return [Regexp, nil] Pattern for word filtering
+      attr_reader :word_pattern
+
+      # Create a new PlainText dictionary.
+      #
+      # @param path [String] Path to the dictionary file or URL
+      # @param language_code [String] The language code
+      # @param locale [String, nil] The locale (optional)
+      # @param case_sensitive [Boolean] Whether lookups are case-sensitive
+      # @param word_pattern [Regexp, nil] Pattern to filter words (optional)
+      # @param metadata [Hash] Additional metadata (optional)
+      def initialize(path, language_code:, locale: nil, case_sensitive: false,
+                     word_pattern: nil, metadata: {})
+        super(language_code, locale: locale, metadata: metadata)
+
+        @original_path = path
+        @path = resolve_path(path)
+        @case_sensitive = case_sensitive
+        @word_pattern = word_pattern
+        @words = load_words(@path)
+        @word_set = build_word_set
+
+        # Register this dictionary type
+        self.class.register_type(:plain_text) unless Dictionary.registry.key?(:plain_text)
+      end
+
+      # Check if a word exists in the dictionary.
+      #
+      # @param word [String] The word to look up
+      # @return [Boolean] True if the word exists
+      def lookup(word)
+        return false if word.nil? || word.empty?
+
+        lookup_word = @case_sensitive ? word : word.downcase
+        @word_set.key?(lookup_word)
+      end
+
+      # Generate spelling suggestions.
+      #
+      # Uses edit distance to find similar words in the dictionary.
+      #
+      # @param word [String] The misspelled word
+      # @param max_suggestions [Integer] Maximum suggestions
+      # @return [Array<String>] List of suggested words
+      def suggest(word, max_suggestions: 10)
+        return [] if word.nil? || word.empty?
+
+        lookup_word = @case_sensitive ? word : word.downcase
+
+        # Find words with same prefix
+        prefix_len = [lookup_word.length - 1, 3].max
+        prefix = lookup_word[0...prefix_len]
+        candidates = @words.select { |w| w.start_with?(prefix) }
+
+        # Calculate edit distances
+        candidates.map do |dict_word|
+          dist = edit_distance(lookup_word, dict_word)
+          [dict_word, dist]
+        end.select { |_, dist| dist.positive? && dist <= 2 }
+                  .sort_by { |_, dist| dist }
+                  .first(max_suggestions)
+                  .map(&:first)
+      end
+
+      # Add a word to the dictionary.
+      #
+      # @param word [String] The word to add
+      # @param flags [Array<String>] Flags (ignored for PlainText)
+      # @return [Boolean] True if added
+      def add_word(word, flags: [])
+        return false if word.nil? || word.empty?
+
+        lookup_word = @case_sensitive ? word : word.downcase
+        return false if @word_set.key?(lookup_word)
+
+        @words << lookup_word
+        @word_set[lookup_word] = @words.length - 1
+
+        true
+      end
+
+      # Remove a word from the dictionary.
+      #
+      # @param word [String] The word to remove
+      # @return [Boolean] True if removed
+      def remove_word(word)
+        return false if word.nil? || word.empty?
+
+        lookup_word = @case_sensitive ? word : word.downcase
+        return false unless @word_set.key?(lookup_word)
+
+        index = @word_set.delete(lookup_word)
+        @words.delete_at(index)
+
+        true
+      end
+
+      # Get all words in the dictionary.
+      #
+      # @return [Array<String>] All words
+      def words
+        @words.dup
+      end
+
+      # Create a dictionary from an array of words.
+      #
+      # @param words [Array<String>] The words
+      # @param language_code [String] The language code
+      # @param locale [String, nil] The locale (optional)
+      # @param case_sensitive [Boolean] Whether lookups are case-sensitive
+      # @return [PlainText] New dictionary
+      #
+      # @example
+      #   dict = PlainText.from_words(%w[hello world test], language_code: "en")
+      def self.from_words(words, language_code:, locale: nil, case_sensitive: false)
+        dict = allocate
+
+        dict.instance_variable_set(:@language_code, language_code.dup.freeze)
+        dict.instance_variable_set(:@locale, locale&.dup&.freeze)
+        dict.instance_variable_set(:@path, nil)
+        dict.instance_variable_set(:@case_sensitive, case_sensitive)
+        dict.instance_variable_set(:@word_pattern, nil)
+        dict.instance_variable_set(:@words, words.dup.map { |w| case_sensitive ? w : w.downcase })
+        dict.instance_variable_set(:@word_set, dict.instance_variable_get(:@words).each_with_index.to_h)
+        dict.instance_variable_set(:@metadata, {}.freeze)
+
+        # Register this dictionary type (unless already registered)
+        register_type(:plain_text) unless Dictionary.registry.key?(:plain_text)
+
+        dict
+      end
+
+      # Create a dictionary from a string.
+      #
+      # @param text [String] The text containing words (newline separated)
+      # @param language_code [String] The language code
+      # @param locale [String, nil] The locale (optional)
+      # @param case_sensitive [Boolean] Whether lookups are case-sensitive
+      # @return [PlainText] New dictionary
+      #
+      # @example
+      #   text = "hello\nworld\ntest"
+      #   dict = PlainText.from_string(text, language_code: "en")
+      def self.from_string(text, language_code:, locale: nil, case_sensitive: false)
+        words = text.split("\n").reject { |l| l.empty? || l.strip.start_with?("#") }
+                    .map(&:strip)
+
+        from_words(words, language_code: language_code, locale: locale,
+                          case_sensitive: case_sensitive)
+      end
+
+      private
+
+      # Resolve path - handles URLs by downloading to temp location.
+      #
+      # @param path [String] File path or URL
+      # @return [String] Local file path
+      def resolve_path(path)
+        return File.expand_path(path) unless url?(path)
+
+        # Download URL to temp file
+        download_to_temp(path)
+      end
+
+      # Check if path is a URL.
+      #
+      # @param path [String] Path to check
+      # @return [Boolean] True if URL
+      def url?(path)
+        path.start_with?("http://", "https://")
+      end
+
+      # Download URL to temporary file.
+      #
+      # @param url [String] URL to download
+      # @return [String] Path to downloaded file
+      def download_to_temp(url)
+        require "tempfile"
+
+        uri = URI.parse(url)
+        filename = File.basename(uri.path)
+
+        temp = Tempfile.new([filename, ".txt"], encoding: "UTF-8")
+        temp.binmode
+
+        URI.open(uri, "rb") do |remote_file|
+          IO.copy_stream(remote_file, temp)
+        end
+
+        temp.close
+        temp.path
+      end
+
+      # Load words from dictionary file.
+      #
+      # @param path [String] The file path
+      # @return [Array<String>] List of words
+      def load_words(path)
+        raise DictionaryNotFoundError, path unless File.exist?(path)
+
+        File.foreach(path, chomp: true)
+            .reject { |line| line.empty? || line.strip.start_with?("#") }
+            .map(&:strip)
+            .select { |word| @word_pattern.nil? || word.match?(@word_pattern) }
+            .map { |word| @case_sensitive ? word : word.downcase }
+      end
+
+      # Build a hash set for O(1) lookups.
+      #
+      # @return [Hash] Word to index mapping
+      def build_word_set
+        @words.each_with_index.to_h
+      end
+
+      # Calculate Levenshtein edit distance.
+      #
+      # @param str1 [String] First string
+      # @param str2 [String] Second string
+      # @return [Integer] Edit distance
+      def edit_distance(str1, str2)
+        return str2.length if str1.empty?
+        return str1.length if str2.empty?
+
+        # Use smaller string for inner loop
+        str1, str2 = str2, str1 if str1.length > str2.length
+
+        previous = (0..str1.length).to_a
+
+        str2.each_char.with_index do |char2, j|
+          current = [j + 1]
+
+          str1.each_char.with_index do |char1, i|
+            insert_cost = current[i] + 1
+            delete_cost = previous[i + 1] + 1
+            substitute_cost = previous[i] + (char1 == char2 ? 0 : 1)
+
+            current << [insert_cost, delete_cost, substitute_cost].min
+          end
+
+          previous = current
+        end
+
+        previous.last
+      end
+    end
+  end
+end

data/lib/kotoshu/dictionary/repository.rb

@@ -0,0 +1,248 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module Kotoshu
+  module Dictionary
+    # Repository for managing multiple dictionary instances.
+    #
+    # This class provides a centralized registry for dictionaries,
+    # allowing them to be registered and retrieved by key.
+    #
+    # @example Registering and retrieving dictionaries
+    #   repo = Repository.new
+    #   repo.register(:en_US, unix_dict)
+    #   repo.register(:custom, custom_dict)
+    #   repo.get(:en_US)  # => unix_dict
+    #
+    # @example Using the global repository
+    #   Repository.register(:en_US, dict)
+    #   Repository.get(:en_US)
+    class Repository
+      # @return [Hash] The dictionary storage
+      attr_reader :dictionaries
+
+      # Create a new repository.
+      #
+      # @param dictionaries [Hash] Initial dictionaries (optional)
+      def initialize(dictionaries = {})
+        @dictionaries = dictionaries.dup
+      end
+
+      # Register a dictionary.
+      #
+      # @param key [Symbol, String] The key to register under
+      # @param dictionary [Base] The dictionary instance
+      # @return [self] Self for chaining
+      #
+      # @example
+      #   repo.register(:en_US, unix_dict)
+      def register(key, dictionary)
+        @dictionaries[key.to_sym] = dictionary
+        self
+      end
+      alias add register
+      alias []= register
+
+      # Get a dictionary by key.
+      #
+      # @param key [Symbol, String] The key
+      # @return [Base, nil] The dictionary or nil if not found
+      #
+      # @example
+      #   repo.get(:en_US)
+      def get(key)
+        @dictionaries[key.to_sym]
+      end
+      alias [] get
+
+      # Check if a key is registered.
+      #
+      # @param key [Symbol, String] The key
+      # @return [Boolean] True if the key exists
+      #
+      # @example
+      #   repo.registered?(:en_US)  # => true
+      def registered?(key)
+        @dictionaries.key?(key.to_sym)
+      end
+      alias has_key? registered?
+      alias key? registered?
+
+      # Unregister a dictionary.
+      #
+      # @param key [Symbol, String] The key
+      # @return [Base, nil] The removed dictionary or nil
+      #
+      # @example
+      #   repo.unregister(:en_US)
+      def unregister(key)
+        @dictionaries.delete(key.to_sym)
+      end
+      alias remove unregister
+
+      # Clear all dictionaries.
+      #
+      # @return [self] Self for chaining
+      def clear
+        @dictionaries.clear
+        self
+      end
+
+      # Get all registered keys.
+      #
+      # @return [Array<Symbol>] All keys
+      def keys
+        @dictionaries.keys
+      end
+
+      # Iterate over registered keys.
+      #
+      # @yield [key] Block to execute for each key
+      # @return [Enumerator] Enumerator if no block given
+      def each_key(&block)
+        return enum_for(:each_key) unless block_given?
+
+        @dictionaries.each_key(&block)
+      end
+
+      # Get all dictionaries.
+      #
+      # @return [Array<Base>] All dictionaries
+      def values
+        @dictionaries.values
+      end
+
+      # Get the number of registered dictionaries.
+      #
+      # @return [Integer] Dictionary count
+      def size
+        @dictionaries.size
+      end
+      alias count size
+      alias length size
+
+      # Check if the repository is empty.
+      #
+      # @return [Boolean] True if empty
+      def empty?
+        @dictionaries.empty?
+      end
+
+      # Iterate over dictionaries.
+      #
+      # @yield [key, dictionary] Each key and dictionary
+      # @return [Enumerator] Enumerator if no block given
+      def each(&block)
+        return enum_for(:each) unless block_given?
+
+        @dictionaries.each(&block)
+      end
+
+      # Merge another repository into this one.
+      #
+      # @param other [Repository, Hash] The repository or hash to merge
+      # @return [self] Self for chaining
+      #
+      # @example
+      #   repo1.merge(repo2)
+      def merge(other)
+        dicts_to_merge = other.is_a?(Repository) ? other.dictionaries : other
+
+        @dictionaries.merge!(dicts_to_merge)
+        self
+      end
+
+      # Find dictionaries by language code.
+      #
+      # @param language_code [String] The language code
+      # @return [Array<Base>] Matching dictionaries
+      #
+      # @example
+      #   repo.find_by_language("en-US")
+      def find_by_language(language_code)
+        @dictionaries.values.select do |dict|
+          dict.language_code.casecmp(language_code).zero?
+        end
+      end
+
+      # Convert to hash.
+      #
+      # @return [Hash] Hash representation
+      def to_h
+        @dictionaries.dup
+      end
+
+      # String representation.
+      #
+      # @return [String] String representation
+      def to_s
+        "Repository(size: #{size})"
+      end
+      alias inspect to_s
+
+      # Global repository instance.
+      #
+      # @return [Repository] The global repository
+      #
+      # @example Using the global repository
+      #   Repository.instance.register(:en_US, dict)
+      def self.instance
+        @instance ||= new
+      end
+
+      # Register a dictionary in the global repository.
+      #
+      # @param key [Symbol, String] The key
+      # @param dictionary [Base] The dictionary
+      # @return [Repository] The global repository
+      #
+      # @example
+      #   Repository.register(:en_US, dict)
+      def self.register(key, dictionary)
+        instance.register(key, dictionary)
+      end
+
+      # Get a dictionary from the global repository.
+      #
+      # @param key [Symbol, String] The key
+      # @return [Base, nil] The dictionary or nil
+      #
+      # @example
+      #   Repository.get(:en_US)
+      def self.get(key)
+        instance.get(key)
+      end
+
+      # Unregister a dictionary from the global repository.
+      #
+      # @param key [Symbol, String] The key
+      # @return [Base, nil] The removed dictionary or nil
+      def self.unregister(key)
+        instance.unregister(key)
+      end
+
+      # Clear the global repository.
+      #
+      # @return [Repository] The global repository
+      def self.clear
+        instance.clear
+      end
+
+      # Get all keys from the global repository.
+      #
+      # @return [Array<Symbol>] All keys
+      def self.keys
+        instance.keys
+      end
+
+      # Check if a key is registered in the global repository.
+      #
+      # @param key [Symbol, String] The key
+      # @return [Boolean] True if the key exists
+      def self.registered?(key)
+        instance.registered?(key)
+      end
+    end
+  end
+end