Trouble in Zend Framework Land?

[arborint]

I noticed this recently in Joshua Eichorn's blog ZActiverecord Can't Work and the comment by Mike Naberezny who seems to be involved in the implementation.

The desire for static calls is interesting. I know it has been discussed here that static calls are not that desireable. It makes me wonder how thoughtful the peer review is.

Beside that, there is definitely a sense that they are bumping up against the limitations of PHP. I wonder about ZController which has not been mentioned at all.

Also note the framework-feedback@zend.com email address. Nothing to give feedback on yet, but there's an email address.

[Ren]

Yeah, I posted the debug_backtrace() hack as bit of a joke, not having seen Mike's comment. And lo and behold, seem they have thought of using something similar.

Seems quite good thou Zend doing a framework, sometimes get the feeling alot of the PHP developers just develop the language, and do little in PHP itself.
Probably an unfair comment, but does seem that way, when you hit some odd limitation you wonder why.

[jayboots]

The desire for static calls is interesting. I know it has been discussed here that static calls are not that desireable. It makes me wonder how thoughtful the peer review is.

...or maybe it is a reflection of the thoughtfulness of the peer review here? Static calls are useful in many situations and like any other technique, involve trade-offs. Sure, they can be misused and then appear to be "undesirable" -- but so can any technique.

[Dr Livingston]

To say that there is trouble is an exaggeration; PHP is a dynamic language - there is always a solution

[arborint]

Yeah, I posted the debug_backtrace() hack as bit of a joke, not having seen Mike's comment. And lo and behold, seem they have thought of using something similar.

I saw that and I think it showed how far they have gone to try to make it work.

Seems quite good thou Zend doing a framework, sometimes get the feeling alot of the PHP developers just develop the language, and do little in PHP itself.
Probably an unfair comment, but does seem that way, when you hit some odd limitation you wonder why.

I get the sense that maybe one of the contributing companies had an ActiveRecord implementation that worked for them, so they got everyone excited. But when they actually tried to implement it without the constraints that the contributor had tolerated -- it is not working as well as planned.

This all gives me some worries about the Controller architecture. I think it is the most critical part to make their framework actually work.

[arborint]

To say that there is trouble is an exaggeration; PHP is a dynamic language - there is always a solution

Apparently it is going to have to continue to be dynamic to find a solution.

[33degrees]

I managed to solve this problem in my own framework, by using a little class I call "this"

/**
 * Helper class for working with static method calls
 *
 * @package library
 */
class this {
    
    /**
     * Returns the name of the class that called 'this'
     *
     * @return string
     */
    function class_name() {
        $trace = debug_backtrace();
        
        foreach($trace as $call) {
            if (isset($call['class']) && $call['class'] != __CLASS__) {
                return $call['class'];    
                
            }
        }
        
        return false;
        
    }
    
    /**
     * Returns an array containing all the variables defined in the calling class
     *
     * @return array
     */
    function get_vars() {
        return get_class_vars(this::class_name());
        
    }
    
    /**
     * Returns the value of a particular variable in the calling class. Returns
     * null if it doesn't exist
     *
     * @return mixed
     */
    function get_var($var_name) {
        $vars = this::get_vars();
        
        if (isset($vars[$var_name])) {
            return $vars[$var_name];    
        } else {
            return null;
        }
    }

    /**
     * Returns true if the variable exists in the calling class.
     *
     * @return bool
     */
    function var_exists($var_name) {
        $vars = this::get_vars();
        
        return isset($vars[$var_name]);
        
    }
    
    /**
     * Returns an array of all the methods defined in the calling class
     *
     * @return array
     */    
    function get_methods() {
        return get_class_methods(this::class_name());    
        
    }
    
    /**
     * Returns true if the method exists in the calling class.
     *
     * @param string $method_name
     */
    function method_exists($method_name) {
        $methods = this::get_methods();
        
        return in_array($method_name, $methods);
    }
    
    /**
     * Calls a static function in the calling class. All the parameters
     * are passed to the function, as in call_user_func
     *
     * @param string $method_name
     * @param mixed $args,...
     * @return mixed
     */
    function call($method_name) {
        $args = func_get_args();
        array_shift($args);
        
        return call_user_func_array(array(this::class_name(), $method_name), $args);
        
    }
    
    /**
     * Calls a static function in the calling class. The args array
     * is passed to the function, as in call_user_func_array
     *
     * @param string $method_name
     * @param array $args
     * @return mixed
     */    
    function call_array($method_name, $args) {
        return call_user_func_array(array(this::class_name(), $method_name), $args);
        
    }
    
} 

and a little test case

class ThisTester extends UnitTestCase {

    var $test = 'hello';
    
