Free dependency injection software for linux

Injection is a simple dependency injection plugin for Rails. Injection allows you to inject ojects into your controllers which have been described in a yaml file (config/objects.yml).

By using constructor injection for controllers, it becomes easy to test the controllers use of such objects using dynamic mocks.

Installation:

$ script/plugin install svn://rubyforge.org//var/svn/injection/tags/injection

Algorithm::Dependency is a base class for implementing various dependency trees.

SYNOPSIS

use Algorithm::Dependency;
use Algorithm::Dependency::Source::File;

# Load the data from a simple text file
my $data_source = Algorithm::Dependency::Source::File->new( foo.txt );

# Create the dependency object, and indicate the items that are already
# selected/installed/etc in the database
my $dep = Algorithm::Dependency->new(
source => $data_source,
selected => [ This, That ]
) or die Failed to set up dependency algorithm;

# For the item Foo, find out the other things we also have to select.
# This WONT include the item we selected, Foo.
my $also = $dep->depends( Foo );
print $also
? "By selecting Foo, you are also selecting the following items: "
. join( , , @$also )
: "Nothing else to select for Foo";

# Find out the order we need to act on the items in.
# This WILL include the item we selected, Foo.
my $schedule = $dep->schedule( Foo );

Algorithm::Dependency is a framework for creating simple read-only dependency heirachies, where you have a set of items that rely on other items in the set, and require actions on them as well.

Despite the most visible of these being software installation systems like the CPAN installer, or debian apt-get, they are usefull in other situations. This module intentionally uses implementation-neutral words, to avoid confusion.

Libdejector provides a simple, easy-to-use set of libraries which help Web developers give their database queries a great degree of resistance to SQL injection attacks.

libdejector library currently provides Python bindings to protect PostgreSQL 8.0.3 through 8.0.5.

Installation:

The simplest way to compile this package is:

1. `cd to the directory containing the packages source code and type `./configure to configure the package for your system. If youre using `csh on an old version of System V, you might need to type `sh ./configure instead to prevent `csh from trying to execute `configure itself.

Running `configure takes awhile. While running, it prints some messages telling which features it is checking for.

2. Type `make to compile the package.

3. Optionally, type `make check to run any self-tests that come with the package.

4. Type `make install to install the programs and any data files and documentation.

5. You can remove the program binaries and object files from the source code directory by typing `make clean. To also remove the files that `configure created (so you can compile the package for a different kind of computer), type `make distclean. There is also a `make maintainer-clean target, but that is intended mainly for the packages developers. If you use it, you may have to get all sorts of other programs in order to regenerate files that came with the distribution.

Injection Framework project is a security tool designed to detect and research SQL injections.

Peco::Container is a light inversion of Control (IoC) container.

SYNOPSIS

my $c = Peco::Container->new;

$c->register( my_key, My::Class );
$c->register( my_key, My::Class, [ @deps ] );
$c->register( my_key, My::Class, [ @deps ], create );
$c->register( my_key, My::Class, [ @deps ], create, { %attrs } );

$c->register( my_key, My::Class, undef, create );
$c->register( my_key, My::Class, undef, create, { %attrs } );
$c->register( my_key, My::Class, [ @deps ], undef, { %attrs } );

my $instance = $c->get(my_key);
my @instances = $c->get_all();

$c->has(my_key) ? 1 : 0;
$c->is_empty ? 1 : 0;

$c->multicast( method, @args );

Peco::Container is a small, flexible Inversion of Control (IoC) container supporting both Constructor Injection and Setter Injection patterns, as well prototype services (factories) and multicasting.

Sledge::Plugin::DI is a dependency injection for Sledge.

SYNOPSIS

use Sledge::Plugin::DI;

package Your::Pages;
use Sledge::Plugin::DI;
# no create_* methods!

# in your config.yaml
common:
di:
session: Sledge::Session::Memcached
cache: Sledge::Cache::Memcached
charset: Sledge::Charset::Default
authorizer:
- pages: Your::Pages
authorizer: Null
- pages: Your::Pages::Admin
authorizer: Your::Authorizer::Admin
- pages: Your::Pages::My
authorizer: Your::Authorizer::My
manager:
- pages: Your::Pages
session: Cookie
- pages: Your::Pages::Mobile
session: StickyQuery

The Jesktop project is a desktop system written in Java that can have GUI applications installed into it. It is semi-dependant upon NanoContainer which is a component framework at Codehaus. NanoContainer and Constructor Dependency Injection are going to change the way we think of Java based component computing.
Jesktop has been under construction since November 2000. Its team was founded by people building Williams Portable Java Environment (PJE) since early 2000.
- To have a fully functional Java desktop environment running on a fully functional Java operating system that is portable across a number of host operating systems, or if there is JDK support in a BIOS layer, without a host operating system.
- To have a single CD installation of Linux (or other Java capable OS) without its own applications, but with NanoContainer, Jesktop and many Java apps pre-configured.
- To see the Jesktop and NanoContainer used widely by Java enthusiasts and deployed on yet to be created Network appliances and palm sized devices (when palm sized devices support J2SE). Thats right, we see this running on small devices. The attraction to hardware manufactureres is obvious - a standard open source OS layer that can support multiple applications safely.
- To see thousands of GPL, MPL, SPL, Commercial etc. etc. apps runnable inside Jesktop. All will be hot installable, reinstallable and de-installable. No reboot/restart necessary. No questions asked.
Main features:
- Multiple GUI applications running inside the same virtual machine.
- Multiple server applications running inside the same virtual machine.
- Drag and drop between applications (to finish)
- Mime type associations for applications (to finish)
- Many built-in, bundled and ported applications.
- Plugable Window Managers.
- Hot installable applications. Hot deinstallable and reinstallable too.
- Externally skinable applications. Apps dont need their own skin logic.