Modifying Custom Taxonomy Forms in WordPress

Today, I was working on a client project and needed to add a little snippet underneath a hierarchical taxonomy form that was registered on a custom post type. Unfortunately, after spending about ten minutes digging through core and googling, I couldn’t find an action hook to use. Luckily, after tracing the output a little further back, I found what I was looking for.

Continue reading “Modifying Custom Taxonomy Forms in WordPress”

Publishing A WordPress Plugin without SVN, Utilizing Ship

So just this past week, I submitted my first plugin to the WordPress.org plugin repository. Needless to say, it was an exciting (yet dull) experience! Since I’m still fairly green to professional development as a whole, there were some aspects of the .org publishing process that were confusing, so I’m writing this post in hopes that someone will find it useful. 🙂
Continue reading “Publishing A WordPress Plugin without SVN, Utilizing Ship”

Adding a custom style button in the WordPress post editor

So my title is a little misleading as what we’re creating is largely based on what your definition of a button. However, the point still stands 🙂

Here is an example of what we’ll be creating today.

Screen Shot 2015-09-21 at 5.01.02 PM
Continue reading “Adding a custom style button in the WordPress post editor”

Crafting Personalized HTML E-Mails with wpMandrill

Recently, I’ve been working on a new little side project called ToDo, a small SPA that allows you to create and manage a ToDo list. It utilizes the new WordPress JSON REST API and it’s awesome. You should definitely check it out!

Edit: ToDo in its current form has unfortunately been “closed”. While you may still find something at the link, I’m not doing anything with it, and will be replacing it with something new, hopefully, in the very near future.
Continue reading “Crafting Personalized HTML E-Mails with wpMandrill”

Why WordPress 4.2.3 should have been a non-issue.

Let me preface the following post by saying this: I am sorry if your site was affected by the WP 4.2.3 update. I’m sure nobody on the core team wanted things to break and if they could go back in time and do things differently, then I think they would.

What happened?

So for the uninformed, on July 23, 2015 the WP core team released a security update that was installed to millions of websites via automatic updates. For a lot of people, this was fine and they weren’t affected by the change. However, another group of sites (some would argue a large portion) were broken due to breaking changes in the WP Shortcode API. This isn’t a post about the shortcode API or the vulnerability though. You can read about the update on the Make WP Core blog.

Why things should not have broken.

Take this section as a grain of salt, and recognize it as my opinion. You don’t have to agree, and I don’t expect everyone too. 

I have been developing on the WordPress platform for about 3 years now. I currently work for a small digital marketing agency in Northern Kansas as the sole developer creating websites for our clients. Before I started working here,  the previous developer had built a lot of sites using premium themes from Themeforest, which as we all know, usually include a bunch of shortcodes for inserting content and functionality across the site. After doing support for a few of these clients, I quickly realized that shortcodes were not a solution for displaying content for our clients. Not only were they messy and difficult for clients to understand (in some instances) but they created a dependency that I was not comfortable with on such a widespread scale. A client accidentally deactivating a plugin could remove some core pieces of content; it was something I just wasn’t comfortable with.

I started to build out themes for our clients using _S and designs from our in house designer. I jumped onto the ACF bandwagon just before the release of v5 and have been using the Pro version on all of our clients’ sites with great success (Elliot’s commitment to backwards compatibility is another post for another time). ACF allowed me to create highly customized interfaces for our clients, while utilizing an API that would work regardless of if ACF was activated or installed (check out Bill Erickson’s post about removing dependencies from ACF). Over time, I have migrated some clients over to a more customized solution when they would come to us after having difficulty manipulating shortcodes and they have loved it.

Now I know what you’re thinking, “But Daron, using ACF ties you to a theme and that’s bad if you’re a blogger who likes flexibility!” And you’re right. Tethering some clients to a specific theme just isn’t an option, but that isn’t an excuse to build solutions that are fundamentally flawed. One of the use cases that really blew my mind, was how people were outputting and manipulating URLs via shortcode. A much better approach would have been to use custom fields and post meta and then calling that data from the theme. Another alternative would be to build a custom plugin with a simple admin interface and some custom metaboxes.

