Free subversion repository software for linux

Image Repository provides a centralized image repository capable of holding thousands of images with keyword/tag-based browsing.
Image Repository is a centralized image repository capable of holding thousands of images with keyword/tag-based browsing and filtering.
Main features:
- Its goal is to provide you with an easy way to have a centralized image library with thousands of images categorized by keywords, dates, etc.
- It has special handling that lets you browse the keyword space like it was a collection of nested folders. Example: Browse to keyword "Carnivores", you will get the available keywords "Cats", "Dogs", and the selection will narrow down, applying all the keywords you have selected on your path through the keyword space.
- It comes complete with a Kupu "library", meaning you can browse the keywords through the Kupu image insertion dialog to make it easy to locate images even in a large collection of images.
- It has a tagging interface that lets you tag images with a thumbnail like view, and apply keywords to multiple images at once.
- It uses whatever image type you have installed (it does need to be added as an addable type and be able to supply thumbnails like the default Plone image type, though).
Enhancements:
- Added action to register the repository in Kupu. [fschulze]
- Using interfaces, views and adapters in various places to make this more flexible. [fschulze]
- Removed unused code. [fschulze]

Subversion Automation project is a wrapper around Subversion that automates and standardizes branching and merging.

The primary goal of the project is to simplify the more complex features of Subversion and therefore encouraging their use.

Cache::Repository is a Perl module used to cache generic file repository.

SYNOPSIS

my $rep = Cache::Repository->new(
style => Filesys,
# options for the F::R driver
);
$rep->add_files(tag => groupname,
files => @filenames,
basedir => /tmp,
move => 1,
);
$rep->add_filehandle(tag => anothergroup,
filename => blah,
filehandle => $fh,
mode => 0755);
$rep->set_meta(tag => groupname,
meta => {
title => blah,
author => foo,
});

$rep->retrieve(tag => groupname, dest => /newdir);
my $data = $rep->get_meta(tag => groupname);

This module is intended to serve as a repository for files, whether those files are local or remote. Different drivers can work independantly to provide differing backing stores. For example, one driver can use a locally-mounted filesystem (even if that is a network filesystem), another could use FTP or HTTP, another could use gmail, and another could use a relational database such as MySQL or DB2.

Drivers may choose to compress the repository, unless explicitly told otherwise.
Keeping this in mind, the API presented here cannot expose things that are not generic to other possible implementations. That said, some possible implementations may not allow adding ("sending" to a web server) - it is expected that they will either throw an exception, or take extra params for FTPing to the server.

BelowVersion is a single-file Python CGI to browse a Subversion repository. It only needs a Web server with Python support and bindings for Subversion libraries.

It bypasses the high-level client library for acceptable performance without losing features. It is written to be fast to navigate with mouse, both within a single revision and between revisions.

It can provide revision logs, colored diffs, and a side-by-side view for image revisions. It can also serve the files like a normal (static) Web server, allowing plain view or saving to disk.

BelowVersion is written to be embeddable in other Web applications with little effort (explained in the source).

RDF::Sesame::Repository is a repository on a Sesame server.

This class is the workhorse of RDF::Sesame. Adding triples, removing triples and querying the repository are all done through instances of this class. Only SELECT queries are supported at this point, but it should be fairly straightforward to add CONSTRUCT functionality. If you do it, send me a patch.

METHODS

construct ( %opts )
Evaluates a construct query and returns the RDF serialization of the resulting RDF graph. A minimal invocation looks something like:
my $q = qq(
CONSTRUCT {Parent} ex:hasChild {Child}
FROM {Child} ex:hasParent {Parent}
USING NAMESPACE
ex =
);
my $rdf = $repo->construct(
query => $q,
format => turtle,
);

If an error occurs during the construction, an exception is thrown. This is different from some RDF::Sesame methods which return undef.
format

Required: Yes

Indicates the RDF serialization format that the Sesame server should return. Acceptable values are rdfxml, turtle and ntriples.
language

Default: SeRQL

Specifies the language in which the construct query is written. This is only included for forwards-compatibility since the only query language supported by Sesame is SeRQL.

output

Default: undef

Indicates where the RDF serialization should be placed. The default value of undef means that the serialization should simply be returned as the value of the construct method.

If the value is a filehandle, the serialization is written to that filehandle. The filehandle must already be open for writing. Otherwise, the value is taken to be a filename which is opened for writing (clobbering existing contents) and the serialization is written to the file.

query

Required : Yes

The text of the construct query.

extract ( %opts )

Extract an RDF representation of all the triples in the repository. The only required option is "format" which specifies the serialization format of the resulting RDF. The minimal method invocation looks like

my $rdf = $repo->extract( format => turtle )

where $rdf is a reference to a scalar containing the serialization of all the triples in the repository. The streaming results returned by Sesame are handled appropriately so that memory usage in minimized. If the output is sent to a file (see "output"), only one "chunk" is held in memory at a time (subject to caching by your OS). The serialization may also be compressed (or otherwise processed) as its being streamed from the server (see "compress").

Error handling is done differently in this method than in other methods in RDF::Sesame. Namely, if an error occurs, an exception is thrown (rather than returning undef and setting errstr(). Eventually, Id like all methods to behave this way.

Subversive project is an Eclipse plug-in which provides Subversion support. From a users point of view, Subversive provides Subversion support similar to CVS support, which is already part of the standard Eclipse platform.
The JavaSVN library is used for interaction with Subversion. In addition to functionality, Subversive pays special attention to usability and nice interface.
The Subversive project is a brand new Eclipse plug-in that provides Subversion support. From a user point of view, Subversive provides Subversion support similar to CVS support, which is already part of the standard Eclipse platform. The main use cases, which are familiar to CVS users, are:
- Connection to the repository using different connection types
- Repository browsing
- Check-out
- Synchronization
- Commiting
- Update
- Resolving conflicts
- Adding to the list of ignored resources
JavaSVN open-source library is used for interaction with Subversion. Having compared it with other tools that use JavaSVN, the Subversive team together with the JavaSVN team extended the standard Subversion API. This improvement gives Subversive an advantage if compared with other native and Java-based Subversion clients. The following solutions, now available in Subversive, are not present in other Subversion clients because of standard API limitations.

HTTP::OAI::Repository is a documentation for building an OAI compliant repository using OAI-PERL.

Using the OAI-PERL library in a repository context requires the user to build the OAI responses to be sent to OAI harvesters.

SYNOPSIS

use HTTP::OAI::Harvester;
use HTTP::OAI::Metadata::OAI_DC;
use XML::SAX::Writer;
use XML::LibXML;

# (all of these options _must_ be supplied to comply with the OAI protocol)
# (protocolVersion and responseDate both have sensible defaults)
my $r = new HTTP::OAI::Identify(
baseURL=>http://yourhost/cgi/oai,
adminEmail=>youremail@yourhost,
repositoryName=>agoodname,
requestURL=>self_url()
);

# Include a description (an XML::LibXML Dom object)
$r->description(new HTTP::OAI::Metadata(dom=>$dom));

my $r = HTTP::OAI::GetRecord->new(
header=>HTTP::OAI::Header->new(
identifier=>oai:myrepo:10,
datestamp=>2004-10-01
),
metadata=>HTTP::OAI::Metadata::OAI_DC->new(
dc=>{title=>[Hello, World!],description=>[My Record]}
)
);
$r->about(HTTP::OAI::Metadata->new(dom=>$dom));

my $writer = XML::SAX::Writer->new();
$r->set_handler($writer);
$r->generate;