Come implementare un plugin, che modifica il modulo originale solo quando richiesto?

Question

Ho un plugin che estende un modulo originale.
Dovrebbe solo modificare il modulo, quando richiesto esplicitamente.

Problema:
Non appena richiesto una volta, il modulo originale viene modificato per sempre, anche nei casi in cui il plug-in non è una dipendenza.
L'ordine non importa qui, è sufficiente richiedere il plugin una volta.

Esempio:

define("main", [], function() { 
    return {opt: "A"}; 
}); 
define("plugin", ["main"], function(obj) { 
    obj.opt = "B"; 
}); 
require(["main", "plugin"], function(obj) { 
    console.log(obj.opt); // should log B 
}); 
require(["main"], function(obj) { 
    console.log(obj.opt); // should log A but logs B 
}); 

Credo che la strada da percorrere è quello di dire in qualche modo bisogno di ricaricare sempre main dalla fonte invece di utilizzare la versione memorizzata nella cache.
Non ho idea di come, però.
O forse c'è un modo ancora più elegante?

Per favore illuminami, ragazzi.

Fiddle: http://jsfiddle.net/r75e446f

UPDATE: Alcuni potrebbero trovare importante sapere che ho bisogno di questo per il mio ambiente di test di unità karma per testare un modulo con e senza il plugin.

UPDATE2: Cerca di seguito la mia soluzione.

Answer 1

Così ho trovato il modo di realizzare, quello che voglio e ho pensato di condividere qui.

La risposta è denominata "contesto", che è un'opzione nella configurazione requirejs.

http://requirejs.org/docs/api.html#multiversion

Ecco come ho implementato la mia soluzione:

var reqOne = require.config({ 
    context: 'one' 
}); 
var reqTwo = require.config({ 
    context: 'two' 
}); 
reqOne(["main", "plugin"], function(obj) { 
    console.log(obj.opt); // logs B 
}); 
reqTwo(["main"], function(obj) { 
    console.log(obj.opt); // logs A 
}); 

Purtroppo questo non funziona in the fiddle, perché il secondo richiede cercherà di caricare il modulo principale esterno e non riesco a caricare file per jsfiddle.

Ma il solo fatto che provi a farlo senza utilizzare il modulo "principale" già caricato nell'altro richiede, dovrebbe essere la prova che il suo metodo funziona.
Se le definizioni sono esternalizzate in file singoli, questo funziona come un incantesimo.

Grazie per tutti coloro che intervenne.

Answer 2

I moduli RequireJS sono singleton. Se carichi main una, due, dieci volte, otterrai sempre lo stesso modulo. Quindi se modifichi il suo stato, viene modificato per tutti i moduli che lo utilizzano. È possibile dire a RequireJS di non definire il modulo, ma io non lo consiglio poiché renderà il tuo codice oscuro.

Se volevo fare ciò che si sta cercando di fare mi piacerebbe progettare il mio codice di qualcosa di simile:

<script> 
    define("main", [], function() { 
     function Main (opt) { 
      this.opt = opt; 
     } 
     return Main; 
    }); 
    define("plugin1", [], function() { 
     return { 
      install: function (main) { 
       main.opt += " plugin1"; 
      } 
     }; 
    }); 
    define("plugin2", [], function() { 
     return { 
      install: function (main) { 
       main.opt += " plugin2"; 
      } 
     }; 
    }); 
    // Case 1: no plugins 
    require(["main"], function(Main) { 
     var main = new Main("A"); 
     console.log(main.opt); 
    }); 
    // Case 2: only plugin1 
    require(["plugin1", "main"], function (plugin1, Main) { 
     var main = new Main("A"); 
     plugin1.install(main); 
     console.log(main.opt); 
    }); 
    // Case 3: only plugin2 
    require(["plugin2", "main"], function (plugin2, Main) { 
     var main = new Main("A"); 
     plugin2.install(main); 
     console.log(main.opt); 
    }); 
    // Case 4: plugin1 and plugin2 
    require(["plugin1", "plugin2", "main"], function (plugin1, plugin2, 
                Main) { 
     var main = new Main("A"); 
     plugin1.install(main); 
     plugin2.install(main); 
     console.log(main.opt); 
    }); 