In the Make WP post, Andrew mentioned how people were using the shortcode API in ways that it was never intended for. You don’t need to look any further than the default [gallery] shortcode to see what the core team was talking about. The gallery shortcode is completely self contained. It outputs it’s own HTML and any attributes needed to attach styling to. If you’re building shortcodes to output a link to an image or to a URL, then you’re fundamentally using shortcodes in the wrong way. Using actions and filters, you can display all sorts of things in and around the_content. If you need to link a background image, you should be using the customizer or a custom field/metabox. For one, using a custom metabox is a vastly superior UX as well as giving you the peace of mind that sites won’t break because of a fundamentally flawed implementation. The shortcode codex entry does not mention using shortcodes as a replacement for HTML attributes and it probably never will. If you’re site needs to be that customizable, you should be using custom fields and metaboxes.

If you want to remove the theme dependency from solutions like ACF and CMB2, use a hook and display that data programatically. This is a totally valid way to show custom content:

<?php
add_filter( 'the_content', function( $content ){
$extra_content = get_post_meta( 'extra_content', $post->ID );
if ( ! empty($extra_content ) )
return $content . $extra_content ;
else
return $content;
}, 10, 1 );

Just pop that into a plugin file and you’re off to the races. If you need more programatic control over where content is displayed, then you should look into developing a custom theme or using a more inclusive shortcode. Note, the $extra_content variable should include all of the HTML necessary to support itself. You can enqueue CSS as needed from the plugin as well.

Here is another example that was specifically mentioned in the Make WP article and a workaround that doesn’t require hacking a theme.

<?php
add_filter( 'the_content', function( $content ){
// Just pretend you have a custom metabox that saves the ID for you.
$image_id = get_post_meta( 'custom_image', $post->ID );
$image_src = ''; // instantiate variable
if ( !empty( $image_id ) ){
$image_src = wp_get_attachment_image_src( $image_id, 'large');
}
if ( !empty( $image_src ) ){
return "<div class='has-bg-image' style='background-image: url(\" {$image_src} \" );'>" . $content . "</div>";
}
// fallback for if there is no image
return $content;
}, 10, 1 );

Using the above snippet, you can wrap the_content in a div and apply a background image to that div. Using CSS you can further position the image how you want. You can even include that CSS in the same plugin, thus removing any theme dependency.

In closing

We as developers are responsible for when things break and it’s only in our best interest to use the tools that we are given to build applications and solutions that will stand the test of time. Hacking APIs is never a good solution to a problem and it’s up to us to use some common sense and read the documentation on the intended uses of the software that we leverage everyday. Sure, people will always find new ways to use software that the developers never intentioned, however, you do not have the right to be upset when you’ve implemented an unofficial workaround for a problem that is easily solved by utilizing other techniques and APIs. The core team did everything they could to avoid breaking things. Problem is, it’s impossibly to foresee every possible unofficial use-case for every API in the software. Stop giving them flack for your experimental implementations of the API.

I know this probably seems like a disorganized rant, and in some ways, it probably is, but I needed to get it out there and off of my mind. Leave a comment if you want to continue the discussion or you can tweet me @Daronspence

An Ode to More Blogging & WordPress 4.2

Like a lot of other folks in the community, I think the new year (ha! It’s April!) is a great time to make new goals in how we approach our daily lives. So in the spirit of the community, I’m going to try and blog more this year. I’m gonna shoot for a minimum of once a week, though I would like to make it 3+ times a week.

If you happen to be reading this, tweet me some encouragement! I would love to hear it 🙂

As a side note, I’m going to start running the WordPress beta plugin on this site. Should be exciting!

Video: Nested Repeater Fields & Restaurant Menus

If you’re interested in using Advanced Custom Fields ( ACF ) to create a restaurant menu, check out the video tutorial I made! You’ll learn about ACF and how to use a repeater field to loop over your user’s inputted data. Leave a comment if you’re interested in seeing more. Suggestions are welcome! 🙂

Lessons learned from writing a premium WordPress plugin

About 3 months ago, I had a killer idea for a WordPress plugin. I had never written a plugin before and my first venture was a daunting one to say the least. I have learned a lot over the past 3 months and so I’d figure I would share some of my experiences with you.

Lesson #1: v1 is Always Terrible

