mozilla
Los resultados de tu búsqueda

    Preguntas frecuentes sobre RDF en Mozilla

    Imagen:traduccion-pendiente.png Esta página está traduciéndose a partir del artículo RDF in Mozilla FAQ, razón por la cual puede haber algunos errores sintácticos o partes sin traducir. Puedes colaborar continuando con la traducción

    General

    ¿Por dónde empiezo?

    RDF cumple dos objetivos primarios en Mozilla.

    • El primero, es una simple base de datos en cruz para guardar una pequeña cantidad de datos.
    • El segundo, el más importante, es el modelo RDF que se utiliza junto a XUL plantillas, un "API" abstracto para mostrar información.

    RDF en cincuenta palabras o menos es una rápida y muy buena descripción de qué hace RDF en Mozilla.

    El documento RDF Arquitectura final describe con muchos más detalles como trabaja la conexión Mozilla y RDF, y da una explicación de los interfaces implicados.

    Donde puedo encontrar información sobre Open Directory ("dmoz")?

    Aquí no, desafortunadamente. Bien, aquí hay un poco... Debes empezar en http://www.dmoz.org/ para mas información acerca de Open Directory. El set de datos Open Directory está disponible como un, enorme, depósito RDF/XML. Describe miles de sitios Web que usan un mix de vocabulario de Dublin Core y de la "taxonomía" DMoz. Para más información mira sus páginas RDF, o los anuncios odp-rdf para actualizaciones relacionados con su formato de datos exacto. El sitio ChefMoz también esta disponible en RDF.

    Si tienes problemas con los datos DMoz y ChefMoz, será mejor que contactes directamente esos proyectos. Pero si haces algo interesante con los contenidos (ej. cargando pedazos de los datos desde un sitio remoto hacia una interface de usuario XUL), no olvides hacerlo saber a las listas de mozilla-rdf y RDF Interest Group. Estas listas también estarán interesadas en herramientas para limpieza / re-procesamiento y almacenaje de datos DMoz. Para algunos directorios basados en ODP RDF puedes mirar las páginas de los sitios que usan ODP Data.

    Qué es un datasource?

    Generalmente, RDF puede ser visto desde dos puntos de vista: Como un gráfico con nodos y arcos, o como una sopa de declaraciones lógicas. Un datasource es un subgráfico (o coleccíon de declaraciones, dependiendo de tu punto de vista) que por alguna razón están recolectadas todas juntas. Los ejemplos de datasources que existen hoy en día son "marcadores de browser", "historial de navegación", "cuentas de correo IMAP", "servidores de noticia NNTP", y "archivos RDF/XML".

    En Mozilla, las datasources pueden unirse usando composite data source. Es como superponer gráficos, o unir una colección de declaraciones ("microteorías"). Las declaraciones acerca de del mismo recurso RDF pueden ser mezcladas. Por ejemplo, "la última fecha de visita" de un sitio en particular proviene del historial de navegación, y el "atajo de teclado" que puedes usar para ese sitio proviene de los marcadores. Ambos datasources refieren al website a través del URL, esta es la "clave" que permite que el datasource sea mezclado con efectividad.

    Para mas información acerca de como escribir un datasource por favor remitete a RDF Datasource How-To.

    Cómo administra los datasource Mozilla?

    El RDF service administra una tabla con todos los datasources cargados. A la tabla se le asigna una URI, que es algo asi como la URL del archivo RDF/XML, o una URI "especial" que empieza con rdf que hace referencia a un datasource Built-in.

    Los datasources se pueden cargar a traves del servicio RDF, utilizando el método GetDataSource(). Si el argumento URI hace referencia a la URL de un archivo RDF/XML, entonces el servicio creará un datasource RDF. El datasource permanecerá "capturado" hasta que la última referencia al datasource sea liberada. Si el argumento URI hace referencia a un datasource Built-in, el servicio RDF utilizará el administrador de componentes XPCOM para cargar el componente cuya ContractID ha sido hecha utilizando la URI "especial" y el bien conocido prefijo@mozilla.org/rdf/datasource;1?name=.

    Por ejemplo:


    rdf:foo
    

    que cargará:

    @mozilla.org/rdf/datasource;1?name=foo
    

    Igual que los datasources RDF/XML, un datasource que es respondida de esta manera, será "capturada" por el servicio RDF hasta que la última referencia es soltada.

    Cómo creo datasources desde un archivo RDF/XML?

    Puedes crear un datasource RDF/XML usando el método GetDataSource() del servicio RDF:

    // Obten el servicio RDF
    var RDF =
      Components
      .classes["@mozilla.org/rdf/rdf-service;1"]
      .getService(Components.interfaces.nsIRDFService);
    // ...y desde allí, Obten el datasource. Aségurat de que el servidor web lo entregue como
    // text/xml (recomendado) o como text/rdf!
    var ds = RDF.GetDataSource("http://www.mozilla.org/some-rdf-file.rdf");
    // NOTA que  ds será cargado desincronizadamente, asi que los aciertos no serán
    // inmediatos
    

    O puedes crear uno utilizando el administrador de componentes XPCOM directamente, Aquí hay un ejemplo.

    // Crear un archivo RDF/XML usando el administrador de componentes XPCOM
    var ds =
      Components
      .classes["@mozilla.org/rdf/datasource;1?name=xml-datasource"]
      .createInstance(Components.interfaces.nsIRDFDataSource);
    // La interface nsIRDFRemoteDataSource tiene las interfaces
    // que necesitamos para configurar el datasource.
    var remote =
       ds.QueryInterface(Components.interfaces.nsIRDFRemoteDataSource);
    // Asegúrate de que el servidor entregue esto como text/xml (recomendado) o como text/rdf!
    remote.Init("http://www.mozilla.org/some-rdf-file.rdf");
    // Cárgalo! fijate que esto ocurrira desicronizadamente. Configura
    // aBlocking a true, podemos forzarlo pra que sea sincronizado pero
    // generalmente es una mala idea, porque se bloqueará tu interface de usuario!
    remote.Refresh(false);
    // NOTA queds será cargado desincronizadamente, los aciertos no 
    // serán inmediatos
    

    Si deseas que se cargue de forma sincronizada, deberías crearlo manualmente.

    Cómo actualizo un datasource RDF/XML?

    Puedes forzar un datasource RDF/XML (o cualquier datasource que soporte nsIRDFRemoteDataSource) utilizando el método Refresh()de nsIRDFRemoteDataSource. Refresh() tiene un solo parámetro que indica si te gustaría realizar la operacíon sincronizadamente ("blocking") o desincronizadamente ("non-blocking"). Nunca lo hagas sincronizadamente, a menos que sepas lo que estás haciendo, esta opción bloqueará la interfaz de usuario hasta que la carga sea completada.

    Cómo sé si un datasource RDF/XML se cargó?

    Es posible consultar la propiedad loaded utilizando la interfaz nsIRDFRemoteDataSource para determinar si el datasource está cargado o no.


    // Obtén el servicio RDF
    var RDF =
      Components
      .classes["@mozilla.org/rdf/rdf-service;1"]
      .getService(Components.interfaces.nsIRDFService);
    // Obtén el datasource.
    var ds = RDF.GetDataSource("http://www.mozilla.org/some-rdf-file.rdf");
    // Ahora mira si se cargó o no...
    var remote =
      ds.QueryInterface(Components.interfaces.nsIRDFRemoteDataSource);
    
    if (remote.loaded) {
      alert("El datasource ya está cargado!");
    }
    else {
      alert("El datasource no se cargó, pero se está cargando ahora!");
    }
    

    Digamos que el datasource no está cargado, y se está cargando desincronizadamente. Podríamos usar esta API y el setTimeout() de JavaScript para realizar un loop que chequee la propiedad loaded de forma continua. Sería malo no detectar una carga fallida, por ejemplo, que no hubiera ningun dato en le URL.

    Por esta razón, hay una interfaz observadora que te permite espiar el progreso del datasource. El siguiente código ilustra como usarlo.


    // Este es el objeto que observará el progreso de RDF/XML
    var Observer = {
      onBeginLoad: function(aSink)
        {},
    
      onInterrupt: function(aSink)
        {},
    
      onResume: function(aSink)
        {},
    
      onEndLoad: function(aSink)
        { alert("done!"); },
    
      onError: function(aSink, aStatus, aErrorMsg)
        { alert("error! " + aErrorMsg); }
    };
    // obtén el servicio RDF
    var RDF =
      Components
      .classes["@mozilla.org/rdf/rdf-service;1"]
      .getService(Components.interfaces.nsIRDFService);
    // Obtén el datasource.
    var ds = RDF.GetDataSource("http://www.mozilla.org/some-rdf-file.rdf");
    // ahora mira si se cargó o no...
    var remote =
      ds.QueryInterface(Components.interfaces.nsIRDFRemoteDataSource);
    
    if (remote.loaded) {
      alert("El datasource ya está cargado!");
    }
    else {
      alert("El datasource no se cargó, pero se está cargando  ahora!");
      // los datasources RDF/XML son nsIRDFXMLSinks
      var sink =
        ds.QueryInterface(Components.interfaces.nsIRDFXMLSink);
      // Adjunta el observador al  datasource
      sink.addXMLSinkObserver(Observer);
      // ahora serán llamados del métodos del  Observador como
      // los progresos de carga.
    }
    


    Nota que el observador permanecerá unido al datasource RDF/XML a menos que llamemos a XMLSinkObserver

    Cómo accedo a la información de un datasource?

    La interfaz nsIRDFDataSource es lo que te permitirá acceder y manipular las declaraciones en un datasource.

    • boolean HasAssertion(aSource, aProperty, aTarget, aTruthValue).
      This tests the datasource to see if it has the specified tuple.
    • nsIRDFNode GetTarget(aSource, aProperty, aTruthValue).
    • nsISimpleEnumerator GetTargets(aSource, aProperty, aTruthValue).
    • nsIRDFResource GetSource(aProperty, aTarget, aTruthValue).
    • nsISimpleEnumerator GetSoruces(aProperty, aTarget, aTruthValue).
    • nsISimpleEnumerator ArcLabelsIn(aTarget).
    • nsISimpleEnumerator ArcLabelsOut(aSource).

    También puedes usar la interfaz RDF container para acceder a la información contenida en contenedores RDF.

    Cómo cambio información en un datasource?

    Usa "Assert" para agregar una declaración y "Unassert" para quitar una. Mira Mozilla RDF Back end Architecture

    ds.Assert(homepage, FV_quality, value, true);
    ds.Unassert(homepage, FV_quality, value, true);
    

    Cómo guardo los cambios en un datasource?

    Se puede hacer QueryInterface a nsIRDFRemoteDataSource con un datasource. Esta interfaz tiene un método Flush() que re-escribe los contenidos de un datasource nuevamente hacia la URL desde donde fueron cargados. Usando un mecanismo de protocolo específico (ej. un file: URL simplemente escribe el archivo, un http: URL probablemente hará un HTTP-POST). Flush() sólo escribe el datasource si el contenido ha cambiado.

    Cómo úno varios datasource para verlos cómo uno solo?

    Utiliza nsIRDFCompositeDataSource. Esta interfaz proviene de nsIRDFDataSource. Implementar esta interfaz combinará las declaraciones de distintos datasources dentro de uno colectivo. Como la interfaz nsIRDFCompositeDataSource proviene de nsIRDFDataSource, puede ser llamada y modificada igual que un data source.

    Cómo accedo a datasources "built-in"?

    Un datasource buitl-in es un componente localmente-instalado que implementa nsIRDFDataSource. Por ejemplo, el servicio de marcadores. Primero, asegúrate de que eres capaz de acceder a un datasource haciendo click aquí. Hay grandes restricciones de seguridad para acceder a un datasource desde un XUL o JS "desconocido".

    Como el datasource built-in es nada mas que un componente XPCOM, puedes acceder utilizando el componente administrador XPConnect.

    // Usa el administrador de componentes para obtener los // marcadores
    var bookmarks =
      Components.
      classes["@mozilla.org/rdf/datasource;1?name=bookmarks"].
      getService(Components.interfaces.nsIRDFDataSource);
    
    // Ahora haz algo con eso...
    if (bookmarks.HasAssertion(
         RDF.GetResource("http://home.netscape.com/NC-rdf#BookmarksRoot"),
         RDF.GetResource("http://home.netscape.com/NC-rdf#child"),
         RDF.GetResource("http://home.netscape.com/NC-rdf#PersonalToolbarFolder"),
         true) {
      // ...
    }
    

    Algunos datasources tienen ContractID "especiales" que hacen más fácil el acceso utilizando el método GetDataSource() de nsIRDFSerivce o el atributo datasource de una plantilla XUL. Estos ContractID son de:

    @mozilla.org/rdf/datasource;1?name=name
    

    Y son accesibles via GetDataSource y el atributo datasources usando rdf:name. Por ejemplo, el siguiente fragmento XUL muestra como colocar el servicio de marcadores dentro de una plantilla XUL.

    <tree datasources="rdf:bookmarks">
      ...
    </tree>
    

    Cómo manipulo "contenedores" RDF?

    Para manipular un "contenedor" RDF (un <rdf:SEq>, por ejemplo) puedes utilizar nsIRDFContainerUtils la cual puede ser llamada como un servicio a tráves del siguiente ContratID:

    @mozilla.org/rdf/container-utils;1
    

    Puedes usarlo para detectar si algo es un contenedor RDF utilizando IsSeq(), IsBag(), IsAlt(). Puedes "crear un recurso dentro de un contenedor", sino hubiera uno, utilizando MakeSeq(), MakeBag(), MakeAlt(). Estos métodos devuelven nsIRDFContainer que te permitirá hacer operaciones tipo-contenedor sin ensuciarte las manos.

    Si tu datasource ya posee un objeto que es un contenedor RDF, puedes usar el objeto nsIRDFContainer con:

    @mozilla.org/rdf/container;1
    

    Utiliza COntractID y Init() con el datasource y el recurso como parámetros. Nota que esto fallará si el recurso todavia no es un contenedor.

    Plantillas XUL

    Las plantillas XUL se crean especificando un atributo datsource sobre un elemento en un documento XUL.

    Hay dos "formas" de escribir plantillas XUL. La "simple", que es la mas comun en Mozilla, y la "extendida", que pertime mayor concordancia contra gráficos RDF. Mira también XUL:Template Guide (está ordenado de forma bizarra porque se intenta introducir primero la forma extendida, y luego la forma simple como una especie de simplificación de la forma extendida).

    ¿Qué puedo construir con una plantilla XUL?

    Puedes construir cualquier clase de contenido usando una plantilla XUL. Puedes utilizar cualquier clase de etiqueta (incluso HTML o XML arbitrario) en la parte <action> de un <rule>.

    Cuándo debo utilizar una plantilla XUL?

    Una alternativa al uso de plantillas RDF y XUL es el uso de W3C DOM APIs, para crear y manipular modelos de contenido XUL (o HTML). Sin embargo, algunas veces suelen presentarse algunos incovenientes:

    1. hay distintas </em>"vistas" de los datos</em>. Por ejemplo, Mozilla mail/news muestra la jerarquía de carpeta en la barra de herramientas, varios menues, y en algunas ventana de diálogo. Mejor que escribir tres pedazos de código JS (o C++) para construir los árboles DOM, uno para cada modelo de contenido, <menubutton>, <menu> y <tree>, seria que escribas tres sets compactos de reglas.
    2. Los datos pueden cambiar. Por ejemplo un usuario de mail/news tal vez agregue o quite carpetas IMAP (nota como estos requerimientos complican la construcción de modelos de contenido) La plantila de construcción XUL utiliza reglas para mantener sincronizados, de forma automática, todos los modelos de contenidos acorde a tus cambios.

    Para poder tener la ventaja de estas funciones, debes ser capaz de expresar tu información en términos de RDF datasource API ya sea usando el built-in memory datasource, usando RDF/XUL para almacenar tu información, o escribiendo tu propia implementación de nsIRDFDataSource

    Qué es lo que se carga cuando especifico "datasource=" ?

    En el "root" de una plantilla, el atributo datasources especifica que se debe cargar una lista de URIs datasource que están separadas por un espacio en blanco. Pero, qué es una "URI datasource"? Puede ser:

    • Un ContractID abreviado para un componente instalado localmente. Especificando rdf:nombre le indicas al generador de la plantilla que cargue el componente XPCOM con el ContractID: @mozilla.org/rdf/datasource;1?name=nombre
    • La URL de un archivo RDF/XML. Por ejemplo,
      file:///tmp/foo.rdf
      chrome://mycomponent/content/component-data.rdf
      http://www.mysite.com/generate-rdf.cgi
      ftp://ftp.somewhere.org/toc.rdf
      

      La carga será procesada desincronizadamente, y a medida que vaya llegando RDF/XML, el generador de la plantilla irá generando contenido.

    En ambos casos, los datasources se cargan usando el método GetDataSource() de nsIRDFService asi que será manejado de igual manera para todos los datasources que asi se carguen.

    Cuál es el modelo de seguridad para RDF/XML en XUL?

    El documento XUL que es cargado de una URL "confiable" (cualquier chrome: URL) puede especificar cualquier URI datasource en el atributo datasources de la plantilla XUL.

    El documento que es cargado desde una URL "no confiable", puede especificar solo un documento RDF/XML desde el mismo codebase (en el significado de Java) donde se origino el documento XUL. Los datasources que no son "especiales" (ej. rdf:) se cargarán desde un XUL "no confiable".

    Cómo agrego un datasource a una plantila XUL?

    Si bien es posible crear una plantilla XUL con un conjunto de datasources "implicitos" especificando el atributo datasource, abrá veces que no sabrás que datasource cargar hasta que la XUL esté cargada. Por ejemplo, tu XUL tal vez necesite computar el datasource que se desea mostrar en un manejador onload. O, tal vez necesites agregar datasources basado en la acción de un usuario.

    <window xmlns="http://www.mozilla.org/keymaster/gat...re.is.only.xul">
      ...
      <tree id="my-tree" datasources="rdf:null">
        ...
      </tree>
      ...
    </window>
    

    Asumiendo que hemos adquirido el datasource de alguna manera (ej. así), el sig. ejemplo muestra cómo agregar un datasource a una plantila, y luego, forzar a la plantilla a reconstruirse basada en los nuevos contenidos agregados.

    var ds = /* asumimos que tienes esto! */;
    // Obten el elemento DOM para 'my-tree'
    var tree = document.getElementById('my-tree');
    // agregamos nuestro datasource
    tree.database.AddDataSource(ds);
    // Forza al arbol a reconstruirse *ahora*. debes hacerlo "manual"!
    tree.builder.rebuild();
    

    Cualquier elemento XUL con un atributo datasources "tendrá" una propiedad database y una builder. La primera refiere a un objeto nsIRDFCompositeDataSource que contiene los datasources desde donde son contruidas las plantillas.

    La segunda propiedad refiere a un objeto nsIXULTemplateBuilder que es el "generador" que mantiene el estado de los contenidos de la plantilla.

    Nota que el datasource rdf:null es un datasource especial que nos dice "hey, no tenemos un datasource todavía, pero vamos a agregar uno mas tarde, chequéalo!". Esto hace que database y builder se instalen, pero deja a database vacía de datasources, debes agregarlos tú mismo!

    Puedo manipular plantillas XUL usando las APIs DOM?

    Sí! puedes agragar, quitar reglas, cambiar las condiciones de una regla y cambiar el contenido que es generado por una regla. De hecho, puedes cambiar cualquier cosa de una plantilla usando W3C DOM APIs.

    Eso si, debes llamar a rebuild() para que los cambios hagan efecto (del mismo modo que lo haces si agregas un datasource a una plantilla XUL).

    Cómo agrego texto plano desde una plantilla?

    Para agregar texto plano desde una plantilla usa el elemento <text>.

    <template>
      <rule>
        <conditions>...</condition>
        <bindings>...</bindings>
        <action>
          <text value="?alguna-variable" />
        </action>
      </rule>
    </template>
    

    La plantilla arriba creará un modelo de contenido que ejecutará series de nodos de texto.

    Solución de problemas

    Trucos y secretos sobre el tema.

    Mi archivo RDF/XML no carga.

    La causa mas usual de este problema es un tipo de MIME incorrecto. Asegúrate que tu servidor esté enviando el archivo como text/xml (recomendado) o como text/rdf.

    Nota que W3C RDF Core WG está registrando application/rdf+xml, aunque esto no funciona con ningún código Mozilla. (tenemos algún bug registrado para rastrear esto? -- danbri)

    Otro problema posible: para XUL y RDF cargado de forma remota tal vez necesites ajustar las restricciones de seguridad de Mozilla (mira más abajo para ejemplos). Si XUL no está cargando tu RDF, y el tipo MIME está OK, tal vez este sea el problema.

    Puedes usar los utilitarios rdfcat y rdfpoll para verificar que RDF/XML son válidos. Estos programas son generados en Windows por defecto, y en Linux cuando especificas configure --enable-tests.

    • rdfcat url
      Toma como parametro una URL desde donde leerá un archivo RDF/XML, y lo enviará a la consola. Puedes usarlo para verificar que Mozilla ejecuta adecuadamente el RDF/XML hayas escrito.
    • rdfpoll url [interval]
      Toma como parámetro una URL desde donde leerá un archivo RDF/XML. Támbien ecepta un intervalo donde actualizará la URL. NOta que las actualizaciones generan una series de diferencias entre los contenidos previos y posteriores del archivo RDF/XML. Esto es útil para quitar errores en archivos generados que cambien con el tiempo.

    Ambos programas son lentos para cargar y ejecutarse (pero se ejecutarán). Inician XPCOM y hacen que Necko pueda cargar y procesar URLs igual que lo hace Mozilla.

    No sucede nada cuando llamo AddDataSource.

    Nota que el generador de la plantilla no regenera automaticamente el contenido de una plantilla después de AddDataSource o RemoveDataSource, debe ser llamado desde database del generador. Debes llamar elt.builder.rebuild() manualmente para actualizar los contenidos de la plantilla

    Por qué? Esto se diseño para que no se produzcan múltiple re-generaciones cuando más de un datasource es agregado a la database.

    Ejemplos

    Donde puedo encontrar algunos ejemplos?

    Aquí hay algunos, son ejecutables directamente desde HTTP.

    Mira también duplicates.rdf (directo desde Mozilla) también duplicates.xul. Nota que debes alivianar el modelo de seguridad de Mozilla para que funcionen. Para hacerlo, agrega la siguiente línea al archivo de preferencias. (primero debes reiniciar Mozilla para que escriba el archivo)

    user_pref("signed.applets.codebase_principal_support", true);
    

    Te preguntará si permites a los scripts en duplicates.xul accerder XPConnect, responde que SÍ.

    Actualmente Mozilla no permite acceso a las interfaces y servicios RDF sin previlegios, mira el bug 122846 para detalles.

    Por favor comunicate via mail con danbri si crees que deberíamos colocar algún otro link

    Notas

    1. Mira también W3C RDF y Semantic Web para más información acerca de RDF y tecnologías relacionadas.

    Contribuyentes

    • Sección de ejemplos agregada por danbri el 2002-07-02 </li>
    • Gracias a Myk Melez por las notas sobre política de seguridad en XUL remoto.

    Autor: Chris Waterson

    Información sobre documento original

    Categorías

    Interwiki Language Links


    Etiquetas y colaboradores del documento

    Contributors to this page: Nukeador, Lcseba, Nathymig, Jorolo, Blank zero, Mgjbot
    Última actualización por: Mgjbot,