Weird behavior

[unpococloco]

when using the old version of PHPMailer for PHP 5.x, I've always had the require() and use namespace statements contained in a config file required at the top of every page. This is what these statements look like in the config file:

`
require_once( CLASSES . "PHPMailer/src/PHPMailer.php" ); // PHPMailer framework object
require_once( CLASSES . "PHPMailer/src/Exception.php" ); // PHPMailer framework exceptions object
require_once( CLASSES . "PHPMailer/src/SMTP.php" ); // PHPMailer framework SMTP object

use PHPMailer\PHPMailer\PHPMailer;
use PHPMailer\PHPMailer\SMTP;
use PHPMailer\PHPMailer\Exception;
`
Since updating to your newest version, I have isolated the following behavior:

When I put the use statements in my config file, I get a error stating _"The class file /home/lcudev/master/globals/classes/PHPMailer.inc cannot be found."
That error message is triggered by my own autoloader code whenever it fails to find an object class.

Yet when I move the use statements to the calling page and place them underneath the require() statement loading the aforementioned config page as shown below, everything works perfectly.
`
require_once( "../_globals/_config.inc" );

use PHPMailer\PHPMailer\PHPMailer;
use PHPMailer\PHPMailer\SMTP;
use PHPMailer\PHPMailer\Exception;

`

What's up with that and how can I fix it?

PHP 7.3.30
PHPMailer 6.5.0
Linux server

[unpococloco]

The following is in production code working perfectly under the old version of PHPMailer. It is located in an external file invoked into each page by a require_once() statement:
use PHPMailer\PHPMailer\PHPMailer; use PHPMailer\PHPMailer\Exception;

So why is it working there and not in my new code using the selfsame mechanism?

[Synchro]

Because PHPMailer 5 does not use a namespace, so those use statements do nothing at all.

[Synchro]

I also note that the error says PHPMailer.inc, when there is no such file in PHPMailer. You might mean PHPMailer.php.

[unpococloco]

Your first statement explains everything.

Yes, the error says .inc instead of .php. That is my own autoloader function saying, "HUH!?" when PHPMailer fails to autoload. The function currently assumes a .inc extension when it issues its error msg. Am working on getting composer to work so I can eliminate the namespace declarations outright.

[unpococloco]

I've removed all the name space statements as well as the require statements for PHPMailer, Exception, and SMTP.

I have the following line in my config file:

require_once( VENDOR_DIR . "autoload.php" ); // invoke composer autoload
where VENDOR_DIR is the path to the composer directory.

PHPMailer has been installed in the VENDOR_DIR directory.

No joy! my revised error msg says The class file PHPMailer cannot be found using .inc or .php file extensions.

What am I missing here?

Sorry for the stupid questions. I struggle using frameworks.

[Synchro]

I would immediately be suspicious of what's in VENDOR_DIR; it's normal to not include a trailing slash in directory names, so simply appending autoload.php is likely to result in a nonexistent path. It's also entirely normal to keep your vendor directory in the root of your project, so VENDOR_DIR would effectively be ..

require_once is generally an antipattern; it suggests that you don't have full control or awareness of how your class loading process works.

Note that you probably don't need to use the SMTP class because you're very unlikely to need to access it directly in typical PHPMailer usage.

You need the use statements in the file that you are loading from, not the autoloader.

So with all that in mind, your script might look like:

use PHPMailer\PHPMailer\PHPMailer;
use PHPMailer\PHPMailer\Exception;

require VENDOR_DIR . '/autoload.php';

$mail = new PHPMailer();

You'll see that this is essentially what all the PHPMailer code examples look like.

[unpococloco]

So I am stuck with those 'use' statements in the body of every single page and cannot put them into a reusable code file which can be invoked all the pages in 5+ websites sharing that same code? What a ridiculous limitation!

This is my statement defining VENDOR_DIR:
define( "VENDOR_DIR", "/home/domainname/vendor/" ); // the vendor directory for this domain

I indeed have an excellent handle on my loading process. I got into the habit of using require_once() when I was a beginner and simply use it out of habit.

Finally, if I am sending an email using SMTP, why would I not need to use PHPMailer's SMTP object?

[Synchro]

You don't have to use use statements at all; you can use fully-qualified class names instead, such as $mail = new \PHPMailer\PHPMailer\PHPMailer();, but that gets messy, so use statements let you alias those long names. If you wrap your PHPMailer sending code in a function in a separate file then you only need the use statements in that file; duplicating code across many files is also an antipattern ("DRY").

What I said was that you probably don't need to use the SMTP class directly. PHPMailer may use it internally, but when it does so, it's done from within its own namespace, so doesn't need a use statement to qualify it.

[unpococloco]

Once I put the use statements back into the file, it works flawlessly!

Thanks for the clarifications!

I wrote an Email object which facilitates the creation and sending of our organization-specific HTML emails via various mail-merge-type templates. Right now, I have to pass it an instantiated PHPMailer object in the constructor as follows:

Here is the test code which I just successfully ran using my Email object + PHPMailer:

	require_once( "../_globals/_config.inc" );

	use PHPMailer\PHPMailer\PHPMailer;
	use PHPMailer\PHPMailer\Exception;

	$mailer_object = new PHPMailer();
	$email 		   = new Email( NULL, $mailer_object );

	$email->setTo(  		DEV_ADDR, DEV_NAME );
	$email->setCc(  		DEV_ADDR, DEV_NAME );
	$email->setBcc( 		DEV_ADDR, DEV_NAME );
	$email->setSubject( 	"Test Message" );
	$email->setTitle( 		"Generic Message" );
	$email->setPersonName( 	"Dr. Mark S. Willis" );
	$email->setPersonID( 	848 );
	$email->setGenericText( "Mary had a little lamb, the doctor was surprised!" );
	
	if( $email->send() )
		echo "success!";
	else
		echo "failed!";

