kotoshu 0.3.0

data/lib/kotoshu/keyboard/registry.rb

@@ -0,0 +1,146 @@
+# frozen_string_literal: true
+
+require_relative 'layout'
+require_relative 'layouts/qwerty'
+require_relative 'layouts/qwertz'
+require_relative 'layouts/azerty'
+require_relative 'layouts/jcuken'
+require_relative 'layouts/dvorak'
+
+module Kotoshu
+  module Keyboard
+    # Registry for keyboard layouts
+    #
+    # The registry provides a centralized way to access keyboard layouts
+    # and automatically selects the appropriate layout for a given language.
+    #
+    # @example Getting layout for a language
+    #   layout = Keyboard::Registry.layout_for('de')
+    #   layout.name  # => "QWERTZ"
+    #
+    # @example Getting layout by name
+    #   layout = Keyboard::Registry.layout_by_name('Dvorak')
+    #   layout.name  # => "Dvorak"
+    #
+    # @example Listing all available layouts
+    #   Keyboard::Registry.available_layouts.each do |layout|
+    #     puts "#{layout.name}: #{layout.language_codes.join(', ')}"
+    #   end
+    #
+    class Registry
+      class << self
+        # Register a keyboard layout
+        #
+        # @param layout_class [Class<Layout>] the layout class to register
+        # @return [Layout] the instantiated layout
+        def register(layout_class)
+          layouts[layout_class.name] = layout_class.new
+        end
+
+        # Get layout for a specific language code
+        #
+        # Searches for a layout that supports the given language code.
+        # Returns QWERTY as fallback if no matching layout is found.
+        #
+        # @param language_code [String] the language code (e.g., 'en', 'de', 'fr', 'ru')
+        # @return [Layout] the keyboard layout for the language
+        def layout_for(language_code)
+          # Try exact match first
+          layout = layouts.values.find { |l| l.supports_language?(language_code) }
+
+          # Try base language if variant (e.g., 'en-GB' -> 'en')
+          unless layout
+            base_lang = language_code.to_s.split('-').first
+            layout = layouts.values.find { |l| l.supports_language?(base_lang) }
+          end
+
+          layout || default_layout
+        end
+
+        # Get layout by name
+        #
+        # @param name [String, Symbol] the layout name (e.g., 'QWERTY', 'Dvorak')
+        # @return [Layout] the layout, or QWERTY as fallback if not found
+        def layout_by_name(name)
+          name_str = name.to_s
+          result = layouts.values.find do |layout|
+            layout.name == name_str ||
+            layout.class.name.end_with?("::#{name_str}")
+          end
+
+          # Return QWERTY as fallback (not default_layout to avoid recursion)
+          result || layouts['Kotoshu::Keyboard::Layouts::QWERTY']
+        end
+
+        # Get all available layouts
+        #
+        # @return [Array<Layout>] list of all registered layouts
+        def available_layouts
+          layouts.values
+        end
+
+        # Get all supported language codes
+        #
+        # @return [Array<String>] list of all language codes across all layouts
+        def supported_languages
+          layouts.values.flat_map(&:language_codes).uniq.sort
+        end
+
+        # Set the default layout
+        #
+        # @param layout_name [String, Symbol] the name of the layout to use as default
+        def register_default(layout_name)
+          @default_layout_name = layout_name
+        end
+
+        # Check if a language is supported
+        #
+        # @param language_code [String] the language code to check
+        # @return [Boolean] true if the language is supported by any layout
+        def supports_language?(language_code)
+          layouts.values.any? { |l| l.supports_language?(language_code) }
+        end
+
+        # Clear all registered layouts (mainly for testing)
+        #
+        # @return [void]
+        def clear!
+          @layouts = nil
+          @default_layout_name = nil
+        end
+
+        private
+
+        # Get or initialize the layouts hash
+        #
+        # @return [Hash] hash of layout class names to instances
+        def layouts
+          @layouts ||= {}
+        end
+
+        # Get the default layout
+        #
+        # @return [Layout] the default layout (QWERTY if none specified)
+        def default_layout
+          if @default_layout_name
+            name_str = @default_layout_name.to_s
+            layout = layouts.values.find do |l|
+              l.name == name_str || l.class.name.end_with?("::#{name_str}")
+            end
+            return layout if layout
+          end
+
+          # Return QWERTY as the ultimate fallback
+          layouts['Kotoshu::Keyboard::Layouts::QWERTY'] || layouts.values.first
+        end
+      end
+
+      # Auto-register all layout classes on load
+      register(Layouts::QWERTY)
+      register(Layouts::QWERTZ)
+      register(Layouts::AZERTY)
+      register(Layouts::JCUKEN)
+      register(Layouts::Dvorak)
+    end
+  end
+end

