Dichiarazione di una classe all'interno di un modulo

Question

Rilevamento del codice di lavoro (in un modulo chiamato Surveyor, non meno), cercando di capirlo. Ho incontrato questa sezione che contiene una classe all'interno di un modulo. È lo stesso che include il modulo? In caso contrario, qual è il vantaggio di farlo in questo modo? Grazie. (PUNTI BONUS: Perché stiamo aggiungendo sé in classe, è che non è già implicita?)

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

qual è il vantaggio di fare in questo modo?

Serve come namespace quindi le classi con lo stesso nome non si scontrano (quindi non ha nulla a che fare con i mixin). È standard.

Perché l'aggiunta di auto in classe non è già implicita?

Questo è solo uno dei modi di defining class-methods (l'altro è def self.method_name).

Answer 2

È lo stesso di includere il modulo?

No. Quando si dispone di module Foo; end e poi fare

class Bar 
    include Foo 
end 

Si finisce con una classe Bar che comprende tutti i metodi del modulo Foo. Ma quando lo facciamo

module Foo 
    class Bar 
    end 
end 

Finiamo con una classe Foo::Bar che include nessuno dei metodi in Foo che non sono in Bar

Qual è il vantaggio di fare in questo modo?

Consente di organizzare il codice, se necessario.

Perché l'aggiunta di auto in classe non è già implicita?

No, non è già "implicito". Ciò equivale a definire ciascun metodo in quel blocco con self. come def self.mymethod; end. Vedi class << self idiom in Ruby.