Declarar una clase dentro de un módulo

Question

Código de trabajo de topografía (en un módulo llamado Surveyor, no menos), tratando de comprenderlo. Me encontré con esta sección que contiene una clase dentro de un módulo. ¿Es esto lo mismo que incluir el módulo? Si no, ¿cuál es la ventaja de hacerlo de esta manera? Gracias. (Puntos de bonificación: ¿Por qué estamos anexando a la clase de auto, es que no está ya implícita?)

module Surveyor 
    class Common 
    RAND_CHARS = [('a'..'z'), ('A'..'Z'), (0..9)].map{|r| r.to_a}.flatten.join 
    OPERATORS = %w(== != < > <= >= =~) 

    class << self 
     def make_tiny_code(len = 10) 
     if RUBY_VERSION < "1.8.7" 
      (1..len).to_a.map{|i| RAND_CHARS[rand(RAND_CHARS.size), 1] }.join 
     else 
      len.times.map{|i| RAND_CHARS[rand(RAND_CHARS.size), 1] }.join 
     end 
     end 

     def to_normalized_string(text) 
     words_to_omit = %w(a be but has have in is it of on or the to when) 
     col_text = text.to_s.gsub(/(<[^>]*>)|\n|\t/su, ' ') # Remove html tags 
     col_text.downcase!       # Remove capitalization 
     col_text.gsub!(/\"|\'/u, '')     # Remove potential problem characters 
     col_text.gsub!(/\(.*?\)/u,'')     # Remove text inside parens 
     col_text.gsub!(/\W/u, ' ')      # Remove all other non-word characters  
     cols = (col_text.split(' ') - words_to_omit) 
     (cols.size > 5 ? cols[-5..-1] : cols).join("_") 
     end 

     def equal_json_excluding_wildcards(a,b) 
     return false if a.nil? or b.nil? 
     a = a.is_a?(String) ? JSON.load(a) : JSON.load(a.to_json) 
     b = b.is_a?(String) ? JSON.load(b) : JSON.load(b.to_json) 
     deep_compare_excluding_wildcards(a,b) 
     end 
     def deep_compare_excluding_wildcards(a,b) 
     return false if a.class != b.class 
     if a.is_a?(Hash) 
      return false if a.size != b.size 
      a.each do |k,v| 
      return false if deep_compare_excluding_wildcards(v,b[k]) == false 
      end 
     elsif a.is_a?(Array) 
      return false if a.size != b.size 
      a.each_with_index{|e,i| return false if deep_compare_excluding_wildcards(e,b[i]) == false } 
     else 
      return (a == "*") || (b == "*") || (a == b) 
     end 
     true 
     end 

     alias :normalize :to_normalized_string 

     def generate_api_id 
     UUIDTools::UUID.random_create.to_s 
     end 
    end 
    end 
end 

Answer 1

cuál es la ventaja de hacerlo de esta manera?

Por lo tanto, las clases con el mismo nombre no se clasifican (por lo que no tiene nada que ver con mixins). Es estándar.

¿Por qué nos agregamos a la clase, eso no está ya implícito?

Esa es solo una de las formas de defining class-methods (la otra es def self.method_name).

Answer 2

¿Es esto lo mismo que incluir el módulo?

No. Cuando usted tiene module Foo; end y luego hacer

class Bar 
    include Foo 
end 

Se termina con una clase Bar que incluye todos los métodos del módulo Foo. Pero cuando hacemos

module Foo 
    class Bar 
    end 
end 

Terminamos con una clase Foo::Bar que incluye ninguno de los métodos de Foo que no están en Bar

¿Cuál es la ventaja de hacerlo de esta manera?

Le permite organizar su código, si es necesario.

¿Por qué nos agregamos a la clase, eso no está ya implícito?

No, no es ya "implied". Hacerlo equivale a definir cada método en ese bloque con self. como def self.mymethod; end. Ver class << self idiom in Ruby.