How to apply open-closed principle when creating objects

Question

I'm busy parsing xml documents (google docs api) and putting individual documents into objects.

There are different types of documents (documents, spreadsheets, presentations). Most information about these documents is the same, but some is different.

The idea was to create a base document class which holds all the shared information, while using subclasses for each specific document type.

The problem is creating the right classes for the different types. There are two ways to differentiate the type of the document. Each entry has a category element where I can find the type. Another method that will be used is by the resourceId, in the form of type:id.

The most naive option will be to create an if-statement (or switch-statement) checking the type of the entry, and create the corresponding object for it. But that would require to edit the code if a new type would be added.

Now i'm not really sure if there is another way to solve this, so that's the reason I'm asking it here. I could encapsulate the creation of the right type of object in a factory method, so the amount of change needed is minimal.

Right now, I have something like this:

public static function factory(SimpleXMLElement $element)
{
    $element->registerXPathNamespace("d", "http://www.w3.org/2005/Atom");
    $category = $element->xpath("d:category[@scheme='http://schemas.google.com/g/2005#kind']");

    if($category[0]['label'] == "spreadsheet")
    {
        return new Model_Google_Spreadsheet($element);
    }
    else
    {
        return new Model_Google_Base($element);
    }
}

So my question is, is there another method I'm not seeing to handle this situation?

Edit: Added example code

Answer 1

Updated answer with your code example

Here is your new factory :

public static function factory(SimpleXMLElement $element)
{
    $element->registerXPathNamespace("d", "http://www.w3.org/2005/Atom");
    $category = $element->xpath("d:category[@scheme='http://schemas.google.com/g/2005#kind']");
    $className = 'Model_Google_ '.$category[0]['label'];
    if (class_exists($className)){
       return new $className($element);
    } else {
        throw new Exception('Cannot handle '.$category[0]['label']);
    }
}

I'm not sure that I got exactly your point... To rephrase the question, I understood "how can I create the right object without hardcoding the selection in my client code"

With autoload

So let's start with the base client code

class BaseFactory
{
    public function createForType($pInformations)
    {
       switch ($pInformations['TypeOrWhatsoEver']) {
           case 'Type1': return $this->_createType1($pInformations);
           case 'Type2': return $this->_createType2($pInformations);
           default : throw new Exception('Cannot handle this !');
       }
    }
}

Now, let's see if we can change this to avoid the if / switch statments (not always necessary, but can be)

We're here gonna use PHP Autoload capabilities.

First, consider the autoload is in place, here is our new Factory

class BaseFactory
{
    public function createForType($pInformations)
    {
       $handlerClassName = 'GoogleDocHandler'.$pInformations['TypeOrWhatsoEver'];
       if (class_exists($handlerClassName)){
           //class_exists will trigger the _autoload
           $handler = new $handlerClassName();
           if ($handler instanceof InterfaceForHandlers){
               $handler->configure($pInformations);
               return $handler;
           } else {
               throw new Exception('Handlers should implements InterfaceForHandlers');
           }
       }  else {
           throw new Exception('No Handlers for '.$pInformations['TypeOrWhatsoEver']);
       }
   }
}

Now we have to add the autoload capability

class BaseFactory
{
    public static function autoload($className)
    {
        $path = self::BASEPATH.
                $className.'.php'; 

        if (file_exists($path){
            include($path); 
        }
    }
}

And you just have to register your autoloader like

spl_autoload_register(array('BaseFactory', 'autoload'));

Now, everytime you'll have to write a new handler for Types, it will be automatically added.

With chain of responsability

You may wan't to write something more "dynamic" in your factory, with a subclass that handles more than one Type.

eg

class BaseClass
{
    public function handles($type);
}
class TypeAClass extends BaseClass
{
    public function handles($type){
        return $type === 'Type1';
    }
}
//....

In the BaseFactory code, you could load all your handlers and do something like

class BaseFactory
{ 
    public function create($pInformations)
    {
        $directories = new \RegexIterator(
            new \RecursiveIteratorIterator(
                new \RecursiveDirectoryIterator(self::BasePath)
            ), '/^.*\.php$/i'
        );

        foreach ($directories as $file){
            require_once($fileName->getPathName());
            $handler = $this->_createHandler($file);//gets the classname and create it
            if ($handler->handles($pInformations['type'])){
                return $handler;
            }
        }
        throw new Exception('No Handlers for '.$pInformations['TypeOrWhatsoEver']);
    }
}