#$@%#$%!

Ngiler SH3LL 360
: / opt / alt / ruby27 / share / ruby / did_you_mean /

Information Server
MySQL : OFF Perl : OFF CURL : ON WGET : OFF PKEXEC : OFF

Directive	Local Value
IP Address	162.0.209.101
System	Linux premium169.web-hosting.com 4.18.0-553.50.1.lve.el8.x86_64 #1 SMP Thu Apr 17 19:10:24 UTC 2025 x86_64
User	luxeelil
PHP Version	8.0.30
Software	LiteSpeed
Doc root	Writable

Edit File : tree_spell_checker.rb \| Size : 3.38 KB
module DidYouMean # spell checker for a dictionary that has a tree # structure, see doc/tree_spell_checker_api.md class TreeSpellChecker attr_reader :dictionary, :dimensions, :separator, :augment def initialize(dictionary:, separator: '/', augment: nil) @dictionary = dictionary @separator = separator @augment = augment @dimensions = parse_dimensions end def correct(input) plausibles = plausible_dimensions input return no_idea(input) if plausibles.empty? suggestions = find_suggestions input, plausibles return no_idea(input) if suggestions.empty? suggestions end private def parse_dimensions ParseDimensions.new(dictionary, separator).call end def find_suggestions(input, plausibles) states = plausibles[0].product(*plausibles[1..-1]) paths = possible_paths states leaf = input.split(separator).last ideas = find_ideas(paths, leaf) ideas.compact.flatten end def no_idea(input) return [] unless augment ::DidYouMean::SpellChecker.new(dictionary: dictionary).correct(input) end def find_ideas(paths, leaf) paths.map do \|path\| names = find_leaves(path) ideas = CorrectElement.new.call names, leaf ideas_to_paths ideas, leaf, names, path end end def ideas_to_paths(ideas, leaf, names, path) return nil if ideas.empty? return [path + separator + leaf] if names.include? leaf ideas.map { \|str\| path + separator + str } end def find_leaves(path) dictionary.map do \|str\| next unless str.include? "#{path}#{separator}" str.gsub("#{path}#{separator}", '') end.compact end def possible_paths(states) states.map do \|state\| state.join separator end end def plausible_dimensions(input) elements = input.split(separator)[0..-2] elements.each_with_index.map do \|element, i\| next if dimensions[i].nil? CorrectElement.new.call dimensions[i], element end.compact end end # parses the elements in each dimension class ParseDimensions def initialize(dictionary, separator) @dictionary = dictionary @separator = separator end def call leafless = remove_leaves dimensions = find_elements leafless dimensions.map do \|elements\| elements.to_set.to_a end end private def remove_leaves dictionary.map do \|a\| elements = a.split(separator) elements[0..-2] end.to_set.to_a end def find_elements(leafless) max_elements = leafless.map(&:size).max dimensions = Array.new(max_elements) { [] } (0...max_elements).each do \|i\| leafless.each do \|elements\| dimensions[i] << elements[i] unless elements[i].nil? end end dimensions end attr_reader :dictionary, :separator end # identifies the elements close to element class CorrectElement def initialize end def call(names, element) return names if names.size == 1 str = normalize element return [str] if names.include? str checker = ::DidYouMean::SpellChecker.new(dictionary: names) checker.correct(str) end private def normalize(leaf) str = leaf.dup str.downcase! return str unless str.include? '@' str.tr!('@', ' ') end end end Back

Edit File : tree_spell_checker.rb | Size : 3.38 KB

module DidYouMean
  # spell checker for a dictionary that has a tree
  # structure, see doc/tree_spell_checker_api.md
  class TreeSpellChecker
    attr_reader :dictionary, :dimensions, :separator, :augment

def initialize(dictionary:, separator: '/', augment: nil)
      @dictionary = dictionary
      @separator = separator
      @augment = augment
      @dimensions = parse_dimensions
    end

def correct(input)
      plausibles = plausible_dimensions input
      return no_idea(input) if plausibles.empty?
      suggestions = find_suggestions input, plausibles
      return no_idea(input) if suggestions.empty?
      suggestions
    end

private

def parse_dimensions
      ParseDimensions.new(dictionary, separator).call
    end

def find_suggestions(input, plausibles)
      states = plausibles[0].product(*plausibles[1..-1])
      paths = possible_paths states
      leaf = input.split(separator).last
      ideas = find_ideas(paths, leaf)
      ideas.compact.flatten
    end

def no_idea(input)
      return [] unless augment
      ::DidYouMean::SpellChecker.new(dictionary: dictionary).correct(input)
    end

def find_ideas(paths, leaf)
      paths.map do |path|
        names = find_leaves(path)
        ideas = CorrectElement.new.call names, leaf
        ideas_to_paths ideas, leaf, names, path
      end
    end

def ideas_to_paths(ideas, leaf, names, path)
      return nil if ideas.empty?
      return [path + separator + leaf] if names.include? leaf
      ideas.map { |str| path + separator + str }
    end

def find_leaves(path)
      dictionary.map do |str|
        next unless str.include? "#{path}#{separator}"
        str.gsub("#{path}#{separator}", '')
      end.compact
    end

def possible_paths(states)
      states.map do |state|
        state.join separator
      end
    end

def plausible_dimensions(input)
      elements = input.split(separator)[0..-2]
      elements.each_with_index.map do |element, i|
        next if dimensions[i].nil?
        CorrectElement.new.call dimensions[i], element
      end.compact
    end
  end

# parses the elements in each dimension
  class ParseDimensions
    def initialize(dictionary, separator)
      @dictionary = dictionary
      @separator = separator
    end

def call
      leafless = remove_leaves
      dimensions = find_elements leafless
      dimensions.map do |elements|
        elements.to_set.to_a
      end
    end

private

def remove_leaves
      dictionary.map do |a|
        elements = a.split(separator)
        elements[0..-2]
      end.to_set.to_a
    end

def find_elements(leafless)
      max_elements = leafless.map(&:size).max
      dimensions = Array.new(max_elements) { [] }
      (0...max_elements).each do |i|
        leafless.each do |elements|
          dimensions[i] << elements[i] unless elements[i].nil?
        end
      end
      dimensions
    end

attr_reader :dictionary, :separator
  end

# identifies the elements close to element
  class CorrectElement
    def initialize
    end

def call(names, element)
      return names if names.size == 1
      str = normalize element
      return [str] if names.include? str
      checker = ::DidYouMean::SpellChecker.new(dictionary: names)
      checker.correct(str)
    end

private

def normalize(leaf)
      str = leaf.dup
      str.downcase!
      return str unless str.include? '@'
      str.tr!('@', '  ')
    end
  end
end

Back