Yeah that’s right, I said it. When I finally released v1 to the public, there were a lot of problems. PHP 5.2 support? Meh, who needs it? I know a lot of premium plugin developers have dropped PHP 5.2 to take advantage of awesome features like closures, however, since my plugin is sort of an “add-on” for another WordPress product, I wanted to maintain compatibility as much as the other service. Needless to say, the first person who complained that their site got whitescreened after activating, definitely was not happy. Also, WordPress multisite support was also not included. Heck, I’ll honest, I had never even installed multisite before someone mentioned it on the support forums. Whoops. Point being, you will always miss stuff in version 1.0. That’s why we have version numbers! Software was designed to be improved. Don’t beat yourself up too much because things aren’t perfect from the starting line.

Lesson #2: You Know Nothing Jon Snow!

Specifically, in regards to how people will use your software. If you develop a product that allows for any user customization at all, someone will think of a way to use, abuse, and re-use your product in ways you could have never imagined. The feature that took me most by surprise, was the ability to include the plugin in a theme. First of all, MIND BLOWN! I never in a million years would have thought that my creation would be so cool, that someone would want to include it in a theme. Especially within the first month?! After recovering from a mild excitement induced heart attack, I then had to find a way to make everything play nice when not activated like a normal plugin.

One thing that I’m grateful I learned because of this, is the order in which hooks and filters are fired. For example, the action hook fired after the `functions.php` is loaded (`after_theme_setup`) is `init`. 99% of plugin and theme functions can be fired on or after `init` without any consequences and still have access to everything they need. All that was required to make my plugin “includable”, was moving any actions from `plugins_loaded` to `after_theme_setup`. Also, actions and filters are freaking cool! I never really understood how to utilize them effectively until I started using them on a more regular basis. Now I find myself skimming through other plugins looking for hooks and filters to extend their functionality too. It’s a great feeling when you find a problem and a quick glance at the codebase assures you that everything is extensible. Easy Digital Downloads is a great example of a plugin with tons of hooks and filters. Pippin has definitely been an inspiration to the way I look at plugin development.

Lesson #3: Open Source is your Friend

For the first couple of versions, I didn’t release the plugin on GitHub. Which ended up hurting me more than I thought it would. The day that I pushed the codebase to GitHub, something strange happened. I felt obligated to track every change I made. If I read a support email or just ran into a bug while testing, I would go to GitHub and open an issue. Even if the fix was just 1 line of code, I would open one. That small amount of perceived accountability, the knowledge that now anyone could look over my code and judge my decisions, made me better. While I haven’t received any contributions yet, I’m excited for what the future holds and more and more people start to use my creations.

A lot of people also have problems with putting “Premium” plugins in open repositories. First of all, everything used with WordPress is automatically subject to it’s license, the GPL. This means anyone can take the code and copy, modify, sell, distribute, etc, as much as they want. So if people really want it, they’ll get it. The benefit of having a project that anyone can contribute too, vastly outweighs any negatives in my opinion.

Lesson #4: You’ll Become an Addict

I finally understand why Pippin has written 100+ plugins in just a few short years. I’m hooked. Just the other day, someone over on a reddit thread in /r/WordPress was looking for a plugin to do something fairly simple from the admin area. I looked at his problem, thought about it for a minute, and then replied telling him to give me an hour to see what I could do. This led to the creation of Post Author Link, which I will eventually release on WordPress.org for everyone to enjoy. It’s a small plugin now at less than 30 lines of actual code, but it works! It solves a problem in an elegant way without being overly complex. The beauty of it is, that I wanted to write it. I wanted to help this random guy on the internet. For the first time, the kindness bug from the WordPress community infected me and I felt compelled to give back however I could. Now I catch myself browsing through sites like Reddit and WP Chat actively looking for people to help. WordPress has given me so much to become successful that I’m excited to give back to the community in any way I can.

Conclusions

Overall, I’ve learned a lot. I’ve learned to deal with abuse from my plugin website’s contact form, 700,000 API calls in less than a month that shut down my website, etc. The little things. My advice to anyone out there thinking about writing a plugin, premium or otherwise, do it. Stop thinking about it and do it. You’re never gonna learn or grow if you sit on your hands and think about all the things you could do. You are the only person standing in the way of your success. Don’t be afraid to screw up, because it happens to the best of us.