Qual è il modo preferito (migliore stile) per nominare un namespace in Ruby? Singolare o Plurale?

Question

Quali sono per voi i pro ei contro di utilizzare:

FooLib::Plugins 
FooLib::Plugins::Bar 

convegni vs.

FooLib::Plugin 
FooLib::Plugin::Bar 

di denominazione? E cosa useresti o cosa stai usando? Cosa è più comunemente usato nella comunità?

Answer 1

Per me FooLib::Plugins appare come un modulo, utilizzato come spazio dei nomi in cui sono conservate varie classi di plug-in. FooLib::Plugin sembra una superclasse per i plugin FooLib.

In FooLib::Plugins::Bar, Bar sembra decisamente il nome di un plug-in. Con FooLib::Plugin::Bar, sarei in dubbio se Bar fosse una classe di supporto utilizzata da Foo::Plugin o il nome di un plug-in.

Answer 2

Supponendo Plugin è una classe di base:

• class FooLib::Plugin::Bar < FooLib::Plugin

  Questo è quello che uso e raccomando. Bar è un Plugin in FooLibe eredita da FooLib::Plugin. Mantiene anche i plugin fornite dalla libreria FooLib nidificato sotto lo spazio dei nomi della classe generale, che si legge naturale:

  # Assign the Bar Plugin of the FooLib library to p. 
  p = FooLib::Plugin::Bar 
  

  Se dovessi sviluppare un terzo plug-in festa per la vostra biblioteca, vorrei creare la seguente struttura:

  # Baz is a Plugin for the FooLib library provided by BarLib. 
  class BarLib::FooLib::Plugin::Baz < ::FooLib::Plugin 
  

  nota che mi specchio della gerarchia FooLib, ma sotto namespace BarLib s'. Non lo estenderei direttamente.

• class FooLib::Plugins::Bar < FooLib::Plugin

  ho usato anche questo, e penso che rende più senso. Bar estende FooLib::Plugin ed è uno dei Plugins fornito da FooLib. Tuttavia, crea un modulo potenzialmente inutile.

  Penso che questo sarebbe una grande scelta se Plugins è stato un plugin repository centrale che implementa metodi come Plugins.add, Plugins.all e Plugins.loaded.

  Utilizzarlo se è possibile giustificare il modulo aggiuntivo.

• class FooLib::Plugins::Bar < FooLib::Plugins

  non fa un sacco di senso per me. Bar è uno dei in FooLib, quella parte sembra soddisfacente. Tuttavia, eredita da Plugins. Sta ereditando da più di un plugin? Mi sembra strano; il nome della classe non dovrebbe suggerire qualcosa che è impossibile.

Answer 3

In generale, l'approccio tendo a prendere è:

module Foo 
    module Plugin 
    class Base; end 
    end 
end 

class Foo::Plugin::Bar < Foo::Plugin::Base; end 

La classe Base per i plugin è una convenzione trova in tutto il posto in RubyOnRails codice di base, così come molti altri. (Ad esempio ActiveRecord::Base, ActionController::Base, etc.)

sono d'accordo con l'approccio di @Matheus Moreira dove Foo::Plugin viene utilizzato sia come classe base e lo spazio dei nomi per i plugin.

L'unica ragione funzionale per cui questo non dovrebbe essere fatto ha a che fare con la convenzione: nella comunità di Ruby si trovano molte meno istanze di classi come spazi dei nomi rispetto ai moduli. L'unica volta che vedo le classi utilizzate come spazio dei nomi per un'altra classe è quando lo scopo di detta classe è privato della classe namespace e non viene usato esternamente.

Answer 4

Usa:

module FooLib end 
module FooLib::Plugins end 
class FooLib::Plugins::Plugin; end #the base for plugins 
class FooLib::Plugins::Bar < FooLib::Plugins::Plugin; end 
class FooLib::Plugins::Bar2 < FooLib::Plugins::Plugin; end 

o in parole diverse:

module FooLib 
    module Plugins 
    class Plugin; end #the base for plugins 
    class Bar < Plugin; end 
    class Bar2 < Plugin; end 
    end 
end 

anche organizzare i file in questo modo:

- foo_lib/ 
    - plugins/ 
    - plugin.rb 
    - bar.rb 
    - bar2.rb 

Questo è how Rails does it (quindi questo è il Rails Way). Cioè guarda lo spazio dei nomi Associazioni e lo Associations::Association class da cui ereditano tutte le classi che formano lo spazio dei nomi Associazioni (ad esempio Associations::SingularAssociation).

Answer 5

Vorrei secondo l'approccio delineato da @jtrim.

Dato che il modulo (ossia plugin) viene usata per namespacing solo, ho tipicamente override del nuovo metodo nel modulo:

module Foo 
    module Plugin 

    def self.included(base) 
     raise "cannot be included" 
    end 

    def self.extended(base) 
     raise "cannot extend" 
    end 

    def self.new(*args) 
     Base.new(*args) 
    end 

    class Base;end 
    end 
end 


base_plugin_obj = Foo::Plugin.new(...)