Change lookup method to find if content is of XML type.

We now search for an element node amongst all children of the content
element. If we find one, we assume its of XML type (since the spec
requires that other types do not have XML elements anyway).

Add support for content in the entry.

Finally, an atom:entry gets its atom:content.

Rename the functions to set and retrieve the xml content from atom:content.

The names for those functions didn't mirror the usual names for getters
and setters. Fix that.

Added atom:content constructore from a xml node.

When parsing an entry, we will have the pointer to a xmlnode containing
the entire content element, including its type. So, split the buffer
constructor into a part that converts it to a xmlDoc and the part that
creates the content object from its root xmlnode.

Don't forget to change length when setting text content.

When setting the text content, we forgot to set its length, which ended
up preventing a proper copy to happen when retrieving it.

Set alternative content to NULL after free.

When setting the content using a type different from the original (src
content instead of text content, for example), set the old content to
NULL after releasing its memory. Otherwise, we try to free them when
releasing the content object or setting the content again.

More implementation of atom:content.

Decoding and encoding into a string or xmlNode is now done. And there
can be only one between src, text content or xml content.

Started adding support for Entry Content.

The required and long expected support for entry content has get
started. We have some not implemented functions and it is possible to
get some inconsistencies, like setting the content as xmlnode after
creating a content with a different text and being able to retrieve the
original text after that.

It is also not integrated into AtomEntry, but we are getting closer with
this step.

Category XML header was not distributed.

This introduced a build error in applications using the XML interface.
Since atom-xml.h includes category-xml.h, which was not distributed, the
pre-processor couldn't find and build errors happened in applications.

Return a copy of a string in ghashtable configuration module.

Since gkeyfile module returns a string copy that must be freed, other
modules must do as well, to avoid releasing a static or stack string or
double-freeing a dynamic one.

Insert key and value in the group table, not the main table.

In the ghashtable config backend, when inserting a new group/key/value,
we were inserting the new key/value pair into the main table, instead of
the subtable for the group.

Forgot to add new Makefiles that should be generated

After creating the new subdirectories for configuration backends, their
corresponding Makefiles should have been added to autoconf.

Added configuration backend using hash tables

Using GHashTable from GLib, store the configuration in memory, requiring
the user to set all required configuration values by the configuration
users.

GKeyFile config implementation did not return the config object

Moved config current only implementation to subdirectory

To allow multiple config backend implementations, move the gkeyfile
implementation to its own subdirectory.

Fix updating entry XML with category element

When updating the entry XML, the category object was being added instead
of the category XML element.

Added support for category element, which is required

The encoding and decoding of ISO8601 format is left to GLib. The public
interface is time_t, which, besides its lack of subsecond precision,
seems to be the most portable and standard for now. POSIX 2008 obsoletes
struct timeval and gettimeofday and struct timespec and clock_gettime
are too new to be used.

Require atom entries to have ID, title and authors

As required by RFC, entries must have an ID, title and authors. This
will avoid some possible errors when creating the correspondent XML.

Category element in atom entry

Now, there are categories associated to an entry. They can be added and
retrieved just like retrieving authors.

Added support for category element

A new object to represent an entry or feed category.

Use AtomID instead of string consistently in entry

Some code sections in the entry code used AtomID and other sections used
a string to the entry id. Use only AtomID.

Remove unused IRI variable in main sample code

Let the frontend deal with bad requests for posting to member resources

As the atompub RFC specifies that posting to a member resource URI is a
bad request, let the frontend deal with it and avoid the need to inform
the core that the request has a URI and a desired name (Slug).

Let configuration mechanism be extensible

The configuration system now may be implemented with different backends.
The only function provided by now is still the get_str function. For the
keyfile configuration system, the filename may also be provided now.

When sending a POST operation in the soup backend, use the feed URI

When parsing an entry, create a new ID object and copy the others

When parsing the entry, the strings were not copied and the ID was a
string and not an ID object.

