javascript - ¿Accediendo a los metadatos de Greasemonkey desde su script?

metadata

Question

¿Hay alguna forma en que mi script pueda recuperar los valores de metadatos que se declaran en su propio encabezado? No veo nada prometedor en la API, excepto tal vez GM_getValue() . Eso implicaría, por supuesto, una sintaxis de nombre especial. Lo he intentado, por ejemplo: GM_getValue("@name") .

La motivación aquí es evitar la especificación redundante.

Si los metadatos GM no son accesibles directamente, tal vez haya una forma de leer el cuerpo del script en sí. Ciertamente está en la memoria en alguna parte, y no sería demasiado difícil de analizar para "// @" . (Eso puede ser necesario en mi caso de cualquier forma, ya que el valor que realmente me interesa es @version , que es un valor extendido leido por userscripts.org ).

Answer 1

Sobre la base de la respuesta de Athena, aquí está mi solución generalizada que produce un objeto de pares nombre / valor, cada uno representa una propiedad de metadatos. Tenga en cuenta que ciertas propiedades pueden tener valores múltiples, (@include, @exclude, @require, @resource), por lo tanto, mi analizador las captura como matrices, o en el caso de @resource, como un objeto subordinado de pares nombre / valor.

var scriptMetadata = parseMetadata(.toString()); function parseMetadata(headerBlock) { // split up the lines, omitting those not containing "// @" function isAGmParm(element) { return ///// @/.test(element); } var lines = headerBlock.split(/[/r/n]+/).filter(isAGmParm); // initialize the result object with empty arrays for the enumerated properties var metadata = { include: [], exclude: [], require: [], resource: {} }; for each (var line in lines) { [line, name, value] = line.match(///// @(/S+)/s*(.*)/); if (metadata[name] instanceof Array) metadata[name].push(value); else if (metadata[name] instanceof Object) { [rName, rValue] = value.split(//s+/); // each resource is named metadata[name][rName] = rValue; } else metadata[name] = value; } return metadata; } // example usage GM_log("version: " + scriptMetadata["version"]); GM_log("res1: " + scriptMetadata["resource"]["res1"]);

Esto está funcionando muy bien en mis scripts.

EDITAR: Agregó @resource y @require, que se introdujeron en Greasemonkey 0.8.0.

EDITAR: compatibilidad con FF5 +, Array.filter () ya no acepta una expresión regular

Answer 2

Use el objeto GM_info , que se agregó a Greasemonkey en la versión 0.9.16.

Por ejemplo, si ejecuta este script:

// ==UserScript==
// @name            _GM_info demo
// @namespace       
// @description     Tell me more about me, me, ME!
// @include         http://.com/questions/*
// @version         8.8
// ==/UserScript==

unsafeWindow.console.clear ();
unsafeWindow.console.log (GM_info);

Saldrá este objeto:

{
    version:            (new String("0.9.18")),
    scriptWillUpdate:   false,
    script: {
        description:    "Tell me more about me, me, ME!",
        excludes:       [],
        includes:       ["http://.com/questions/*"],
        matches:        [],
        name:           "_GM_info demo",
        namespace:      "",
        ''run-at'':       "document-end",
        unwrap:         false,
        version:        "8.8"
    },
    scriptMetaStr:      "// @name            _GM_info demo/r/n// @namespace       /r/n// @description     Tell me more about me, me, ME!/r/n// @include         http://.com/questions/*/r/n// @version         8.8/r/n"
}

Answer 3

Esta respuesta está desactualizada: a partir de Greasemonkey 0.9.16 (febrero de 2012), consulte la respuesta de Brock con respecto a GM_info

Sí. Un ejemplo muy simple es:

var metadata=<> 
// ==UserScript==
// @name           Reading metadata
// @namespace      http://www.afunamatata.com/greasemonkey/
// @description    Read in metadata from the header
// @version        0.9
// @include        https://.com/questions/104568/accessing-greasemonkey-metadata-from-within-your-script
// ==/UserScript==
</>.toString();

GM_log(metadata); 

Vea este hilo en el grupo greasemonkey-users para más información. Se puede encontrar una implementación más robusta cerca del final.