oxid esales - The extend parade!

In oxid esales everybody likes to extend everything.

Its a bunch of happy ox-classes that just love each other, hug eachother and extend, make out the whooooooole day.

A simple example

oxI18n extends oxBase extends oxSuperCfg

Ok, I understand that you want every happy oxid-super-object to be able to read, write, delete the config, right?

But what the heck are you doing? Did you guys ever hear about design patterns?.

Maybe you should take a look at our friends from pureMVC. They have their patterns well organized in an extra folder:

It gets even better: The Super-Extender

When you want to create an oxoutput object with the following??modules?? loaded:

sub/suboutput1&sub/suboutput2&sub/suboutput3

it magically creates / extends / parties with your classes!

It uses a kind of extension g*ngb*ng function to hook up everyone with everything:

public function getClassName( $sClassName )
{
        $aModules = $this->getConfig()->getConfigParam( 'aModules' );
        if ( is_array( $aModules ) &&
          array_key_exists( $sClassName, $aModules ) ) {
            //multiple inheritance implementation
            //in case we have multiple modules:
            //like oxoutput
               //=> sub/suboutput1&sub/suboutput2&sub/suboutput3
            $aClassChain = explode( "&", $aModules[$sClassName] );

            $sParent = $sClassName;

            //security: just preventing string termination
            $sParent = str_replace(chr(0), '', $sParent);

            //building middle classes if needed
            $sClassName =
            $this->_makeSafeModuleClassParents( $aClassChain, $sParent );
    }

 // check if there is a path, if yes, remove it
 $sClassName = basename( $sClassName );

 return $sClassName;
}

....

/**
 * Creates middle classes if needed.
*
* @param array  $aClassChain Module names
* @param string $sBaseModule Oxid base class
*
* @throws oxSystemComponentException missing system
*             component exception
*
* @return string
*/
private function _makeSafeModuleClassParents( $aClassChain, $sBaseModule )
{
  $myConfig = $this->getConfig();
  $sParent = $sBaseModule;

  //building middle classes if needed
  foreach ($aClassChain as $sModule) {
     //creating middle classes
     //e.g. class suboutput1_parent extends oxoutput {}
     //     class suboutput2_parent extends suboutput1 {}
     //$sModuleClass = $this->getClassName($sModule);

    //security: just preventing string termination
    $sModule = str_replace(chr(0), '', $sModule);

    //get parent and module class names from sub/suboutput2
    $sParentClass = basename($sParent);
    $sModuleClass = basename($sModule);

    //P
    //$sInitClass = "class ".$sModuleClass."_parent extends $sParentClass
    //{ function ".$sModuleClass."_parent(){
    // return ".$sParentClass."::".$sParentClass."();} }";
    $sInitClass = "class ".$sModuleClass."_parent extends $sParentClass {}";

    //initializing middle class
    if (!class_exists($sModuleClass."_parent", false)) {
       eval($sInitClass);
    }
   $sParentPath = $myConfig->getConfigParam( 'sShopDir' ).
                              "/modules/".$sModule.".php";

   //including original file
   if ( file_exists( $sParentPath ) ) {
	require_once $sParentPath;
   } elseif ( !class_exists( $sModuleClass ) ) {
        //to avoid problems with unitest and only throw a
        // exception if class does not exists MAFI
	$oEx = new oxSystemComponentException();
	$oEx->setMessage('EXCEPTION_SYSTEMCOMPONENT_CLASSNOTFOUND');
	$oEx->setComponent($sModule);
   }

   $sParent = $sModule;
 }

   //returning the last module from the chain
   $sClassName = $aClassChain[count($aClassChain) - 1];
   return $sClassName;

}

So … with all the magic party stuff you end up having created / included these classes, all done by their wonderful __autload function:

• class oxoutput extends oxSuperCfg { … }
• class suboutput1_parent extends oxoutput {}
• class suboutput2_parent extends suboutput1 {}
• class suboutput3_parent extends suboutput2 {}

But what the hell is this stuff for?

A module like MyOrder extends MyOrder_parent. For what? Somebody enlighten me!

You extend non-existing classes just for the sake of creating them from the magic __autoload function, is that it?

Related post:

oxid esales – show me your 94% Unit Test coverage!

About these ads