Let frontend handle error in example program instead of handling it

Fix some building and linking problems with the soup backend

The soup backend was not being linked to the atom library and it used
the wrong names for some error functions.

Add initial support for libsoup backend

Add Slug header support to CGI frontend

Implement publish handler in CGI frontend

Get Base URL from HTTP Headers

Implement publish_entry function in GIO backend

Handle POST requests in the core

Added publish handler to frontend

Initialize all frontend functions when creating a new frontend

Implement backend interface to publish entries

Implemented POST request in CGI frontend

Added content data to request

Fix building including request header into frontend header

Implement new frontend functions for CGI frontend

Added function to serve requests from any frontend

This function serves requests from any frontend. This would be common
code among all frontends. That's why implementing in the core makes more
sense.

Added functions to handle errors, entries or feeds in frontend

Added get_request function to the frontend

Added request structure

This is needed to allow the core to know about the request made to the
frontend. A request will need to represent more things besides a type
and the requested object, like the entry or data provided, in the case
of a POST or PUT, for example.

Fixed memory leak when setting error message

Removed parameter name from header

Enumerate entries at the start of the program

This is required to set the request mappings, so the frontend can
identify the backend request needed to retrieve an entry.

CGI frontend now requests a feed or an entry depending on the request

Frontend maps request to Atom ID before retrieving resource

Backend now retrieves a request, not an Atom ID

We map an Atom ID to a backend request and, then, retrieve this request
from the backend.

The frontend tells if a request is a feed or not

Remove Atom Resource

This is required as the next step is to make the frontend decide if the
requested resource is a feed or an entry, instead of the backend.

Added functions to convert AtomID from and to frontend and backend requests

Set up mappings when enumerating entries

Register CGI frontend in main context

Added CGI frontend structure implementation

Added frontend requests mapping

Create frontend structure with map_entries function

Initialize is_feed function for backends to NULL

Moved core implementation to the library

Update entry xml node before using it

Fixed setting an entry title

Use an array instead of a list for the entries in a feed

When converting feed to xml node, set the atom namespace

Allow more than one author, as required by specification

The Atom RFC allows more than one author, which we didn't. Now, an entry
have an array of authors, which can be added to or retrieved. The header
also had the wrong function names.

Fixed the use of a dangling reference

When unreferencing the info object, the name attribute would be
released, resulting in a bug when trying to copy it right after that.
So, we unreference the info object in the end of the loop now.

Fixed memory leak when enumerating entries

Added map from atom:IDs to backend requests

Use local variables when calling backend enumerate function

When enumerating entries, return the requests backend understands

To be able to map atom:IDs to backend requests, let the backend return
the mapping when enumerating the entries.

Do not output error when trying to parse XML data

Ignore if an entry cannot be read when enumerating files

Retrieve an entry if backend can tell it's not a feed

Return error if backend is not able to tell a feed from an entry

Added a .gitignore file to ignore building and built files

Return after returning an error

Convert GIOError too when converting from GError to AtomError

If GIO cannot enumerate directory, set error and return

Return NULL instead of an empty feed in case of a backend error

Avoid a crash if there is no index configured

Dummy IRI parsing. Needed to fix segfault bug, when freeing person's URI

Fix typo for AtomCtx type

Include AtomID header into main Atom header

Introducing AtomID, which is used in core, instead of IRI

Build iri directory before other directories

Library includes every module and sample main program links with it

GIO is the default backend for sample main program

Return a copy of the internal node, caller is the owner

If backend cannot enumerate entries, return 0 entries with NULL array

If entry or feed is NULL, so should be the resource

CGI frontend uses AtomResource instead of AtomEntry

Retrieve resource returns either an entry or a feed

Added AtomResource as a generalization for entries and feeds

Renamed retrieve_resource to retrieve_entry

Create feed using entries from backend

Get string from AtomFeed

Atom namespace is in a common header now

Generate feed with many entries

Distribute XML headers