0

I have a base object (form_field_base) that is extended/inherited by other objects in the form of:

class form_field_base {
    // Lots of code
}
class form_field_text extends form_field_base {
    // Lots of code
}
class form_field_email extends form_field_text {
    // Extending the text object to update validation, and set input type="email"
}
class form_field_file extends form_field_base {
    // Lots of code, for example uploading files
}

The "form_field_base" provides helper methods that all of the form field types use, for example a html() function calls the specific object (form_field_email::html_input) to get the field, then put that in a string with the standard tag, etc.

All of these objects are used by many projects.

However, this latest project I'm working on requires the "form_field_base" object to be customised to allow the setting of some help text, a feature that no other project requires, and if future projects do, it will probably be done differently.

So how should this have be organised?

Ideally I won't have a complete copy of "form_field_base", as that would cause code duplication.

And it does seem like quite a bit of overhead to have dummy intermediate objects:

class form_field_base_common {
    // Lots of code
}
class form_field_base extends form_field_base_common {
    // By default is empty
}

class form_field_text_common extends form_field_base {
    // Lots of code
}
class form_field_text extends form_field_text_common {
    // ...
}

class form_field_email_common extends form_field_text {
    // Extending the text object to update validation, and set input type="email"
}
class form_field_email extends form_field_email_common {
    // ...
}

class form_field_file_common extends form_field_base {
    // Lots of code, for example uploading files
}
class form_field_file extends form_field_file_common {
    // ...
}

Taking that each one has it's own file, which is auto-loaded (either a from a project specific location, if it exists, or from a common folder that all projects can access)... that is already 8 files that need to be found, opened, parsed, etc, just for supporting a form.

Surly there has to be a better way?

Improve this question
2
  • have you tried private methods and data? Or what do you mean? Do you need to hide new features from descendants, ir form other projects that use the same codebase? Commented Aug 18, 2011 at 9:22
  • It's more that the "form_field_base" is already pretty large, and adding more functionality/code to it just for one little project (when it's being used by many projects) does seem to be a waste. Commented Aug 18, 2011 at 9:39

3 Answers 3

Reset to default
1

You have your inheritance chain and you want to modify the base implementation on a per project base while still keeping the common code and types (and not being forced to severely modify the existing projects).

The way to go is to decouple the common functionality from project specific customizations. Use the decorator pattern which even enables you to share customizations between projects.

You situation is for all existing projects:

A <- B <- C

A->a()
B->a(), B->b()
C->a(), C->b(), C->c()

Your new project (lets say project 1) shall have:

A1 <- B <- C

A1->a(), A1->a1(),
B->a(), B->a1(), B->b()
C->a(), C->a1(), C->b(), C->c()

The decorator pattern requires you to create a decorator for each object you want to extend (A1, B1, C1). You want the custom methods of A1 also available in your decorating B1 and C1, so you need to chain them the same way as the original classes.

A1 decorates A
B1 decorates B
C1 decorates C

A1 <- B1 <- C1

A1->a1()
B1->a1()
C1->a1()

You still want the functionality of A, B, C also in your decorating classes, so you need to create a link between each decorator and its decorating source class and delegate the appropriate methods:

A1 hosts a reference of A
B1 hosts a reference of B
C1 hosts a reference of C

A1->a() ----> $this->myA->a();
B1->a() ----> $this->myB->a();
B1->b() ----> $this->myB->b();

All custom project 1 methods are executed directly:

A1->a1() ----> $this->a1();

In your new project 1 you use then:

A1 instead of A
B1 instead of B
C1 instead of C

Your A1, B1 and C1 may be allowed to create their instances of A, B, C right in their constructor although you could pass the instances to enable multiple decorations. In that case you will need proper interfaces, lets say IA, IB, IC. Then your A1 could have the method setA(IA theA) where theA might be an exact A or even an A1 or A2 or A3 ... But this is more advanced and you will find more information by googling the decorator pattern and you perhaps need a little bit of experience with interfaces and polymorphy.

Altogether:

  1. Leave your inheritance chain as it is

  2. Create a decorator chain for each custom project

  3. Link the decorators to their original class and delegate the common functionality.

  4. Use the decorators instead of the original classes in your custom project. They are now identical to their originals plus have the additional methods you want to add.

Improve this answer
Sign up to request clarification or add additional context in comments.

1 Comment

Thanks Jens, while I've probably done things slightly differently, this is basically how I solved it... although I do find that the more I use object orientated programming, the more complicated solutions you seem to need to use (maybe that's just me though).
0

It depends what you want to do with the help text. Perhaps, though you could do it like this:

1 - Create the help text object for the purposes you desire. 2 - Create an optional constructor parameter in your form_field_base class. If set, it would be a private instance of the help text class. 3 - Inside your subclasses, check for the existence of the help text object. If it is set, perform the additional action.

Perhaps this is not suitable for what you're trying to do, though. Without being more sure, though, that's the best I could come up with!

Improve this answer

1 Comment

Thanks for your suggestion, I must admit I was hoping not to edit the existing code in this way, as while your way would allow custom help text that could be handled in (some?) different ways, I'm sure there will be other random (one off) features appearing in the future which will also need this kind of editing.
0

If you already have a nice base class for all form fields that does well without any help text, then leave it as it is. Instead, make a class that will represent a component of the form. This can be a higher level of abstraction:

abstract class FormComponent {
    public __construct(FormField $field) {
        $this->_field = $field;
    }

    public html() {
        // Here you can choose any way to integrate the field's input HTML into
        // the component's HTML. You can wrap it in a label, for example.
        return $self->_get_html() . $self->_field->html_input();
    }
}

UPDATE: You don't have to touch the form_field inheritance chain, you can leave it as it is. If you do it this way, you will have to inject your instantiated field objects into the component class like this:

$field = new form_field_email($arguments); // Whatever arguments it takes

// Here the FormComponent_Email class inherits the FormComponent class
$component = new FormComponent_Email($field);
$component->set_hint('Some hint'); // Set your help text here
$component->set_label('Enter your email');

// You can even add an error container if you wish
if ($some_email_error) {
    $component->set_error('Your email has an error!');
}

$component_html = $component->html();

Here inside the html method of the email component class you can add HTML wrapping to the field that will display the label, the hint container, the error container and everything else that you need.

Improve this answer

3 Comments

Hi Igor, this does sound very interesting... I'm just going to look at the documentation, but do you have more of an example on how this would work... if your saying that I could drop the "extends form_field_base" from the text/email/file/etc classes, so that they can somehow inherit from either that class, or another (custom) one which in turn inherits from form_field_base, then that would be great.
I have updated the answer, see the code snippet. See how you use your regular form object and pass it into the constructor of the new object.
Just wanted to say thank you for the example, in the end I didn't use this method because adding an extra wrapper to every field (the project contains a few hundred fields), but it's a good solution which may help in other projects.

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.