data/lib/kotoshu/keyboard.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require_relative 'keyboard/registry'
+
+module Kotoshu
+  # Keyboard layout system for Kotoshu
+  #
+  # This module provides access to keyboard layouts for typo detection
+  # and suggestion ranking in multi-language spell checking.
+  #
+  # @example Getting a keyboard layout for a language
+  #   layout = Kotoshu::Keyboard.layout_for('de')
+  #   layout.distance('z', 'y')  # => 1 (adjacent on QWERTZ)
+  #
+  # @example Getting a layout by name
+  #   dvorak = Kotoshu::Keyboard.layout_by_name('Dvorak')
+  #   dvorak.distance('a', 'e')  # => 2 (home row on Dvorak)
+  #
+  module Keyboard
+    class << self
+      # Get keyboard layout for a language code
+      #
+      # @param language_code [String] the language code (e.g., 'en', 'de', 'fr', 'ru')
+      # @return [Layout] the keyboard layout for the language
+      def layout_for(language_code)
+        Registry.layout_for(language_code)
+      end
+
+      # Get keyboard layout by name
+      #
+      # @param name [String, Symbol] the layout name (e.g., 'QWERTY', 'Dvorak')
+      # @return [Layout, nil] the layout, or nil if not found
+      def layout_by_name(name)
+        Registry.layout_by_name(name)
+      end
+
+      # Get all available layouts
+      #
+      # @return [Array<Layout>] list of all registered layouts
+      def available_layouts
+        Registry.available_layouts
+      end
+
+      # Get all supported language codes
+      #
+      # @return [Array<String>] list of all language codes across all layouts
+      def supported_languages
+        Registry.supported_languages
+      end
+
+      # Check if a language is supported
+      #
+      # @param language_code [String] the language code to check
+      # @return [Boolean] true if the language is supported by any layout
+      def supports_language?(language_code)
+        Registry.supports_language?(language_code)
+      end
+    end
+  end
+end

data/lib/kotoshu/language/detector.rb

