final classes

[ShurikAg]

Hi,

We are using this library for our project and we came across an issue that blocks us from extending the functionality and in particular the fact that quite a few classes defined as final.

What is the actual reason for these classes to be final?

[avalanche123]

Sure, here is a blog post where I summarize it http://avalanche123.com/blog/2011/03/15/how-to-write-clean-code/

[ShurikAg]

There are some discrepancies in what you are saying in your post. Well, how can you talk about extendible if all of your public interface is final???

Quote (http://php.net/manual/en/language.oop5.final.php) : "If the class itself is being defined final then it cannot be extended."

And by the way it have nothing to do with TDD. You testing your implementation, I, as a client of your library will test it's extensions. Extending a class doesn't mean changing the existing one...

[avalanche123]

Can you elaborate on why you need to extend any of classes I provide?
Also, inheritance is not the only way to extend functionality, all final classes in Imagine have a corresponding interface. I encourage you to implement these interfaces in your own classes if you need to change behavior of default implementations.
http://en.wikipedia.org/wiki/Composition_over_inheritance

[romainneutron]

Hello @ShurikAg

There are many ways to extend the library, inheritance is one of them, composition is another way.
Why don't you explain you actual problem / project ?

[ShurikAg]

OK, there is a case in out app that we need to have some more details in the Image object (such as original mimeType) for further validation purposes.
Of coarse, we could do some workarounds, and pass get the mimeType from somewhere else, but in our case we designed a validator engine based on decorator design pattern and this engine is build to accept Image object.

@avalanche123 we don't need to change the functionality, we need to add/extend it... That is what extension is about, right?

[avalanche123]

@ShurikAg please refrain from snarky comments if you want to keep this conversation productive and have this issue resolved.

To resolve your issue, please provide some more details on how you are accomplishing this task - show me how you would like to extend the image class so we can work out if this is a case where we need to reopen the class for extension or if we can use composition instead.

If you feel decisions I made while building Imagine were wrong, there were, what I believed to be, good reasons for them. It might be time to re-evaluate them.

P.S. my previous comment above said "extend functionality", not "change functionality" as you've read it.

[ShurikAg]

Sure, what I'm trying to do is to add a single private field into the Image type of object and getter and setter methods.

The way I initially planned o do it is by extending an Image class.
Now, in order to make this work I would also extend Imagine class and overwrite wrap method to return CustomImage, but wrap is private...

Ideally, it would be nice to have an ability to inject configuration of the Image class name to create (or something similar).

At this point I am forced to create a wrapper class containing and Image object in it as a property. But, in this case, instead of simply operating on the public interface of the Image class I have to either get the image object from the wrapper or create a proxy methods for each and every method I might need for the Image class.

If I could easily change the object type that gets created by the Imagine class (of coarse, been ImageInterface) I could use the same object as is within the context of our app without adding any complexity...

Hoep that helps...

[avalanche123]

Here is how I would do it:

<?php

interface MyImageInterface
{
    function getMimeType();
}

class MyImageClass implements MyImageInterface, Imagine\Image\ImageInterface
{

    private $mimeType;
    private $image;

    public function __construct(Imagine\Image\ImageInterface $image, $mimeType)
    {
        $this->image = $image;
        $this->mimeType = $mimeType;
    }

    public function getMimeType()
    {
        return $this->mimeType;
    }

    public function get($format, array $options = array())
    {
        return $this->image->get($format, $options);
    }

    public function __toString()
    {
        return $this->image->__toString();
    }

    public function draw()
    {
        return $this->image->draw();
    }

    public function effects()
    {
        return $this->image->effects();
    }

    public function getSize()
    {
        return $this->image->getSize();
    }

    public function mask()
    {
        return new MyImageClass($this->image->mask(), $this->mimeType);
    }

    public function histogram()
    {
        return $this->image->histogram();
    }

    public function getColorAt(PointInterface $point)
    {
        return $this->image->getColorAt($point);
    }

    public function copy()
    {
        return new MyImageClass($this->image->copy(), $this->mimeType);
    }

    public function crop(PointInterface $start, BoxInterface $size)
    {
        $this->image->crop($start, $size);

        return $this;
    }

    public function resize(BoxInterface $size)
    {
        $this->image->resize($size);

        return $this;
    }

    public function rotate($angle, Color $background = null)
    {
        $this->image->rotate($angle, $background);

        return $this;
    }

    public function paste(ImageInterface $image, PointInterface $start)
    {
        $this->image->paste($image, $start);

        return $this;
    }

    public function save($path, array $options = array())
    {
        $this->image->save($path, $options);

        return $this;
    }

    public function show($format, array $options = array())
    {
        $this->image->show($format, $options);

        return $this;
    }

    public function flipHorizontally()
    {
        $this->image->flipHorizontally();

        return $this;
    }

    public function flipVertically()
    {
        $this->image->flipVertically();

        return $this;
    }

    public function strip()
    {
        $this->image->strip();

        return $this;
    }

    public function thumbnail(BoxInterface $size, $mode = self::THUMBNAIL_INSET)
    {
        return new MyImageClass($this->image->thumbnail($size, $mode), $this->mimeType);
    }

    public function applyMask(ImageInterface $mask)
    {
        $this->image->applyMask($mask);

        return $this;
    }

    public function fill(FillInterface $fill)
    {
        $this->image->fill($fill);

        return $this;
    }
}

class MyImagine implements Imagine\Image\ImagineInterface
{
    private $imagine;

    public function __construct(Imagine\Image\ImagineInterface $imagine)
    {
        $this->imagine = $imagine;
    }

    public function create(BoxInterface $size, Color $color = null)
    {
        // determine image's mime type here
        $mimeType = "some mime type";

        return new MyImageClass($this->imagine->create($size, $color), $mimeType);
    }

    public function open($path)
    {
        // determine image's mime type here
        $mimeType = "some mime type";

        return new MyImageClass($this->imagine->open($path), $mimeType);
    }

    public function load($string)
    {
        // determine image's mime type here
        $mimeType = "some mime type";

        return new MyImageClass($this->imagine->load($string), $mimeType);
    }

    public function read($resource)
    {
        // determine image's mime type here
        $mimeType = "some mime type";

        return new MyImageClass($this->imagine->read($resource), $mimeType);
    }

    public function font($file, $size, Color $color)
    {
        return $this->imagine->font($file, $size, $color);
    }
}

Does this make sense?

[ShurikAg]

It does and that is exactly what I eventually did, but I am just not sure if that is the right way to do it if it could be much simpler by extending the class?

[avalanche123]

I agree, that PHP doesn't make it easy to build typed proxies, I keep image implementations final to be able to change them without breaking third party code that relies on existing implementation. I am open to changing this if enough people weigh in

[romainneutron]

Hello, another way to proxify would be such code :

public function __call($method, $args)
{
    return call_user_func_array(array($this->image, $method), $args);
}

Romain

On 15 nov. 2012, at 09:06, Bulat Shakirzyanov notifications@github.com
wrote:

Here is how I would do it:

image = $image; $this->mimeType = $mimeType; } public function getMimeType() { return $this->mimeType; } public function get($format, array $options = array()) { return $this->image->get($format, $options); } public function __toString() { return $this->image->__toString(); } public function draw() { return $this->image->draw(); } public function effects() { return $this->image->effects(); } public function getSize() { return $this->image->getSize(); } public function mask() { return new MyImageClass($this->image->mask(), $this->mimeType); } public function histogram() { return $this->image->histogram(); } public function getColorAt(PointInterface $point) { return $this->image->getColorAt($point); } public function copy() { return new MyImageClass($this->image->copy(), $this->mimeType); } public function crop(PointInterface $start, BoxInterface $size) { $this->image->crop($start, $size); return $this; } public function resize(BoxInterface $size) { $this->image->resize($size); return $this; } public function rotate($angle, Color $background = null) { $this->image->rotate($angle, $background); return $this; } public function paste(ImageInterface $image, PointInterface $start) { $this->image->paste($image, $start); return $this; } public function save($path, array $options = array()) { $this->image->save($path, $options); return $this; } public function show($format, array $options = array()) { $this->image->show($format, $options); return $this; } public function flipHorizontally() { $this->image->flipHorizontally(); return $this; } public function flipVertically() { $this->image->flipVertically(); return $this; } public function strip() { $this->image->strip(); return $this; } public function thumbnail(BoxInterface $size, $mode = self::THUMBNAIL_INSET) { return new MyImageClass($this->image->thumbnail($size, $mode), ``` $this->mimeType); } ``` public function applyMask(ImageInterface $mask) { $this->image->applyMask($mask); return $this; } public function fill(FillInterface $fill) { $this->image->fill($fill); return $this; }} ``` class MyImagine implements Imagine\Image\ImagineInterface{ private $imagine; ``` public function __construct(Imagine\Image\ImagineInterface $imagine) { $this->imagine = $imagine; } public function create(BoxInterface $size, Color $color = null) { // determine image's mime type here $mimeType = "some mime type"; return new MyImageClass($this->imagine->create($size, $color), ``` $mimeType); } ``` public function open($path) { // determine image's mime type here $mimeType = "some mime type"; return new MyImageClass($this->imagine->open($path), $mimeType); } public function load($string) { // determine image's mime type here $mimeType = "some mime type"; return new MyImageClass($this->imagine->load($string), $mimeType); } public function read($resource) { // determine image's mime type here $mimeType = "some mime type"; return new MyImageClass($this->imagine->read($resource), $mimeType); } public function font($file, $size, Color $color) { return $this->imagine->font($file, $size, $color); }} ``` Does this make sense? — Reply to this email directly or view it on GitHubhttps://github.com//issues/162#issuecomment-10400262.

[ShurikAg]

@romainneutron Sure, but this is kind of PHP "black magic" that I am personally trying to avoid...

[avalanche123]

magic methods won't work as you won't be able to implement correct interfaces unless you have those methods defined explicitly