Free facts about apples software for linux

Gantry::Docs::About is a document explaining Gantrys features and history.
History
Along about 1997 or so, our company (a cable/ISP owned by a newspaper) began serving mod_perl apps to staff and customers. A framework developed and flourished. It was simple, explicit, and fast enough for the high-volume sites run by our parent newspaper. As time passed, improvements were made until a second version was conceived and deployed.
Finally, in August of 2005, a third revision was completed which is now available as an open source product (under the standard Perl license). The new version has lots of new features and removes some of the arcana that built up over the previous six or so years. Notably, it gained an MVC structure and some nifty automated CRUD. But the newly released third version, now called Gantry, retains simplicity, explicitness, speedy throughput, and the ability to host complex projects.
Main features:
- a central mod_perl handler all apps may inherit (Gantry.pm)
- CGI/FastCGI support (Gantry::Engine::CGI)
- automated CRUD (create, retrieve, update, delete) for straightforward tables (Gantry::Plugins::AutoCRUD)
- flexible CRUD for the sophisticated parts of applications (Gantry::Plugins::CRUD)
- easy date entry (via javascript code in form.tt)

Facter is a cross-platform Ruby library for retrieving facts from operating systems. Supports multiple resolution mechanisms, any of which can be restricted to working only on certain operating systems or environments.

Facter is especially useful for retrieving things like operating system names, IP addresses, MAC addresses, and SSH keys.

It is easy to extend Facter to include your own custom facts or to include additional mechanisms for retrieving facts.

Installation:

Run ruby install.rb or use one of the distributed gem files at http://reductivelabs.com/downloads/gems .

install.rb should successfully install; let me know if it doesnt.

Otherwise, you can just set RUBYLIB to contain its lib directory, or copy the libs into your main ruby library directory.

This chapter serves as a gentle introduction to Maypole and setting up Maypole applications. We look at what Maypole is, how to get it up and running, and how to start thinking about building Maypole applications.

What is Maypole?

Presumably you have some idea of what Maypole is all about, or otherwise you wouldnt be reading this manual. But Maypole is good at many different things, and you may have accidentally focussed on one aspect of Maypole while missing the big picture.

For instance, you may know that Maypole is extremely good at putting web front-ends onto databases. This is true, but its only a part of what Maypole does. You may have heard that Maypole is a web application framework, which is true, but it doesnt mean very much. There are a huge number of things that Maypole can do, because its very much a blank slate. You can make it do what you will. In this manual, well be making it act as a front-end to a database, as a social network site, as an intranet portal, and many other things besides.It is a framework.

I like to think that Maypole is a way of going from a URL to a method call to some output. If you have a URL like /product/order/12, Maypole is a way of having it load up product number 12, call an order method, and produce a page about what its just done. The reason Maypole is such a big deal is because it does all this for you. You no longer have to care about your web server. You hardly have to care about your database. You dont have to care about templating modules, parsing CGI parameters, or anything else. You only need to care about business logic, and the business logic in this instance is how you order a product, and what you need to display about it once youve done so. This is what programming should be: only caring about the work that distinguishes one program from another.

It does this using a technique called MVC for web applications.

What is MVC for web applications?

Maypole was originally called Apache::MVC, reflecting its basis in the Model-View-Controller design pattern. (I had to change it firstly because Maypole isnt tied to Apache, and secondly because Apache::MVC is a really dull name.) Its the same design pattern that forms the foundation of similar projects in other languages, such as Javas Struts framework.

This design pattern is found primarily in graphical applications; the idea is that you have a Model class which represents and manipulates your data, a View class which is responsible for displaying that data to the user, and a Controller class which controls the other classes in response to events triggered by the user. This analogy doesnt correspond precisely to a web-based application, but we can take an important principle from it. As Template Toolkit author Andy Wardley explains:

