Seagull is a mature OOP framework for building web, command line and GUI applications. Licensed under BSD, the project allows PHP developers to easily integrate and manage code resources, and build complex applications quickly.
Many popular PHP applications are already seamlessly integrated within the project, as are various templating engines, testing tools and managed library code. If you're a beginner, the framework provides a number of sample applications that can be customised and extended to suit your needs. If you're an intermediate or advanced developer, take advantage of Seagull's best practices , standards and modular codebase to build your applications in record time.
PHP 4/5 compatible
compact core framework with basic CMS and other modules included to get you started
ease of use: learning curve not as steep as other frameworks
enterprise ready, performance conscious design
tight integration with PEAR libraries, great for prototyping complex projects
integrated ORM for RAD
highly configurable, easy to integrate with 3rd party code
community support: the project enjoys participation from a large and active developer community, want the documentation in Chinese, looking for Seagull devs near you?
loosely coupled components, use template engine of your choice, output to multiple devices or CLI
staying power: started in 2001, the Seagull project has been steadily growing in popularity and now enjoys international recognition
Minimal Requirements
One Minute Install
Modularity
Quality Control
Stability of Codebase
[…]
Entities are simply the code reprentations of the main concepts in your application, the data structures you're going to be working with.
When designing an app, you probably have a set way of doing things, but chances are you're going to:
decide on which entities your app will be processing
make sure the attributes and entities are correctly distinguished
create the tables in the database
build the business logic that manages the data
OO design makes complex application design more manageable by providing the following concepts:
data encapsulation - each object 'holds' all the various attributes for an entity; if your objects are complex, let's say like a Car object, the data is more manageable then if you had the properties scattered all over the place. Don't forget that your object can be comprised of other objects (composition), like in the Car example the engine attribute could be an Engine object. All the operations associated with the Car object would be methods in the Car class.
data persistence - your application would be pretty useless if you were not able to preserve your object modifications. If you wanted to persist your data from page to page, say in the case of a User object, you'd just need to put it in the session. To persist the object between application logois, like User account info, you'd need to store it in the appropriate persistent store: as a record in a DB, a file on the system hard disk, an entry in an LDAP directory, etc.
object state - any time you use a method to modify the attributes of an object, you are changing its state. In OO terms all object attributes are private and can never be accessed directly from other objects, only through getter/setter methods. In PHP4.x however, this is not enforced and indeed it is often more convenient to modify properties directly.
DB_DataObject is a package from PEAR that takes care of entity management for you. In the words of the author Alan Knowles:
DataObject performs 2 tasks:
Builds SQL statements based on the objects vars and the builder methods.
Acts as a datastore for a table row.
The core class is designed to be extended for each of your tables so that you put the data logic inside the data classes. Included is a generator to create your configuration files and your base classes.
At one time or another your web application is going to require you to manage your entities in some way, usually modifying the object state by performing one the the following basic operations:
add (INSERT)
modify (UPDATE)
remove (DELETE)
The term in parentheses is the SQL analogy. What DataObjects (DO) does is to encapsulate the way you interact with your data, making it a lot easier to manage object state. The package has the following workflow:
To start off, install the package in your PEAR repository (its included by default in the Seagull distro).
Using the entities you decided on during the design stage of your project, you create the appropriate tables in the DB.
Execute the DO createTables.php script which creates the entity classes in PHP for you which are analogous to the tables in your DB (This can be done in Seagull through the web interface in the Maintenance section).
Use the DO API to manage all your objects (entities) in a uniform way, regardless of how many attributes you add/modify/delete.
client asks for all the attributes to be changed in the last 2 entities, and in addition wants 2 new entities, one with around 50 attributes.
so you modify your DB tables, which can be done quickly with phpMyAdmin, and regenerate your classes with the DO script.
Total time taken: about 10% of what it would have taken you without DataObjects.
DB_Dataobject lets you manage complex entities in your web applications by encapsulating the object data and allowing you to modify object state more easily.
DB_DataObject Version 0.3 introduced the ability to create link ini files so you can map rows to other database columns using an ini file. This ini file should have the name '(databasename).links.ini', and be placed in the (Seagull)/var/cache/entities/ folder.
The (databasename).links.ini file contains a section for each table, then the primary and foreign key mappings for each.
If you use a 'full stop' in the key (link from column), getLinks() will look up in the table with the field name matching the string to the left of the 'full stop', and replace the 'full stop' with an underscore and assign the object variable to that name. Or you may wish to use the selectAs() method to decide how you want columns from different objects to be returned, when using joinAdd().
; for table person [person] ; link value of eyecolor to table colors, match name column eyecolor = colors:name ; link value of owner to table grp, match id column owner = grp:id ; link value of picture to table attachments, match id column picture = attachments:id ; for a sales example with multiple links of a single column [sales] ; for autoloading the car object into $sales->_car_id car_id = car:id ; for autoloading the part number object into $sales->_car_id_partnum car_id.partnum = part_numbers:car_id
$person = new DataObjects_Person();
$person->eyeColour = 'red';
$person->find();
while ($person->fetch()) {
// use the links.ini file to automatically load // the car object into $person->_car $person->getLinks();
echo "{$person->name} has red eyes and owns a {$person->_car->type}\n";
}
// and finally the most complex, using SQL joins and select as. // the example would look like this.
$person = new DataObjects_Person(); $person->eyeColour = 'red';
// first, use selectAs as to make the select clauses match the column names. $person->selectAs();
// now lets create the related element $car = new DataObjects_Car();
// and for fun.. lets look for red eys and red cars.. $car->colour = 'red';
// add them together. $person->joinAdd($car);
// since both tables have the column id in them, we need to reformat the query so // that the car columns have a different name. $person->selectAs($car,'car_%s');
$person->find();
while ($person->fetch()) {
echo "{$person->name} has red eyes and owns a {$person->car_type}\n";
}
documented on: 2007.01.26