@@ -0,0 +1,242 @@
+# frozen_string_literal: true
+
+module Kotoshu
+  module Language
+    # Language detection based on character sets and patterns.
+    #
+    # Uses Unicode character ranges to identify probable language.
+    # Provides confidence scoring for multiple matches.
+    #
+    # @example Detect language
+    #   Language::Detector.detect("Hello world")  # => "en"
+    class Detector
+      # Character set ranges for language detection
+      CHARACTER_SETS = {
+        cyrillic: /\p{Cyrillic}/,
+        hiragana: /[\u3040-\u309F]/,
+        katakana: /[\u30A0-\u30FF]/,
+        cjk: /[\u4E00-\u9FFF]/,
+        hangul: /[\uAC00-\uD7AF]/,
+        latin: /[a-zA-Zà-ÿ]/
+      }.freeze
+
+      # Language-specific patterns
+      LANGUAGE_PATTERNS = {
+        # Russian: Cyrillic
+        russian: {
+          pattern: /\p{Cyrillic}[а-яА-ЯёЁ]/,
+          min_ratio: 0.3,
+          scripts: [:cyrillic]
+        },
+
+        # Japanese: Mixed script (Hiragana + Katakana + Kanji)
+        japanese: {
+          pattern: /[\u3040-\u309F]|[\u30A0-\u30FF]|[\u4E00-\u9FFF]/,
+          min_ratio: 0.2,
+          scripts: [:hiragana, :katakana, :cjk],
+          must_have: [:hiragana]  # Only require hiragana, not both
+        },
+
+        # Portuguese: Latin with specific accents
+        portuguese: {
+          pattern: /[ãõáàâãéêíóôõúç]/i,
+          min_ratio: 0.05,
+          scripts: [:latin]
+        },
+
+        # French: Latin with specific accents (NOT German umlauts)
+        french: {
+          pattern: /[éèêëàâùûüîïôç]/i,  # Removed ä, ö (not French)
+          min_ratio: 0.02,  # Lower threshold
+          scripts: [:latin],
+          priority: 1  # Higher priority than English
+        },
+
+        # Spanish: Latin with inverted punctuation
+        spanish: {
+          pattern: /[áéíóúüñ¿¡]/i,
+          min_ratio: 0.02,  # Lower threshold
+          scripts: [:latin],
+          priority: 1
+        },
+
+        # German: Latin with umlauts and eszett
+        german: {
+          pattern: /[äöüßÄÖÜ]/,  # Explicitly include uppercase
+          min_ratio: 0.02,  # Lower threshold
+          scripts: [:latin],
+          priority: 1
+        },
+
+        # English: Latin with minimal accents
+        english: {
+          pattern: /[a-zA-Z]/,
+          min_ratio: 0.3,
+          scripts: [:latin],
+          max_accent_ratio: 0.02
+        }
+      }.freeze
+
+      # Language code mapping
+      CODE_MAPPING = {
+        russian: "ru",
+        japanese: "ja",
+        portuguese: "pt",
+        french: "fr",
+        spanish: "es",
+        german: "de",
+        english: "en"
+      }.freeze
+
+      class << self
+        # Detect language from text.
+        #
+        # Returns the most probable language code based on character analysis.
+        #
+        # @param text [String] Text to analyze
+        # @return [String, nil] Detected language code or nil if uncertain
+        def detect(text)
+          return nil if text.nil? || text.strip.empty?
+
+          scores = analyze_languages(text)
+          return nil if scores.empty?
+
+          # Sort by score, then by priority (higher priority first)
+          result = scores.max_by do |code, score|
+            config = LANGUAGE_PATTERNS.find { |k, v| CODE_MAPPING[k] == code }
+            priority = config&.last&.dig(:priority) || 0
+            [score, priority]
+          end
+
+          result&.first
+        end
+
+        # Detect with confidence score.
+        #
+        # @param text [String] Text to analyze
+        # @return [Array<String, Float>] Language code and confidence (0-1)
+        def detect_with_confidence(text)
+          return [nil, 0.0] if text.nil? || text.strip.empty?
+
+          scores = analyze_languages(text)
+          return [nil, 0.0] if scores.empty?
+
+          top_language, top_score = scores.max_by { |_, score| score }
+          confidence = normalize_confidence(top_score, scores.values)
+
+          [top_language, confidence]
+        end
+
+        # Get multiple language candidates.
+        #
+        # @param text [String] Text to analyze
+        # @param limit [Integer] Maximum candidates to return
+        # @return [Array<Array<String, Float>>] Array of [code, confidence] pairs
+        def detect_candidates(text, limit: 3)
+          return [] if text.nil? || text.strip.empty?
+
+          scores = analyze_languages(text)
+          return [] if scores.empty?
+
+          total_score = scores.values.sum.to_f
+          scores
+            .sort_by { |_, score| -score }
+            .first(limit)
+            .map { |code, score| [code, score / total_score] }
+        end
+
+        private
+
+        # Analyze text and score each language.
+        #
+        # @param text [String] Text to analyze
+        # @return [Hash] Hash mapping language codes to scores
+        def analyze_languages(text)
+          text_length = text.length.to_f
+          return {} if text_length.zero?
+
+          scores = {}
+
+          LANGUAGE_PATTERNS.each do |language, config|
+            score = score_language(text, language, config, text_length)
+            scores[CODE_MAPPING[language]] = score if score > 0
+          end
+
+          scores
+        end
+
+        # Score a specific language against text.
+        #
+        # @param text [String] Text to analyze
+        # @param language [Symbol] Language key
+        # @param config [Hash] Language configuration
+        # @param text_length [Float] Length of text
+        # @return [Float] Score (0-1)
+        def score_language(text, language, config, text_length)
+          # Check required scripts
+          if config[:must_have]
+            return 0 unless config[:must_have].all? do |script|
+              text.match?(CHARACTER_SETS[script])
+            end
+          end
+
+          # Check forbidden scripts
+          if config[:must_not_have]
+            return 0 if config[:must_not_have].any? do |script|
+              text.match?(CHARACTER_SETS[script])
+            end
+          end
+
+          # Count matching characters
+          matches = text.scan(config[:pattern]).length
+          ratio = matches / text_length
+
+          # Check minimum ratio
+          return 0 if ratio < config[:min_ratio]
+
+          # Check maximum accent ratio (for English)
+          if config[:max_accent_ratio]
+            accent_chars = text.scan(/[à-ÿ]/).length
+            accent_ratio = accent_chars / text_length
+            return 0 if accent_ratio > config[:max_accent_ratio]
+          end
+
+          # Bonus for having required scripts
+          score = ratio
+          if config[:scripts]
+            script_bonus = config[:scripts].count do |script|
+              text.match?(CHARACTER_SETS[script])
+            end
+            score *= (1 + script_bonus * 0.1)
+          end
+
+          # Extra bonus for non-Latin specific characters (accents, umlauts, etc.)
+          # This helps distinguish languages with special characters from plain English
+          if language != :english && matches > 0
+            # Calculate what portion of the text is the special characters
+            special_char_ratio = matches / text_length
+            # Give bonus proportional to special character presence
+            score *= (1 + special_char_ratio)
+          end
+
+          [score, 1.0].min
+        end
+
+        # Normalize confidence score.
+        #
+        # @param top_score [Float] Highest score
+        # @param all_scores [Array<Float>] All scores
+        # @return [Float] Normalized confidence (0-1)
+        def normalize_confidence(top_score, all_scores)
+          return 0.0 if top_score.zero?
+
+          second_best = all_scores.sort { |a, b| b <=> a }[1] || 0
+          return 1.0 if second_best.zero?
+
+          ratio = top_score / (top_score + second_best)
+          (ratio * 0.8 + 0.2).clamp(0.0, 1.0) # Minimum confidence 0.2
+        end
+      end
+    end
+  end
+end