What the MVC-for-the-web crowd are really trying to achieve is a clear
separation of concerns. Put your database code in one place, your
application code in another, your presentation code in a third place.
That way, you can chop and change different elements at will,
hopefully without affecting the other parts (depending on how well your
concerns are separated, of course). This is common sense and good practice.
MVC achieves this separation of concerns as a by-product of clearly
separating inputs (controls) and outputs (views).

This is what Maypole does. It has a number of database drivers, a number of front-end drivers and a number of templating presentation drivers. In common cases, Maypole provides precisely what you need for all of these areas, and you get to concentrate on writing just the business logic of your application. This is one of the reasons why Maypole lets you develop so rapidly: because most of the time, you dont need to do any development at all.

Data::ICal is a Perl module that generates iCalendar (RFC 2445) calendar files.

SYNOPSIS

use Data::ICal;

my $calendar = Data::ICal->new();

my $vtodo = Data::ICal::Entry::Todo->new();
$vtodo->add_properties(
# ... see Data::ICal::Entry::Todo documentation
);

# ... or

$calendar = Data::ICal->new(filename => foo.ics); # parse existing file
$calendar = Data::ICal->new(data => BEGIN:VCALENDAR...); # parse existing file


$calendar->add_entry($vtodo);

print $calendar->as_string;

# Or, if youre printing to something you want google to read:
print $calendar->as_string(fold => 0);

A Data::ICal object represents a VCALENDAR object as defined in the iCalendar protocol (RFC 2445, MIME type "text/calendar"), as implemented in many popular calendaring programs such as Apples iCal.

Each Data::ICal object is a collection of "entries", which are objects of a subclass of Data::ICal::Entry. The types of entries defined by iCalendar (which refers to them as "components") include events, to-do items, journal entries, free/busy time indicators, and time zone descriptors; in addition, events and to-do items can contain alarm entries. (Currently, Data::ICal only implements to-do items and events.)
Data::ICal is a subclass of Data::ICal::Entry; see its manpage for more methods applicable to Data::ICal.

Class::InsideOut::Manual::About is a guide to this and other implementations of the inside-out technique.
This manual provides an overview of the inside-out technique and its application within Class::InsideOut and other modules. It also provides a list of references for further study.
Inside-out object basics
Inside-out objects use the blessed reference as an index into lexical data structures holding object properties, rather than using the blessed reference itself as a data structure.
$self->{ name } = "Larry"; # classic, hash-based object
$name{ refaddr $self } = "Larry"; # inside-out
The inside-out approach offers three major benefits:
- Enforced encapsulation: object properties cannot be accessed directly from ouside the lexical scope that declared them
- Making the property name part of a lexical variable rather than a hash-key means that typos in the name will be caught as compile-time errors (if using strict)
- If the memory address of the blessed reference is used as the index, the reference can be of any type
In exchange for these benefits, robust implementation of inside-out objects can be quite complex. Class::InsideOut manages that complexity.
Philosophy of Class::InsideOut
Class::InsideOut provides a set of tools for building safe inside-out classes with maximum flexibility.
It aims to offer minimal restrictions beyond those necessary for robustness of the inside-out technique. All capabilities necessary for robustness should be automatic. Anything that can be optional should be. The design should not introduce new restrictions unrelated to inside-out objects, such as attributes and CHECK blocks that cause problems for mod_perl or the use of source filters for syntatic sugar.
As a result, only a few things are mandatory:
- Properties must be based on hashes and declared via property
- Property hashes must be keyed on the Scalar::Util::refaddr
- register must be called on all new objects
All other implementation details, including constructors, initializers and class inheritance management are left to the user (though a very simple constructor is available as a convenience). This does requires some additional work, but maximizes freedom. Class::InsideOut is intended to be a base class providing only fundamental features. Subclasses of Class::InsideOut could be written that build upon it to provide particular styles of constructor, destructor and inheritance support.

acdctl is a VESA/Apple Cinema Display controller.

acdctl is a commandline utility to control the otherwise inaccessible brightness levels of a VESA-compliant USB connected display such as the Apple Cinema Display.

acdctl works on any system with libusb support by directly manipulating the displays USB HID interface.