    function test_all() {
        
        $this->assertEqual(this::class_name(), __CLASS__);    
        
        $this->assertEqual(this::get_var('test'), 'hello');        

        $this->assertTrue(this::call('call_me'));

        $this->assertEqual(this::call('call_me', 'test'), 'test');
        
        $this->assertEqual(this::call('math', 1, 10, 100), 111);
        
        $this->assertEqual(this::call_array('math', array(2, 20, 200)), 222);
        
        $this->assertTrue(this::method_exists('run'));
        
        $this->assertFalse(this::method_exists('foo'));
    }

    function call_me($param = true) {
        return $param;    
    }
    
    
    function math($one, $two, $three) {
        return $one + $two + $three;
        
    }
    
} 

Usage should be clear, but here's some code from my finder method

            // find a single id                
            $options['conditions'] .= this::call('table_name').".".this::get_var('id_field')." = '".$ids[0]."'";
            
            $result = this::call('find', 'all', $options); 

Say what you will about using this kind of hack, "this" works

[Ezku]

I managed to solve this problem in my own framework, by using a little class I call "this"

That's actually very interesting. It's a hack, obviously, but are there any concrete drawbacks to the solution? Mainly, how fast is this::class_name() when it uses debug_backtrace() to do its thing?

[33degrees]

A quick benchmark using the following methods, the average of 10 000 calls each

return __CLASS__: 0.025 ms
return get_class($this): 0.037 ms
return this::class_name(): 0.214 ms

so it's an order of magnitude slower, but it's still a miniscule amount. I have yet to find a significant drawback, in any case.

[lastcraft]

Hi.

SimpleTest uses a similar hack to get the location of the test failure. Every single assertion calls this method, but everything seems to run fast enough.

yours, Marcus

[JaskaS]

Maybe i'm just stupid, but how does this differ from just using __CLASS__?

class this {
    /**
     * Returns the name of the class that called 'this'
     *
     * @return string
     */
    function class_name() {
        $trace = debug_backtrace();
        
        foreach($trace as $call) {
            if (isset($call['class']) && $call['class'] != __CLASS__) {
                return $call['class'];    
                
            }
        }
        
        return false;
        
    } 
} 

class base{
    

   static function run() {
     
      echo  this::class_name();
      echo __CLASS__;
        
    }     
    
}
class test extends base{
    
}
base::run();
test::run(); 

outputs:
basebasebasebase

php version 5.1

It clearly isn't solution for that particular problem stated in first post.

[33degrees]

I don't program in PHP5, but in PHP4 your code outputs:

basebasetestbase

I can't see why it wouldn't do the same under PHP5, I'll have a look at home tonight.

[JaskaS]

This is interesting, I tried it in php4 and it really does work. In php 5 backtrace does contain only class where called function is defined, not the class where it was called from.

[mwmitchell]

That's too bad. I was hoping I could start using static finders! That's the neastest "hack" I've seen in a while.

[33degrees]

I imagine that if you remove the static keyword, it would work, although it would through an E_STRICT error.

[Dr Livingston]

Apparently it is going to have to continue to be dynamic to find a solution.

I'm sure PHP will cope with the demands of modern day web development

[Sorccu]

I imagine that if you remove the static keyword, it would work, although it would through an E_STRICT error.

No, it does not work (PHP 5.5.1).

[arborint]

(PHP 5.5.1).

[Ren]

I imagine that if you remove the static keyword, it would work, although it would through an E_STRICT error.

Nah, doesnt seem to work in PHP 5.1.2 RC.

[33degrees]

It could be that they changed debug_backtrace() so that it shows the class the contains the method rather than the class that was called. I'll look into it tonight and see if I can find another way of making it work.

[Sorccu]

Umm Oh well. I meant PHP 5.1.1, obviously

[33degrees]

I did some research, the debug_backtrace() behavior was changed in 5. I'm curious to know how Zend plan on working around this issue; are they going to give up on the static call route, or are they going to add something to the language to support it?

[Ren]

I did some research, the debug_backtrace() behavior was changed in 5. I'm curious to know how Zend plan on working around this issue; are they going to give up on the static call route, or are they going to add something to the language to support it?

I get the impression they'd like todo both, so ZPF is compatable with 5.01, but have some C solution for future versions.

Can't see how they're going to get it working suitably with 5.01 thou, grepping the source isn't a good solution, slow and would prevent distributing encoded source.

[33degrees]

I suppose the easiest thing for them to do would be to support two syntaxes. As far as a C solution, all that would be needed is a constant similar to __CLASS__, but that gives you the name of the class that was called (like __CALLED_CLASS__ ).

In any case, I find it amusing that they did the webcast using that syntax, while there is currently no way of implementing it in PHP5. Makes you wonder how much code they'd actually written at that point.

[arborint]

In any case, I find it amusing that they did the webcast using that syntax, while there is currently no way of implementing it in PHP5. Makes you wonder how much code they'd actually written at that point.

It certainly mirrors the experience in several threads here (e.g. Container, DI and Persistence) where we started out very excited and eventually ground to a halt -- with a rich understanding of the subject, no doubt -- but frustrated that no clean, complete implementation was available.