After I have built the HTML email body and its generic text counterpart using private methods in this object and selected the appropriate Subject line for said template, its own send() methodI transfers all the necessary values to the PHPMailer object which then uses its own send() method to actually send the msg.

Like I said, once we resolved the PHPMailer calls, it works great!

You mentioned placing the use statements and PHPMailer instantiation inside a function to make them reusable. Is there a way to somehow use my object's constructor as that function? Something along the following lines:

function __construct( ?string $template_type = NULL ) {
	use PHPMailer\PHPMailer\PHPMailer;
	use PHPMailer\PHPMailer\Exception;

	// if $template_type has no value, default to a generic message
	$this->template_type = empty( $template_type ) ? GENERIC_MSG : $template_type; // set the template type

	self::$mailer_object = new PHPMailer();
} 	// end constructor

-OR-

function __construct( ?string $template_type = NULL ) {

	// if $template_type has no value, default to a generic message
	$this->template_type = empty( $template_type ) ? GENERIC_MSG : $template_type; // set the template type

	self::$mailer_object = new PHPMailer\PHPMailer\PHPMailer();
} 	// end constructor

instead of the current code:

function __construct( ?string $template_type = NULL, $email_object = NULL ) {

	// if $template_type has no value, default to a generic message
	$this->template_type = empty( $template_type ) ? GENERIC_MSG : $template_type; // set the template type
			
	// instanciate a PHPMailer object
	if( empty( $email_object ) )
		die( "Missing PHPMailer Object" );
	else
		self::$email_msg = $email_object;
} 	// end constructor

One final question regarding the use statement: I thought whenever you include() or require() an external file, the code contained therein is inserted into the calling file and the resulting aggregate code is then executed after all inclusions have been completed. If this the way things happen, why does the use statement break when placed in an include() file? How would the interpreter even know an include() file was in play once the code has been inserted?

[Synchro]

No, I said to put the use statements in the file, not the function. Convention is to put all use statements at the top of the file. If you use an IDE it will keep them all tidy for you.

Regarding compilation, all that happens before the file is inserted, so the use statements are used to qualify all the namespaced things you're using, before its functionality is pulled into the including file, so it's more compile-then-merge than the reverse.

I think I mentioned before that use statements are local to the file they appear in. use statements are probably simpler than you think - think of them as short names for things with long names, and that's about all there is to them. This is also why it doesn't matter if the things they refer to exist or not; if I say use thingy\banana; it will be completely benign and do nothing until I happen to try to instantiate a class called banana, at which point PHP will go, "oh you mean thingy\banana".

What might not be apparent is that this:

use thingy\banana;

is exactly equivalent to:

use thingy\banana as banana;

and this syntax is used for aliasing, like this:

use thingy\banana as fruit;
$f = new fruit();

which will create an instance of the namespaced thingy\banana class using a different name. Why we want to do that is so you can do this:

use thingy\banana;
use yoda\sardine\banana as yuck;
$f = new banana();
$g = new yuck();

so we get to use two different classes that are both called banana in their own namespaces without them clashing.

HTH

[unpococloco]

Thank you for the most succinct explanation of namespaces I've read to date. I think I've finally grasped the concept, the best practices for coding them, and why they cannot be contained within an object.

[decomplexity]

With your ‘all the pages in 5+ websites sharing that same code’ you might find the decomplexity/SendOauth2 wrapper for PHPMailer worth a look, especially if you use (or plan to use) OAuth2 authentication, although basic authentication is also supported. It is installed with Composer and has its own namespace.

[unpococloco]

Our mailserver is not currently configured for OAuth, though I could be mistaken. That info is outside my "mushroom." :-)

[unpococloco]

As it turns out, this one actually works!

function __construct( ?string $template_type = NULL ) {

	// if $template_type has no value, default to a generic message
	$this->template_type = empty( $template_type ) ? GENERIC_MSG : $template_type; // set the template type

	self::$email_msg = new PHPMailer\PHPMailer\PHPMailer();
} 	// end constructor

but I would still appreciate an answer to my question about include() files.

[Synchro]

That syntax will only work because you don't have a namespace in your own file. If you did this:

namespace my\namespace;
function __construct( ?string $template_type = NULL ) {

	// if $template_type has no value, default to a generic message
	$this->template_type = empty( $template_type ) ? GENERIC_MSG : $template_type; // set the template type

	self::$email_msg = new PHPMailer\PHPMailer\PHPMailer();
} 	// end constructor

this code will fail because it will try to create an instance of my\namespace\PHPMailer\PHPMailer\PHPMailer, which doesn't exist. You would need to change that line to:

self::$email_msg = new \PHPMailer\PHPMailer\PHPMailer();

note the leading \ that makes it reference the global namespace, much like an absolute file path.

BTW, the mapping of class names to files is mostly defined by a convention called PSR-4, and composer uses that a lot.

[unpococloco]

Is there any reason why my constructor just posted (it does work) would be considered bad practice?

[Synchro]

Not really, but if you added a namespace in this file at some later point, the constructor would break even though its code hadn't changed, so I'd recommend either adding that leading \, or adding a use statement for PHPMailer at the top of the file just as a robustness measure.

[unpococloco]

I appreciate your kindness and patience as you walked me through this. You filled in some badly understood blanks for me and I feel confident on how to move forward on this. Thank you!