8c21769078
$item->name was inteded as the author name and $item->author as the author uri. Bridges use $item->name and $item->author interchangably for author name, so $item->name can be removed. $item->author is now used for the author name!
237 lines
8 KiB
Markdown
237 lines
8 KiB
Markdown
# Howto create a bridge
|
|
|
|
A bridge is an class that allows rss-bridge to create a RSS feed from a website.
|
|
The bridge is a PHP file, located in the [`bridges/`](bridges/) folder.
|
|
|
|
Read the following chapters an make sure to read the [Guidelines](#guidelines)!
|
|
|
|
## Specifications
|
|
|
|
A rss bridge must extend the `BridgeAbstract` class and implement the following functions :
|
|
|
|
* [`loadMetadatas`](#the-loadmetadatas-function) (**required**)
|
|
* [`collectData`](#the-collectdata-function) (**required**)
|
|
* [`getName`](#the-getname-function)
|
|
* [`getURI`](#the-geturi-function)
|
|
* [`getCacheDuration`](#the-getcacheduration-function)
|
|
|
|
Find a [template](#template) at the end of this file.
|
|
|
|
## The `loadMetadatas` function
|
|
|
|
This function is used by rss-bridge to determine the name, maintainer name, website, last updated date... of the bridge, and the user parameters.
|
|
|
|
### Basic metadatas
|
|
|
|
The basic metadatas are :
|
|
|
|
```PHP
|
|
$this->maintainer // Name of the maintainer
|
|
$this->name // Name of the bridge
|
|
$this->uri // URI to the target website of the bridge ("http://....")
|
|
$this->description // A brief description of the bridge
|
|
$this->update // Date of last change in format "yyyy-mm-dd"
|
|
$this->parameters // (optional) Definition of additional parameters
|
|
```
|
|
|
|
Find a description of `$this->parameters` [below](#parameters)
|
|
|
|
The default values are :
|
|
|
|
```PHP
|
|
$this->maintainer = 'No maintainer';
|
|
$this->name = "Unnamed bridge";
|
|
$this->uri = "";
|
|
$this->description = 'No description provided';
|
|
$this->parameters = array();
|
|
```
|
|
|
|
### Parameters
|
|
|
|
Parameters are defined in a JSON-like format, which is parsed and transformed into a HTML `<form>` by rss-bridge.
|
|
|
|
These datas goes into the `$this->parameters` array, which is not mandatory if your bridge doesn't take any parameter.
|
|
|
|
Every possible usage of a bridge is an array element.
|
|
|
|
The array can be a key-based array, but it is not necessary. The following syntaxes are hereby correct :
|
|
|
|
```PHP
|
|
$this->parameters[] = ...
|
|
$this->parameters['First usage of my bridge'] = ...
|
|
```
|
|
|
|
It is worth mentionning that you can also define a set of parameters that will be applied to every possible utilisation of your bridge.
|
|
To do this, just create a parameter array with the `global` key :
|
|
|
|
```PHP
|
|
$this->parameters['global'] = ...
|
|
```
|
|
|
|
### Format specifications
|
|
|
|
Every `$this->parameters` element is a JSON array of cluster (`[ ... ]`) containing all input fields.
|
|
|
|
Following elements are supported :
|
|
|
|
Parameter Name | Required | Type | Supported values | Description
|
|
---------------|----------|------|------------------| -----------
|
|
`name`|**yes**|Text||Input name as displayed to the user
|
|
`identifier`|**yes**|Text||Identifier, which will be the key in the `$param` array for the [`collectData`](#the-collectdata-function) function
|
|
`type`|no|Text|`text`, `number`, `list`, `checkbox`|Type of the input, default is text
|
|
`required`|no|Boolean|`true`, `false`|Set this if you want your attribute to be required
|
|
`values`|no|Text|`[ {"name" : option1Name, "value" : "option1Value"}, ... ]`| Values list, required with the '`list`' type
|
|
`title`|no|Text||Will be shown as tooltip when mouse-hovering over the input
|
|
|
|
Hence, the most basic parameter definition is the following :
|
|
|
|
```PHP
|
|
...
|
|
$this->parameters[] =
|
|
'[
|
|
{
|
|
"name" : "Username",
|
|
"identifier" : "u"
|
|
}
|
|
]';
|
|
...
|
|
```
|
|
|
|
## The `collectData` function
|
|
|
|
This function takes as a parameter an array called `$param`, that is automatically filled with values from the user, according to the values defined in the parameters array in `loadMetadatas`.
|
|
This function is the place where all the website scrapping and the RSS feed generation process must be implemented.
|
|
|
|
RSS elements collected by this function must be stored in the class variable `items[]`.
|
|
|
|
Every RSS element is an instance of the `Item` class.
|
|
|
|
## Items
|
|
|
|
The `Item` class is used to store parameter that are collected in the [`collectData`](#the-collectdata-function) function. Following properties are supported by rss-bridge :
|
|
|
|
```PHP
|
|
$item->uri // URI to reach the subject ("http://...")
|
|
$item->title // Title of the item
|
|
$item->timestamp // Timestamp of the item in numeric format (use strtotime)
|
|
$item->author // Name of the author
|
|
$item->content // Content in HTML format
|
|
```
|
|
|
|
In order to create a new item you'll have to escape the **I** in **I**tem like this :
|
|
|
|
```PHP
|
|
$item = new \Item();
|
|
```
|
|
|
|
### Item usage
|
|
|
|
Which items are necessary depends on the output format. There are two formats that support literally any property in the `$item`:
|
|
|
|
* JSON
|
|
* Plaintext
|
|
|
|
The following list provides an overview of the parameters used by the other formats :
|
|
|
|
Parameter | ATOM | HTML | (M)RSS
|
|
----------|------|------|-------
|
|
`uri`|X|X|X
|
|
`title`|X|X|X
|
|
`timestamp`|X|X|X
|
|
`author`|X|X|X
|
|
`content`|X|X|X
|
|
|
|
## The `getName` function
|
|
|
|
This function returns the name of the bridge as it will be displayed on the main page of rss-bridge or on top of the feed output (HTML, ATOM, etc...).
|
|
|
|
**Notice:** rss-bridge will by default return `$this->name` which is defined in the [`loadMetadatas`](#the-loadmetadatas-function) function, so you only have to implement this function if you require different behavior!
|
|
|
|
```PHP
|
|
public function getName(){
|
|
return $this->name;
|
|
}
|
|
```
|
|
|
|
## The `getURI` function
|
|
|
|
This function returns the URI to the destination site of the bridge. It will be used on the main page of rss-bridge when clicking your bridge name.
|
|
|
|
**Notice:** rss-bridge will by default return `$this->uri` which is defined in the [`loadMetadatas`](#the-loadmetadatas-function) function, so you only have to implement this function if you require different behavior!
|
|
|
|
```PHP
|
|
public function getURI(){
|
|
return $this->uri;
|
|
}
|
|
```
|
|
|
|
## The `getCacheDuration` function
|
|
|
|
This function returns the time in **seconds** during which rss-bridge will output cached values instead of re-generating a RSS feed.
|
|
|
|
**Notice:** rss-bridge will return `3600` seconds (1 hour) by default, so you only have to implement this function if you require different timing!
|
|
|
|
```PHP
|
|
public function getCacheDuration(){
|
|
return 3600; // 1 hour
|
|
}
|
|
```
|
|
|
|
# Bridge Abstract functions
|
|
|
|
All bridges extend from `BridgeAbstract` and therefore are able to make use of functions defined in `BridgeAbstract`.
|
|
|
|
Following functions should be used for good practice and will support you with your bridge :
|
|
|
|
* [`returnError`](#the-returnerror-function)
|
|
* [`file_get_html`](#the-file_get_html-function)
|
|
|
|
## The `returnError` function
|
|
|
|
This function aborts execution of the current bridge and returns the given error message with the provided error number :
|
|
|
|
```PHP
|
|
$this->returnError('Your error message', 404)
|
|
```
|
|
|
|
Check the [list of error codes](https://en.wikipedia.org/wiki/List_of_HTTP_status_codes) for applicable error numbers.
|
|
|
|
## The `file_get_html` function
|
|
|
|
This function is a wrapper around the [simple_html_dom](http://simplehtmldom.sourceforge.net/) [file_get_html](http://simplehtmldom.sourceforge.net/manual_api.htm#api) function in order to provide context by design. It is considered good practice to use this function.
|
|
|
|
```PHP
|
|
$html = $this->file_get_html('your URI');
|
|
```
|
|
|
|
# Guidelines
|
|
|
|
* scripts (eg. Javascript) must be stripped out. Make good use of `strip_tags()` and `preg_replace()`
|
|
* each bridge must present data within 8 seconds (adjust iterators accordingly)
|
|
* cache timeout must be fine-tuned so that each refresh can provide 1 or 2 new elements on busy periods
|
|
* `<audio>` and `<video>` must not autoplay. Seriously.
|
|
* do everything you can to extract valid timestamps. Translate formats, use API, exploit sitemap, whatever. Free the data!
|
|
* don't create duplicates. If the website runs on WordPress, use the generic WordPress bridge if possible.
|
|
* maintain efficient and well-commented code :wink:
|
|
|
|
# Template
|
|
|
|
This is the minimum template for a new bridge:
|
|
|
|
```PHP
|
|
<?php
|
|
class MySiteBridge extends BridgeAbstract{
|
|
public function loadMetadatas(){
|
|
$this->maintainer = 'No maintainer';
|
|
$this->name = 'Unnamed bridge';
|
|
$this->uri = '';
|
|
$this->description = 'No description provided';
|
|
$this->parameters = array();
|
|
}
|
|
|
|
public function collectData(array $params){
|
|
// Implement your bridge here!
|
|
}
|
|
}
|
|
|
|
```
|