In sostanza, fare ciò che è comune a tutti i casi una classe Main che può essere inizializzato in costruzione e che possono essere modificati dai plugin. Quindi ciascun plugin può installarsi su Main. Il codice sopra è un'illustrazione minima di come potrebbe essere fatto. In un progetto reale, la soluzione finale dovrebbe essere progettata per tenere conto delle esigenze specifiche del progetto.

Answer 3

Vorrei sollevare la mia comprensione per la discussione .. quando AMD, definiamo lo module. A meno che il modulo (in questo caso è main, la fonte definita) sia in grado di accettare lo plugin e consentire al plug-in di modificare le proprietà, suppongo che non siamo in grado di dirottarlo o che sarà un anti-pattern?

che dire estendiamo/clonare la fonte definita, come

define("plugin", ["main"], function(obj) { 
    return $.extend(true, {}, obj, {opt: "B"}); 
}); 

http://jsfiddle.net/r75e446f/6/

qui il modulo plugin è sempre usando il modulo main come la sua dipendenza, poi, quando si utilizza il modulo usiamo direttamente il modulo plugin e non è più necessario richiedere il modulo main? (A proposito ho capito questa sconfitta la definizione di 'plug-in', ma il mio senso è che abbiamo a che fare con la module come quello che le requireJs progettati per essere)

--2nd approach--

se si vuole davvero farlo in modo plug-in, per quanto riguarda lo loader plugin? come il plugin text usiamo sempre `require ('text! abc.json'). Quindi scrivi un loader e registralo nella configurazione di requireJs, e poi potremmo usarlo. (more)

Answer 4

Se non si desidera modificare il modulo originale per tutti i moduli che lo utilizzano, il proprio plug-in non dovrebbe modificare il modulo originale. Invece, fai in modo che il plugin restituisca una copia modificata del modulo originale.

define("main", [], function() { 
    return {opt: "A"}; 
}); 
define("plugin", ["main"], function(obj) { 
    var decorator = {} 
    for (var key in obj) { decorator[key] = obj[key];} 
    decorator.opt = "B"; 
    return decorator 
}); 
require(["main", "plugin"], function(obj, plugin) { 
    console.log(plugin.opt); // should log B 
}); 
require(["main"], function(obj) { 
    console.log(obj.opt); // should log A but logs B 
}); 

Questo funziona senza complicazioni se l'oggetto originale è un semplice oggetto struct simile, senza alcuna funzione. Se ci sono funzioni, o se il tuo oggetto originale è stato costruito usando il Pattern del modulo, allora c'è una forte possibilità di errori sottili nella copia, a seconda di come sono stati definiti i metodi.

EDIT 2015-01-13: Il PO ha chiarito la sua domanda che gli piacerebbe che i suoi test fossero in grado di eseguire sia il modulo originale modificato che quello non modificato senza dover ricaricare la pagina. In tal caso, consiglierei di utilizzare require.undef per scaricare il modulo principale e ricaricarlo senza dover ricaricare l'intera pagina.

Answer 5

Una soluzione più elegante sarebbe quella di adottare un approccio orientato agli oggetti, dove:

1. moduli ritorno costruttori anziché istanze, e
2. plugin può quindi essere una sottoclasse di main.

Questa è l'implementazione (fiddle):

console.clear(); 
define("Main", [], function() { 
    return function() { this.opt = "A"; }; 
}); 
define("Plugin", ["Main"], function(Main) { 
    return function() { 
     Main.call(this); 
     this.opt = "B"; 
    }; 
}); 
require(["Plugin"], function(Plugin) { 
    console.log((new Plugin()).opt); // should log B 
}); 
require(["Main"], function(Main) { 
    console.log((new Main()).opt); // should log A 
});