| 1 |
/* $Id: README.txt,v 1.1 2006/01/25 07:10:27 dman Exp $ */ |
/* $Id: README.txt,v 1.2 2006/01/25 13:08:52 dman Exp $ */ |
| 2 |
|
|
| 3 |
Relationship Manager |
All files cleared for a D6 replacement effort |
| 4 |
|
|
|
@author - Dan Morrison <http://coders.co.nz> |
|
|
Licensed under the GPL v2.0 |
|
|
|
|
|
About |
|
|
----------------------------- |
|
|
|
|
|
The Relationship Manager module is intended to allow free-form links between |
|
|
nodes, recording not just that one page relates to another, but HOW it relates. |
|
|
|
|
|
Taxonomy is sufficient for grouping or classifying nodes, but it can make no |
|
|
statements about HOW each of those nodes relate to each other, only that they |
|
|
are in the same 'group'. |
|
|
In order to support complex metadata like 'this page REFERS TO that page' or |
|
|
'this document IS DEPRECATED IN FAVOUR OF that document', we introduce the |
|
|
concept of predicates, and provide both a user interface and a programmers API |
|
|
to support this. |
|
|
|
|
|
Following much discussion and reseach, this module exposes the concept of |
|
|
'triples', as used throughout the RDF metadata initiatives and standards. |
|
|
An understanding of the RDF syntax is NOT required to make use of this module, |
|
|
although it becomes quite useful when using it to define your own predicates. |
|
|
|
|
|
( |
|
|
'predicates' are the phrases that provide the 'action' in a statement of fact. |
|
|
In the sentence "The author of README.txt is Dan", "author of" is the |
|
|
predicate. |
|
|
Throughout the documentation, I use a subject-predicate-object structure that |
|
|
attempts to make grammatical sense, eg "README.txt HAS AUTHOR Dan". |
|
|
) |
|
|
|
|
|
|
|
|
The core module is made available to be extended by other modules that wish to |
|
|
make use of the generalized relationship management functions. Several examples |
|
|
of simple modules that leverage this power are provided as optional plugins. |
|
|
|
|
|
|
|
|
Features |
|
|
----------------------------- |
|
|
|
|
|
* Pluggable ontologies - a module can create its own predicates and define |
|
|
the behaviour of what happens when a node has (or wants to have) a |
|
|
user-defined property. (much like Taxonomy) |
|
|
* RDF-compatable - Relationships between documents can be expressed using |
|
|
RDF syntax. Internally, this should make no difference to a casual user, |
|
|
but when used, each Drupal page truly becomes part of the 'Semantic Web' |
|
|
* New properties and links are embedded in the HTML head as "meta content" |
|
|
and "link rel" tags. This enables semantic navigation and access keys in |
|
|
certain browsers, and should alos provide useful hints to indexers. |
|
|
* Cute interface - Although the power and complexity of this approach can |
|
|
be overwhelming, the editing of relationships is done through a simple |
|
|
form. (simple at the node level - actually administering new terms is not) |
|
|
* Some inference engine support - Depending on the ontology in use, extra |
|
|
statements can be deduced about a resource. This is to be developed to |
|
|
support OWL web ontology and SPARQL RDF Query Language. |
|
|
* Server-agnostic - Both the subject and object of a statement may be off-site |
|
|
URLs. You can create a 'relationship' between your pages and any other |
|
|
resource defined by a URI. You can even make statements about things |
|
|
you have no control over at all... for whatever reason... |
|
|
* Literal Metadata - the object of a statement is usually expected to be |
|
|
another resource (as defined by a URI) but this is not enforced. Predicates |
|
|
can make statements about literal strings |
|
|
eg "This page has copyright 2005". |
|
|
Using the relationship module in this way sort of emulates the flexinode |
|
|
functionality - in a much more free-form way. |
|
|
|
|
|
|
|
|
Install |
|
|
----------------------------- |
|
|
|
|
|
* 1. The main 'relationship.module' should have no dependances other than |
|
|
Drupal core 4.6. |
|
|
|
|
|
* 2. Untar the distribution file in your contributed modules folder. |
|
|
The package may contain several *.module files - only relationship.module |
|
|
is required to be enabled, the rest are optional to provide examples or |
|
|
administration enhancements. *.inc files are libraries that may be |
|
|
included on request by the modules. |
|
|
|
|
|
* 3. Database setup IS AUTOMATIC ON INSTALL. You do not need to pipe the SQL |
|
|
tables through mysql or anything. With appropriate rights, the tables |
|
|
will be created the first time relationship.module is enabled in the |
|
|
admin/modules interface. |
|
|
|
|
|
* 4. Visit admin/modules on your site and enable 'relationship'. |
|
|
|
|
|
* 5. Types of relationships can now be administered through the new admin menu |
|
|
option 'relationships'. It's recommended to start with a sample set of |
|
|
terms to see how this works. Only a couple of really basic terms are |
|
|
available at first. |
|
|
|
|
|
* 5.1 Enable (for example) 'ontology_navigation' which will expose a bunch of |
|
|
book-type relationships - 'next' 'previous' 'up', 'first' and provide |
|
|
a vanilla 'book.module' style navigation block under nodes that use these |
|
|
terms. |
|
|
This ontology also comes with a demo function (available under |
|
|
admin/relationship) to populate the database with some sample, structured |
|
|
content. |
|
|
|
|
|
* 5.2 There is now an extra edit table appended to each node edit form. |
|
|
This is where the relationships are maintained through select-boxes. |
|
|
|
|
|
* 5.3 To actually see the relationships in action, try enabling the |
|
|
metadata_blocks.module. Enable it in the admin/modules, then turn on the |
|
|
'all metadata' block in admin/blocks. This will display the properties you |
|
|
add to a node. |
|
|
|
|
|
----------------------------- |
|
|
Pluggable Additions |
|
|
----------------------------- |
|
|
|
|
|
Several extra modules are provided to expose different features of the system. |
|
|
Not all the extras are needed for all uses, so these are distributed as |
|
|
helper modules. They do all however rely on the 'relationship.module' to be |
|
|
available. |
|
|
Each module has extensive documentation of its own, but here's an overview. |
|
|
|
|
|
|
|
|
metadata_blocks.module |
|
|
----------------------------- |
|
|
|
|
|
... is a new type of block, administered through the 'admin/blocks' menu. |
|
|
It exposes a default 'all metadata' block which will display all relationship |
|
|
links (and literals) currently associated with whatever node it is displayed |
|
|
alongside. While that could be useful, it's there primarily as development |
|
|
utility. |
|
|
|
|
|
It also allows you to define any number of custom blocks that expose only the |
|
|
type of relations you wish users to see. A trivial example would be to use it |
|
|
to show 'related' links as a side block. More interestingly, it could list |
|
|
resources that link TO this page, or any 'metadata' about the page. |
|
|
|
|
|
Note, the metadata_blocks.module requires another helper module called |
|
|
listblock.module. It's a trivial rendering library, but it needs to be enabled. |
|
|
|
|
|
ONTOLOGIES |
|
|
----------------------------- |
|
|
|
|
|
Ontologies are sets of terms, DEFINITIONS of predicates, usually containing |
|
|
a little internal logic defining how these terms relate to one another. |
|
|
A 'geneology' ontology may define that the phrase "is parent of" is a |
|
|
meaningful relationship two things (people) may have to each other. |
|
|
It would also include the rule that "is child of" is a required reciprocal |
|
|
relationship. |
|
|
An ontology module inside drupal MAY also define a presentational enhncement, |
|
|
such as providing a link to 'parent(s)' in the links bar when rendering a node. |
|
|
|
|
|
An 'ontology' containing 'predicates' can be thought of as being similar to |
|
|
Drupal 'vocabulary' containing 'terms'. |
|
|
The code and the interface was originally based on this model, then extended |
|
|
to allow for distributed (external) definitions of terms through the use of |
|
|
public schemas and URI identifiers. ... so everyone knows they are working |
|
|
with the same terms, not installation-specific keywords. |
|
|
|
|
|
ontology_navigation.module |
|
|
----------------------------- |
|
|
|
|
|
- defines a set of navigational relationships, as well as publishing a small |
|
|
nav block and modifying the rendering of a node to provide 'book.module' type |
|
|
buttons at the bottom of a 'page'. It is basically proof-of-concept, and not |
|
|
intended to usurp the real book.module or menu.module, which both benefit from |
|
|
a top-down heirachical approach and tree management interface. |
|
|
|
|
|
ontology_geneology.module |
|
|
----------------------------- |
|
|
|
|
|
.. is another proof-of-concept, using predicate terms that have built-in |
|
|
implications or characteristics when developing the inference engine. |
|
|
If Cain is the son of Adam, and Enoch is the son of Cain, |
|
|
then Enoch is an ancestor of Adam. ... stuff like that. |
|
|
|
|
|
ontology_revision_control.module |
|
|
----------------------------- |
|
|
|
|
|
.. defines a set of document management type terms. |
|
|
Intended to express concepts like: |
|
|
if a document is replaced by another one, |
|
|
(but is still required to be on file) |
|
|
then the deprecated document should have a warning flag put on it to link |
|
|
to the 'latest version', and other documents which refer to the old one may |
|
|
be told to refer to the new one instead... |
|
|
|
|
|
This is an attempt at realizing a real-world requirement, |
|
|
(the prime mover for this entire system in fact) |
|
|
but it exposed a lot of groundwork that needed to be done. |
|
|
|
|
|
|
|
|
ontology_rdf.module |
|
|
----------------------------- |
|
|
|
|
|
.. Is in fact a lot more than just an ontology of terms. |
|
|
It provides admin functionality to expose the underlying data structures of |
|
|
the predicates in use, allows import and export of ontologies from |
|
|
remote sources (like the Dublin Core) and provides a true RDF representation |
|
|
of metadata for all nodes. |
|
|
The terms it defines are those used in the definition of RDF/XML itself - |
|
|
what is a 'property', what is a 'relationship', what does 'isSubpropertyOf' |
|
|
mean. |
|
|
|
|
|
Each predicate term can be defined in terms of other RDF statements. The whole |
|
|
system can bootstrap itself up from first principles, the language can define |
|
|
itself. |
|
|
|
|
|
This is power-user stuff, well complicated for normal users. |
|
|
|
|
|
A bonus feature to be found in this package however is the ability to import |
|
|
statements from other sites. If pointed at an RSS feed, it can absorb |
|
|
information about like "that blog links to that article" ... or, if someone |
|
|
else out there is using Semantic web principles, it can discover what the |
|
|
'author' and more of a remote document is ... and remember it. |
|
Parent Directory
| 
Revision Log
| 
Revision Graph
| 
Patch