RSS Club is a series of posts which are only visible to RSS / Atom subscribers. Like you 😃

If you want this for your own WordPress site, here's what you'll need:

1. A blog post which is only visible in RSS / Atom.
2. Which has no HTML rendering on your site.
3. And cannot be found in your site's search.
4. Nor via search engines.
5. Also, doesn't appear on your mailing list.
6. Does not get shared or syndicated to the Fediverse.

(This is a bit more strict than the original rules which allow for web rendering and being found via a search engine.)

Start With A Category

The easiest way to do this in WordPress is via a category - not a tag.

After creating a category on your blog, click the edit link. You will see in the URl bar a tag_id.

Whenever you want to make an RSS-exclusive post, you select the category before you publish.

Disable Display

This code stops any page in the RSS Club category from being displayed on the web.

function rss_club_post_blocker(): void {
    if (    is_singular( "post" )
        &&  has_category( "rss-club" )
        && !current_user_can( "edit_posts" ) )
    {
        status_header( 403 );
        echo "You must be a member of RSS Club to view this content.";
        exit;
    }
}
add_action( "template_redirect", "rss_club_post_blocker" );

Editors can still see it, but everyone else gets a blocked message.

Remove From Site Search and SiteMap

Here's a snippet to stick in your functions.php - it removes the category from any queries unless it is for the admin pages or the RSS feeds.

//  Remove the RSS Club category from search results.
//  $query is passed by reference
function rss_club_search_filter( \WP_Query $query ): void {
    //  Ignore admin screens.
    if ( !is_admin() && !is_feed() ) {
        //  Find the RSS-Club category ID.
        $category = get_category_by_slug( "rss-club" );

        //  Remove it from the search results.
        if ( $category ) {
            $query->set( "category__not_in", [$category->term_id] );
        }       
    }
}
add_action( "pre_get_posts", "rss_club_search_filter" );

This code also redacts that category from the build-in sitemap. Note - the name of the category still shows up in the XML, but it leads to a 404.

Exclude From Email and Social Media RSS Feeds

My mailing list and social media posts are fed from RSS. So how do remove an entire category from an RSS feed?

Simple! Append ?cat=-1234 to the end!

A negative category ID will remove the category from being displayed. So my email subscribers won't see the RSS only content. Of course, they get email-only exclusive posts, so don't feel too bad for them 😊

Fediverse Exclusion

The manual way is easiest. Assuming you have the ActivityPub plugin and a the Share On Mastodon plugin, you can unselect the sharing options before publishing.

If you think you might forget to toggle those boxen, there is a filter for the share plugin:

function rss_club_mastodon_filter( bool $is_enabled, int $post_id ): bool {
    global $exclude;
    if ( has_category( $exclude, $post_id ) ) {
        return false;
    }
    return $is_enabled;
}
add_filter( "share_on_mastodon_enabled", "rss_club_mastodon_filter", 10, 2 );

Similarly, there's a filter for the ActivityPub plugin:

function rss_club_activitypub_filter( bool $disabled, \WP_Post $post ): bool 
{
    global $exclude;
    if ( has_category( $exclude, $post ) ) {
        return true;
    }

    return $disabled;
}
add_filter( "activitypub_is_post_disabled", "rss_club_activitypub_filter", 10, 2 );

Enjoy!

If you've set up your own RSS Club feed, drop me a line so I can subscribe 😊

Not only did they have my email address, they also had a copy of one of my phone numbers. I asked them where they got it from and they said:

Your phone number came from Parsely, Inc (wpvip.com) one of our customers who participates in our customer contributor network by sharing their business contacts with the Apollo platform.

I've never done any business with Parsely. They have no reason to have my phone number and absolutely no permission to share it with other organisations.

Back in 2021, Parsely became part of WordPress VIP. Ah yes, our old "friends" at Automattic with their somewhat lax attitude to privacy.

I took advantage of WordPress VIP's GDPR policy and sent a terse but polite "Hey, WTAF?" to them. Their response was quick:

Thanks for reaching out. We are currently investigating our systems to locate any personal data regarding your request. We appreciate your patience.

After a bit of prodding, they eventually replied with:

It appears that we obtained your contact information as a result of a meeting you had with a representative for the WPScan service around August 5, 2022. WPScan is owned by our parent company Automattic.

We have no record of Parsely, Inc. (which is no longer in existence) or WPVIP Inc. (the owner of the Parse.ly service) having any relationship with Apollo.io.

We also have no record of Parsely, Inc. or WPVIP Inc. having sold or otherwise provided your information to any third party.

I have no memory and no record of meeting anyone from WPScan - although I concede it is possible I did as part of a previous job.

But even if it was in an email signature when I contacted them that still doesn't explain how it made its way to Apollo for them to give to spammers everywhere. Was it a hack? A data leak? A treacherous employee? A deliberate sale? A sneaky app update? Or maybe just Apollo lying to me.

I don't care any more. I'm just so tired of shitty companies treating personal data as a commodity to be traded, sold, repackaged, and abused.

Sometimes this is done with complex cryptography and involves key-signing ceremonies. Other times it involves byzantine XML RDF. Or you can use the baroque XHTML Friends Network.

None of those have been widely adopted. Perhaps it's because PGP is a usability nightmare, XML is out of fashion, or because these relationships mostly live in silos like Facebook and LinkedIn, or just that people value their privacy and don't want to expose their social graph any more than they have to.

Enter a new contender into the ring - human.json - it describes itself as:

a lightweight protocol for humans to assert authorship of their site content and vouch for the humanity of others. It uses URL ownership as identity, and trust propagates through a crawlable web of vouches between sites.

It looks like this:

{
  "version": "0.1.1",
  "url": "https://shkspr.mobi/blog/",
  "vouches": [
    {
      "url": "https://neilzone.co.uk/",
      "vouched_at": "2026-03-20"
    },
    {
      "url": "https://ohhelloana.blog/",
      "vouched_at": "2026-03-20"
    }
  ]
}

That says that I assert my own blog is written by a human, and that I vouch that my friends Neil and Ana write their own content.

Now, obviously there's no way that I can prove my blog posts are written by an organic, vegan-fed, human. And, while I know and trust the friends I've met AFK, I don't have any special insight into their creative processes. If I suspect them of being synthetic clankers, I can disavow their sites by removing them from my human.json file.

Adding to WordPress

There's an easy way and a hard way. The easy way it to just hand-write a JSON file and upload it to your website. BORING!

To start with, you'll need to add some code to your HTML's head. Stick this in your index.php

<link rel=human-json href=https://example.com/json/human.json>

Next, add this to your functions.php or wherever you set your weird options:

//  Add rewrite rule for /json and /json/{something}
add_action( "init", function () {
    add_rewrite_rule(
        '^json(?:/([^/]+))?/?$',    //  Matches /json and /json/{something}
        'index.php?pagename=json&json_param=$matches[1]',
        "top"
    );
});

//  Register custom query variable
add_filter( "query_vars" , function ($vars) {
    $vars[] = "json_param";
    return $vars;
});

That creates a rewrite so that /json/whatever will be intercepted. For now, this only deals with human.json - but there may be more weird JSON things you want to support later. Hurrah for over-engineering!

Next, add this:

add_action( "template_redirect", function() {
    if ( get_query_var( "json_param" ) && "human.json" == get_query_var( "json_param" ) ) {
        $data = [
            "version" => "0.1.1",
                "url" => esc_url( home_url() ),
            "vouches" => [
                [
                           "url" => "https://friend.example.com",
                    "vouched_at" => "2026-03-20"
                ],
                [
                           "url" => "https://whatever.example",
                    "vouched_at" => "2026-03-20"
                ],

            ]
        ];
        //  Headers to make sure it all works.
        header( "Access-Control-Allow-Origin: *" );
        wp_send_json( $data, 200 );
    }
} );

That intercepts the request, generates some JSON, then serves it with the correct content type and CORS headers.

You may need to refresh your redirects. Easiest way is to go to your blog's admin page and choose Settings → Permalinks, then hit Save

Over over engineering

This takes a list of your human friends, deduplicates them, sorts them alphabetically, and changes the vouch date to that of when you last updated the files.

add_action( "template_redirect", function() {
    if ( get_query_var( "json_param" ) ) {
        // https://codeberg.org/robida/human.json
        if ( strcasecmp( "human.json", get_query_var( "json_param" ) ) == 0 ) {

            //  People who I know to be human.
            $humans = array_unique([
                "https://neilzone.co.uk/",
                "https://ohhelloana.blog/",
                "https://example.com/",
            ]);

            sort( $humans );

            //  When was this file updated?
            //  RFC 3339 date format.
            $modified = date( "Y-m-d", filemtime( __FILE__ ) );

            foreach ( $humans as $human ) {
                $vouches[] = [ "url" => $human, "vouched_at" => $modified ];
            }

            $data = [
                "version" => "0.1.1",
                    "url" => esc_url( home_url() ),
                "vouches" => $vouches
            ];

            //  Headers to make sure it all works.
            header( "Access-Control-Allow-Origin: *" );
            wp_send_json( $data, 200, JSON_PRETTY_PRINT );
        } else {
            //  No valid parameter
            wp_send_json( null,  404, JSON_PRETTY_PRINT );
        }
    }
} );

Is it worth it?

I don't know.

Perhaps no one will use this. Or perhaps all my friends will turn out to be poorly constructed Turing machines. Or maybe a better standard will come along.

Either way, I think it is nifty and am happy to support it.

You can read more about human.json on CodeBerg.

To double-down on the annoyance, there's no simple way to turn them off. In part, that is due to the "WordPress Philosophy":

Decisions, not options

[…] Every time you give a user an option, you are asking them to make a decision. When a user doesn’t care or understand the option this ultimately leads to frustration.

I broadly agree with that. Having hundreds of options is a burden for users and a nightmare for maintainers. Do please read this excellent discussion from Tom McFarlin for a more detailed analysis.

But I want to turn things off. Luckily, there is a way. If you're a developer, you can remove a fair number of these "enforced" decisions. Add the following to your theme's functions.php file and watch the mandatory WordPress bloat whither away. I've commented each removal and, where possible, given a source for more information. Feel free to leave a comment suggesting how this script can be improved and simplified.

//  Remove mandatory classic theme.
function disable_classic_theme_styles() {
    wp_deregister_style( "classic-theme-styles" );
    wp_dequeue_style(    "classic-theme-styles" );
}
add_action( "wp_enqueue_scripts", "disable_classic_theme_styles" );

//  Remove WP Emoji.
//  http://www.denisbouquet.com/remove-wordpress-emoji-code/
remove_action( "wp_head",             "print_emoji_detection_script", 7 );
remove_action( "wp_print_styles",     "print_emoji_styles"              );
remove_action( "admin_print_scripts", "print_emoji_detection_script"    );
remove_action( "admin_print_styles",  "print_emoji_styles"              );
//  https://wordpress.org/support/topic/remove-the-new-dns-prefetch-code/
add_filter( "emoji_svg_url", "__return_false" );

//  Stop emoji replacement with images in RSS / Atom Feeds
//  https://danq.me/2023/09/04/wordpress-stop-emoji-images/
remove_filter( "the_content_feed", "wp_staticize_emoji" );
remove_filter( "comment_text_rss", "wp_staticize_emoji" );

//  Remove automatic formatting.
//  https://css-tricks.com/snippets/wordpress/disable-automatic-formatting/
remove_filter( "the_content",  "wptexturize" );
remove_filter( "the_excerpt",  "wptexturize" );
remove_filter( "comment_text", "wptexturize" );
remove_filter( "the_title",    "wptexturize" );

//  More formatting crap.
add_action("init", function() {
    remove_filter( "the_content", "convert_smilies", 20 );
    foreach ( array( "the_content", "the_title", "wp_title", "document_title" ) as $filter ) {
        remove_filter( $filter, "capital_P_dangit", 11 );
    }
    remove_filter( "comment_text", "capital_P_dangit", 31 );    //  No idea why this is separate
    remove_filter( "the_content",  "do_blocks", 9 );
}, 11);

//  Remove Gutenberg Styles.
//  https://wordpress.org/support/topic/how-to-disable-inline-styling-style-idglobal-styles-inline-css/
remove_action( "wp_enqueue_scripts", "wp_enqueue_global_styles" );

//  Remove Gutenberg editing widgets.
//  From https://wordpress.org/plugins/classic-widgets/
//  Disables the block editor from managing widgets in the Gutenberg plugin.
add_filter( "gutenberg_use_widgets_block_editor", "__return_false" );
//  Disables the block editor from managing widgets.
add_filter( "use_widgets_block_editor", "__return_false" );

//  Remove Gutenberg Block Library CSS from loading on the frontend.
//  https://smartwp.com/remove-gutenberg-css/
function remove_wp_block_library_css() {
    wp_dequeue_style( "wp-block-library"       );
    wp_dequeue_style( "wp-block-library-theme" );
    wp_dequeue_style( "wp-components"          );
}
add_action( "wp_enqueue_scripts", "remove_wp_block_library_css", 100 );

//  Remove hovercards on comment links in admin area.
//  https://wordpress.org/support/topic/how-to-disable-mshots-service/#post-12946617
add_filter( "akismet_enable_mshots", "__return_false" );

//  Remove Unused Plugin code.
function remove_plugin_css_js() {
    wp_dequeue_style( "image-sizes" );
}
add_action( "wp_enqueue_scripts", "remove_plugin_css_js", 100 );

//  Remove WordPress forced image size
//  https://core.trac.wordpress.org/ticket/62413#comment:40
add_filter( "wp_img_tag_add_auto_sizes", "__return_false" );

//  Remove <img> enhancements
//  https://developer.wordpress.org/reference/functions/wp_filter_content_tags/
remove_filter( "the_content",  "wp_filter_content_tags", 12 );

//  Stop rewriting http:// URls for the main domain.
//  https://developer.wordpress.org/reference/hooks/wp_should_replace_insecure_home_url/
remove_filter( "the_content", "wp_replace_insecure_home_url", 10 );

//  Remove the attachment stuff
//  https://developer.wordpress.org/news/2024/01/building-dynamic-block-based-attachment-templates-in-themes/
remove_filter( "the_content", "prepend_attachment" );

//  Remove the block filter
remove_filter( "the_content", "apply_block_hooks_to_content_from_post_object", 8 );

//  Remove browser check from Admin dashboard.
//  https://core.trac.wordpress.org/attachment/ticket/27626/disable-wp-check-browser-version.0.2.php
if ( !empty( $_SERVER["HTTP_USER_AGENT"] ) ) {
    add_filter( "pre_site_transient_browser_" . md5( $_SERVER["HTTP_USER_AGENT"] ), "__return_null" );
}

//  Remove shortlink.
//  https://stackoverflow.com/questions/42444063/disable-wordpress-short-links
remove_action( "wp_head", "wp_shortlink_wp_head" );

//  Remove RSD.
//  https://wpengineer.com/1438/wordpress-header/
remove_action( "wp_head", "rsd_link" );

//  Remove extra feed links.
//  https://developer.wordpress.org/reference/functions/feed_links/
add_filter( "feed_links_show_comments_feed", "__return_false" );
add_filter( "feed_links_show_posts_feed",    "__return_false" );

//  Remove api.w.org link.
//  https://wordpress.stackexchange.com/questions/211467/remove-json-api-links-in-header-html
remove_action( "wp_head", "rest_output_link_wp_head" );
//  https://wordpress.stackexchange.com/questions/211817/how-to-remove-rest-api-link-in-http-headers
//  https://developer.wordpress.org/reference/functions/rest_output_link_header/
remove_action( "template_redirect", "rest_output_link_header", 11, 0 );

You can find the latest version of my debloat script in my theme's repo.

If there are other things you find helpful to remove, or a better way to organise this file, please drop a comment in the box.

At the same time, I don't want to know too much about people. I don't want to stalk them around the web. I refuse to care how long they spend with me. I can't be bothered setting up a foolproof system that captures 100% accurate information.

After trying several analytics plugins for WordPress, I've decided to have a go at writing my own⁰.

Before embarking on this, please do read "You Don't Need Analytics on Your Blog" and the slightly more provocative "You do not need “analytics” for your blog because you are neither a military surveillance unit nor a commodity trading company". Both give excellent examples of why this is at best foolish and at worse injurious. Proceed with caution in your heart.

Background

As a consequence of the way the web works, every time you click on a link the website's owner gets the following pieces of information.

• The time you clicked,
• The page you visited,
• The name of the web browser you use,
• The URl of the page which you clicked to get here,
• The IP address your computer has.

There are a few other things sent along but they're not interesting to me.

Using that information, I can construct a reasonably accurate view of how many times a post has been viewed and how many people viewed it.

Defining a page view

If a web page is loaded, that counts as a view. I'm not going to track whether the user stayed for more than 30 seconds or closed their browser in disgust after reading the headline. If the page is loaded, that's a view.

But what if one person repeatedly hits refresh on the same post? To deal with that, I'll need a concept of a visitor.

Defining a visitor

The "normal" way of doing things is to stick a cookie in the user's browser and track them that way. I can't be bothered with that. And, besides, it doesn't account for a person reading on their laptop and then moving to their phone.

So I'm going to use a proxy by creating a cryptographic hash of the visitor's IP address and the browser's User Agent string.

Of course, a household might have one IP address and multiple people with the same phone. But, equally, one person might rove over several WiFi networks in the course of one browsing session, getting a different IP each time.

The aim is to be reasonably accurate.

Hashing the contents means I don't need to store the user's IP address. Once hashed, the information becomes a string like db050e7b853e5856 which is functionally impossible to crack back to an IP address & UA string¹.

This also means that I can redefine the concept of a page view. If the same visitor refreshed the page multiple times, it will only count as a single visit.

I'll reset the counter at midnight in my local timezone. If someone visits just before midnight and then just after, it'll count as two visits. Oh well.

Where did they come from?

Generally speaking, there are two ways that visitors share their referrer. One is the "referer" header (yes, it is misspelled). It contains a URl of the referring site or application. For example, if someone clicked from a search result it might say https://yahoo.com.

The other way is using "Urchin Tracking Module" query strings. At the end of the URl they visit, they might append something like ?utm_source=alices-newsletter.

Some sites, like Reddit, might use multiple subdomains - old.reddit.com or out.reddit.com - so some deduplication may be necessary.

Where in the world are they?

A user's IP address is somewhat accurate method of detecting their location. Yes, users could be proxying through a VPN or using a SIM card from a foreign country. But this isn't an exercise in precise tracking. Rough and ready is fine.

There are a variety of GeoIP Databases which are updated semi-regularly. I'm only interested in the country of origin, I don't care about finer resolution than that.

Again, the aim isn't precise targetting. I'd just like to know that people in Sudan ever read my blog posts.

What else could we use?

It might be nice to know if someone is using a small-screen or large device. But my CSS is responsive, so I don't care.

Similarly, their Internet connection speed might be available. But, again, I try to optimise things so that isn't necessary to know.

Do I need to know if someone speaks Hungarian? No. There's nothing useful I can do with that information.

Could I extract their operating system, device, and browser from their User-Agent? I guess. Would I use the information that X% of my readers use Firefox on Linux? Doubtful!

Collect the information

There are two main methods of collecting these data.

First is a "no JavaScript" solution. This tells the browser to request an image which has a query string to send along the details of the page requested.

<noscript>
    <img src="/tracking.php?ID=<?php echo $postID ?>" alt="" width=1 height=1 class=hidden>
</noscript>

The downside is that there's no way to capture referer information. If each page were dynamically generated, I could grab it from PHP's $_SERVER superglobal. But my website is heavily cached, so that isn't possible.

It is possible to use JavaScript to dynamically send the information for collection:

let formData = new FormData();
formData.append("HTTP_REFERER", document.referrer);
formData.append("ID",  <?php echo $postID ?>);

fetch("/tracking.php", {
    method: "POST",
    body: formData,
});

This approach has three distinct advantages.

1. It works whether the user has JS enabled or not.
2. Repeated requests for the same page will usually reload the image from cache, so won't double-count.
3. It doesn't count hits from bots. They typically don't execute JavaScript or don't request images.

Bot Detection

Not all traffic originates from humans. There are lots of bots which crawl the web. Some are useful - like search engines building up a map. Others are harmful - like AI agents aggressively scraping content to plagiarise.

There are lots of identifiable bots out there - and more which obfuscate themselves. There are some, like Lighthouse which cloak themselves.

I'm not trying to eliminate everything which could be a bot. I am trying for reasonably accurate. So I eliminate any User-Agent which contains:

"/bot|crawl|spider|seo|lighthouse|facebookexternalhit|preview|HeadlessChrome/i"

There are some big lists of bots you can use - but they don't seem to trigger my analytics because they aren't requesting the images or executing the JS.

What bits of the site to measure?

I only care about how many visitors my posts and pages get. I don't need to know if someone visited a tag page, or scrolled back to page 100 of posts from 2019. Those sorts of deep pages are usually only accessed by bots anyway.

I also don't want to count visits from me, myself, and I.

So the tracking is only inserted on single pages which are viewed by non-admins:

if ( is_singular() && !current_user_can( "edit_posts" ) ) {
    …
}

Oddities

Sometimes, the URl requested will look something like: https://shkspr-mobi.translate.goog - that just means Google has translated it.

Sometimes, the referer will look something like: android-app://com.google.android.gm/ - that just means they clicked from an Android app.

Sometimes, the URl requested will include a fragment or a query string - they can be ignored.

Sometimes, the utm_ will contain all sorts of weird stuff. It isn't always possible to pull out exactly where it has come from.

Sometimes, the referer and utm_ will disagree. Ah well, never mind.

Sometimes, RSS views are counted and sometimes not. Perhaps I should fix that?

Sometimes, users block trackers or use a text-only browser. That's fine, they can keep their secrets.

Saving the data

I started this by just shoving what I collected into a CSV.

//  Write the CSV.
$line = [date("c"), $ID, $UA, $referer, $domain, $country, $user];
//  Date-based filename.
$filename = "log-" . date("Y-m-d") . ".csv";
//  Append mode.
$handle = fopen( $filename, "a" );
fputcsv( $handle, $line );
fclose( $handle );

Nothing fancy. Something easily grepable with the ability to query it in more detail if I need. At the number of hits that my site gets, it is less than 1MB per day.

I've since moved it into a single MySQL table. That might not be sustainable with hundreds of thousands of rows. But that's tomorrow's problem.

Accuracy

I've been running this for a couple of days - simultaneously with my other, more professional, stats plugin. It is within 5% accuracy. It appears to slightly exaggerate the number of visitors and undercount my page-views. That's good enough for my purposes and probably good for my ego!

Putting it all together

You can take a look at all the code on my GitLab repo.

What does it look like?

If you've made it this far, you can have a little pictorial treat! Aren't you lucky?

What's next?

For now, a simple table structure is fine. I've shoved it in a basic database. Sure, I don't have any indexes or fancy stuff like that. But modern computers are pretty fast.

Eventually I'll need to create some new tables which will consolidate the data. Perhaps a table for individual posts, using date and country? Or maybe referer? I'll have to see.

I also need a way to get historic data into it. I've blog stats going back to 2009 which I am anxious not to lose.

And, yeah, I'll need a better front-end than manually running SQL queries.

Above all, I want to keep it simple enough that my puny mortal brain can understand it after several years of not touching anything. I want to build something which can run without constant maintenance.

Remember, this is only an exercise in self-learning, self-hosting, and self-respect.

After skimming through a few options, I found Tempest Highlight. It has nearly everything I want in a code highlighter:

•  PHP with no 3rd party dependencies.
•  Lots of common languages.
•  Modern, with regular updates.
•  Easy to use functions.
•  Range of difference style sheets.

But, on the downside:

•  No WordPress plugin.
•  Not all languages supported.
•  CSS embedded in HTML.

I can live without some esoteric languages, but I don't really want to run composer install on my blog. I just want a quick WordPress plugin. So, here's how I did it.

Here Be Dragons

This is a quick prototype. It has an audience of one; me. It may break in unexpected ways. Use at your own risk.

The file layout is relatively simple:

WordPress Plugins
├── Highlight_Plugin
│   ├── src/
│   ├── autoload.php
│   ├── index.php
│   └── base.css

The src/ directory contains the src/ directory from Tempest Highlight.

The Art of Loading without Loading

Normally, to install a PHP package, the composer app creates an autoloader which will magically import everything you need into your project. We can't do that here. Instead, we need to manually load the library.

Create a file in the plugin's directory called autoload.php - its job is to autoload everything in the src/ directory.

<?php
spl_autoload_register( function ( $class ) {
    //  Project-specific namespace prefix
    $prefix = "Tempest\\Highlight\\";

    //  Base directory for the namespace prefix
    $base_dir = __DIR__ . "/src/";

    //  Does the class use the namespace prefix?
    $len = strlen( $prefix );
    if ( strncmp( $prefix, $class, $len ) !== 0) {
        //  No, move to the next registered autoloader
        return;
    }

    //  Get the relative class name
    $relative_class = substr( $class, $len );

    //  Replace namespace separators with directory separators, append with .php
    $file = $base_dir . str_replace( "\\", "/", $relative_class ) . ".php";

    //  If the file exists, require it
    if ( file_exists( $file ) ) {
        require $file;
    }
});

I don't know if that's the easiest way to do it. But it works!

Testing

The index.php file can now be tested:

//  Load the Tempest Highlight library
require_once __DIR__ . "/autoload.php";

//  Set up the namespace
use Tempest\Highlight\Highlighter;

//  Define the theme.
$theme = new Tempest\Highlight\Themes\InlineTheme( __DIR__ . "/src/Themes/Css/light-plus.css");

//  Create the highlighter.
$highlighter = new Tempest\Highlight\Highlighter( $theme );

//  Print some formatted HTML
echo $highlighter->parse("<em id='foo' class='bar'>test</em>", "html" );

All being well, that should produce this:

&lt;<span style="color: #0000ff;">em</span> id='foo' class='bar'&gt;test&lt;/<span style="color: #0000ff;">em</span>&gt;

That has the CSS embedded. Not ideal, but certainly good enough. I picked "light-plus" because it was the only theme which seemed to meet at least WCAG AA when on a white background.

OK, so how do we go from printing out a scrap of HTML to extracting all the code snippets from a WordPress blog?

Draw The Rest of the Owl

In theory the code is relatively straightforward.

Find code snippets

My Markdown plugin transforms this:

 ```javascript
 var a = 2.0;
 ``` 

Into this:

<pre><code class="language-javascript">
var a = 2.0;
</code></pre>

No need to use a regex, the new PHP 8.4 HTMLDocument gives us direct programmatic access to the HTML.

//  Load the content into PHP 8.4's HTML DOM.
$dom = Dom\HTMLDocument::createFromString( $content, LIBXML_NOERROR | LIBXML_HTML_NOIMPLIED, "UTF-8" );

//  Select the code snippets.
//  `<pre><code class="language-*">`
$codeSnippets = $dom->querySelectorAll( "pre>code[class^=language-]" );

Replace the snippets

From the above, I have the language and code, so it can "easily" be replaced.

//  Iterate through each snippet.
foreach ( $codeSnippets as $code ) {
    //  Get the HTML from within the <code>.
    $originalCode = $code->textContent;
    //  Replace the contents of <code> with the highlighted HTML.
    $code->innerHTML = $highlighter->parse( $originalCode, $language )
}

Replacing the code in that node manipulates the original DOM. Which means, after looping through all the snippets, I can return the altered HTML like so:

return $dom->saveHTML();

And then…

Obviously, there's a bit more too it than that. It ignores RSS feeds, it adds a base CSS style to the head, some SVGs get embedded, semantic metadata is included, and it all gets a bit tangled and complicated.

ToDo

A few things need to happen to make this even better.

• Encoded comments as well and posts.
• Add new languages.
• Don't in-line the CSS into the HTML, but add it as a separate stylesheet.

But, for now, it is running on my blog and that's good enough for me!

Get the code

You can play about with the WordPress plugin. Bugs reports, pull requests, and suggestions all warmly welcomed.

Here's how the admin list of posts looks to me:

I don't want it to look like that. I want it in RFC3339 format.

I know what you're thinking, just change the default date display - but that only seems to work in some areas of WordPress. It doesn't change the column-date format. Here's what mine is set to:

So that doesn't work.

Instead, you need to use the slightly obscure post_date_column_time filter

Add this to your theme's functions.php:

//  Admin view - change date format
function rfc3339_post_date_time( $time, $post ) {
    //  Modify the default time format
    $rfc3339_time = date( "Y-m-d H:i", strtotime( $post->post_date ) );
    return $rfc3339_time;
}
add_filter( "post_date_column_time", "rfc3339_post_date_time", 10, 2 );

And, hey presto, your date column will look like this:

Obviously, you can change that code to whichever date format you prefer.

When zoomed in, it shows the relation between posts and tags.

In this case, I can see that the posts about Small Gods and Pyramids both share the tags of Discworld, Fantasy, and Book Review. But only Small Gods has the tag of Religion.

Isn't that cool! It is a native feature of Quartz's GraphView. How can I build something like that for my WordPress blog?

Aim

Create an interactive graph which shows the relationship between a post, its links, and their tags.

It will end up looking something like this:

You can get the code or follow along to see how it works.

This is a multi-stage process. Let's begin!

What We Need

When on a single Post, we need the following:

• The tags assigned to that Post.
• Internal links back to that Post.
• Internal links from that Post.
• The tags assigned to links to and from that Post.

Tags assigned to that Post.

This is pretty easy! Using the get_the_tag_list() function we can, unsurprisingly, get all the tags associated with a post.

$post_tags_text = get_the_tag_list( "", ",", $ID );
$post_tags_array = explode( "," , $post_tags_text );

That just gets the list of tag names. If we want the tag IDs as well, we need to use the get_the_tags() function.

$post_tags = get_the_tags($ID);
$tags = array();
foreach($post_tags as $tag) {
    $tags[$tag->term_id] = $tag->name; 
}

Backlinks

Internal links back to the Post is slightly trickier. WordPress doesn't save relational information like that. Instead, we get the Post's URl and search for that in the database. Then we get the post IDs of all the posts which contain that string.

//  Get all the posts which link to this one, oldest first
$the_query = new WP_Query(
    array(
        's' => $search_url,
        'post_type' => 'post',
        "posts_per_page" => "-1",
        "order" => "ASC"
    )
);

//  Nothing to do if there are no inbound links
if ( !$the_query->have_posts() ) {
    return;
}

Backlinks' Tags

Once we have an array of posts which link back here, we can get their tags as above:

//  Loop through the posts
while ( $the_query->have_posts() ) {
    //  Set it up
    $the_query->the_post();
    $id                  = get_the_ID();
    $title               = esc_html( get_the_title() );
    $url                 = get_the_permalink();
    $backlink_tags_text  = get_the_tag_list( "", ",", $ID );
    $backlink_tags_array = explode( "," , $backlink_tags_text );
}

Links from the Post

Again, WordPress's lack of relational links is a weakness. In order to get internal links, we need to:

1. Render the HTML using all the filters
2. Search for all <a href="…">
3. Extract the ones which start with the blog's domain
4. Get those posts' IDs.

Rendering the content into HTML is done with:

$content = apply_filters( "the_content", get_the_content( null, false, $ID ) );

Searching for links is slightly more complex. The easiest way is to load the HTML into a DOMDocument, then extract all the anchors. All my blog posts start /blog/YYYY so I can avoid selecting links to tags, uploaded files, or other things. Your blog may be different.

$dom = new DOMDocument();
libxml_use_internal_errors( true ); //  Suppress warnings from malformed HTML
$dom->loadHTML( $content );
libxml_clear_errors();

$links = [];
foreach ( $dom->getElementsByTagName( "a" ) as $anchor ) {
    $href = $anchor->getAttribute( "href" );
    if (preg_match('/^https:\/\/shkspr\.mobi\/blog\/\d{4}$/', $href)) {
        $links[] = $href;
    }
}

The ID of each post can be found with the url_to_postid() function. That means we can re-use the earlier code to see what tags those posts have.

Building a graph

OK, so we have all our constituent parts. Let's build a graph!

Graphs consist of nodes (posts and tags) and edges (links between them). The exact format of the graph is going to depend on the graph library we use.

I've decided to use D3.js's Force Graph as it is relatively simple and produces a reasonably good looking interactive SVG.

Imagine there are two blog posts and two hashtags.

const nodes = [
    { id: 1, label: "Blog Post 1",    url: "https://example.com/post/1", group: "post" },
    { id: 2, label: "Blog Post 2",    url: "https://example.com/post/2", group: "post" },
    { id: 3, label: "hashtag",        url: "https://example.com/tag/3",  group: "tag"  },
    { id: 4, label: "anotherHashtag", url: "https://example.com/tag/4",  group: "tag"  },
];

• Blog Post 1 links to Blog Post 2.
• Blog Post 1 has a #hashtag.
• Both 1 & 2 share #anotherHashtag.

const links = [
    { source: 1, target: 2 },
    { source: 3, target: 1 },
    { source: 4, target: 1 },
    { source: 4, target: 2 },
];

Here's how to create a list of nodes and their links. You will need to edit it for your own blog's peculiarities.

<?php 
// Load WordPress environment
require_once( "wp-load.php" );

//  Set up arrays for nodes and links
$nodes = array();
$links = array();

//  ID of the Post
$main_post_id = 12345;

//  Get the Post's details
$main_post_url   = get_permalink( $main_post_id );
$main_post_title = get_the_title( $main_post_id );

//  Function to add new nodes
function add_item_to_nodes( &$nodes, $id, $label, $url, $group ) {
    $nodes[] = [ 
        "id"    => $id, 
        "label" => $label, 
        "url"   => $url, 
        "group" => $group
    ];

}

//  Function to add new relationships
function add_relationship( &$links, $source, $target ) {
    $links[] = [
        "source" => $source,
        "target" => $target
    ];
}

//  Add Post to the nodes
add_item_to_nodes( $nodes, $main_post_id, $main_post_title, $main_post_url, "post" );

//  Get the tags of the Post
$main_post_tags = get_the_tags( $main_post_id );

//  Add the tags as nodes, and create links to main Post
foreach( $main_post_tags as $tag ) {
    $id   = $tag->term_id;
    $name = $tag->name;

    //  Add the node
    add_item_to_nodes( $nodes, $id, $name, "https://shkspr.mobi/blog/tag/" . $name, "tag" );
    //  Add the relationship
    add_relationship( $links, $id, $main_post_id );
}

//  Get all the posts which link to this one, oldest first
$the_query = new WP_Query(
    array(
        's'              => $main_post_url,
        'post_type'      => 'post',
        "posts_per_page" => "-1",
        "order"          => "ASC"
    )
);

//  Nothing to do if there are no inbound links
if ( $the_query->have_posts() ) {
    //  Loop through the posts
    while ( $the_query->have_posts() ) {
        //  Set up the query
        $the_query->the_post();
        $post_id = get_the_ID();
        $title = esc_html( get_the_title() );
        $url   = get_the_permalink();

        //  Add the node
        add_item_to_nodes( $nodes, $post_id, $title, $url, "post" );
        //  Add the relationship
        add_relationship( $links, $post_id, $main_post_id );

        //  Get the tags of the Post
        $post_tags = get_the_tags( $post_id );

        //  Add the tags as nodes, and create links to main Post
        foreach($post_tags as $tag) {

            $id   = $tag->term_id;
            $name = $tag->name;

            //  Add the node
            add_item_to_nodes( $nodes, $id, $name, "https://shkspr.mobi/blog/tag/" . $name, "tag" );
            //  Add the relationship
            add_relationship( $links, $id, $post_id );
        }

    }
}

//  Get all the internal links from this post
//  Render the post as HTML
$content = apply_filters( "the_content", get_the_content( null, false, $ID ) );

//  Load it into HTML
$dom = new DOMDocument();
libxml_use_internal_errors( true );
$dom->loadHTML( $content );
libxml_clear_errors();

//  Get any <a href="…" which starts with https://shkspr.mobi/blog/
$internal_links = [];
foreach ( $dom->getElementsByTagName( "a" ) as $anchor ) {
    $href = $anchor->getAttribute( "href" );
    if (preg_match('/^https:\/\/shkspr\.mobi\/blog\/\d{4}$/', $href)) {
        $internal_links[] = $href;
    }
}

//  Loop through the internal links, get their hashtags
foreach ( $internal_links as $url ) {
    $post_id = url_to_postid( $url );
    //  Get the Post's details
    $post_title = get_the_title( $id );

    //  Add the node
    add_item_to_nodes( $nodes, $post_id, $post_title, $url, "post" );
    //  Add the relationship
    add_relationship($links, $main_post_id, $post_id );

    //  Get the tags of the Post
    $post_tags = get_the_tags( $post_id );

    //  Add the tags as nodes, and create links to main Post
    foreach( $post_tags as $tag ) {
        $id   = $tag->term_id;
        $name = $tag->name;

        //  Add the node
        add_item_to_nodes( $nodes, $id, $name, "https://shkspr.mobi/blog/tag/" . $name, "tag" );
        //  Add the relationship
        add_relationship( $links, $id, $post_id );
    }
}

//  Deduplicate the nodes and links
$nodes_unique = array_unique( $nodes, SORT_REGULAR );
$links_unique = array_unique( $links, SORT_REGULAR );

//  Put them in the keyless format that D3 expects
$nodes_output = array();
$links_output = array();

foreach ( $nodes_unique as $node ) {
    $nodes_output[] = $node;
}

foreach ( $links_unique as $link ) {
    $links_output[] = $link;
}

//  Return the JSON
echo json_encode( $nodes_output, JSON_PRETTY_PRINT );
echo "\n";
echo json_encode( $links_output, JSON_PRETTY_PRINT );

Creating a Force Directed SVG

Once the data are spat out, you can include them in a web-page. Here's a basic example:

<!DOCTYPE html>
<html lang="en">
    <head>
        <meta charset="UTF-8">
        <meta name="viewport" content="width=device-width, initial-scale=1.0">
        <title>Force Directed Graph</title>
        <script src="https://d3js.org/d3.v7.min.js"></script>
    </head>
    <body>
        <svg width="800" height="600">
            <defs>
                <marker id="arrowhead" markerWidth="10" markerHeight="7" refX="10" refY="3.5" orient="auto" fill="#999">
                <path d="M0,0 L10,3.5 L0,7 Z"></path>
                </marker>
            </defs>
        </svg>
        <script>

            const nodes = [];
            const links = [];

            const width  = 800;
            const height = 600;

            const svg = d3.select("svg")
                .attr( "width",  width  )
                .attr( "height", height );

            const simulation = d3.forceSimulation( nodes )
                .force( "link",   d3.forceLink( links ).id( d => d.id ).distance( 100 ) )
                .force( "charge", d3.forceManyBody().strength( -300 ) )
                .force( "center", d3.forceCenter( width / 2, height / 2 ) );

            //  Run simulation with simple animation
            simulation.on("tick", () => {
                link
                    .attr("x1", d => d.source.x)
                    .attr("y1", d => d.source.y)
                    .attr("x2", d => d.target.x)
                    .attr("y2", d => d.target.y);   node
                    .attr("transform", d => `translate(${d.x},${d.y})`);
            });

            // Draw links
            const link = svg.selectAll( ".link" )
                .data(links)
                .enter().append("line")
                .attr( "stroke", "#999" )
                .attr( "stroke-width", 2 )
                .attr( "x1", d => d.source.x )
                .attr( "y1", d => d.source.y )
                .attr( "x2", d => d.target.x )
                .attr( "y2", d => d.target.y )
                .attr( "marker-end", "url(#arrowhead)" );

            //  Draw nodes
            const node = svg.selectAll( ".node" )
                .data( nodes )
                .enter().append( "g" )
                .attr( "class", "node" )
                .attr( "transform", d => `translate(${d.x},${d.y})` )
                .call(d3.drag() //  Make nodes draggable
                    .on( "start", dragStarted )
                    .on( "drag",  dragged )
                    .on( "end",   dragEnded ) 
                );

            //  Add hyperlink
            node.append("a")
            .attr( "xlink:href", d => d.url ) //    Link to the node's URL
            .attr( "target", "_blank" ) //  Open in a new tab
            .each(function (d) {
                const a = d3.select(this);
                //  Different shapes for posts and tags
                if ( d.group === "post" ) {
                    a.append("circle")
                        .attr("r", 10)
                        .attr("fill", "blue");
                } else if ( d.group === "tag" ) {
                    //  White background rectangle
                    a.append("rect")
                            .attr("width", 20)
                            .attr("height", 20)
                            .attr("x", -10)
                            .attr("y", -10)
                            .attr("fill", "white"); 
                    // Red octothorpe
                    a.append("path")
                            .attr("d", "M-10,-5 H10 M-10,5 H10 M-5,-10 V10 M5,-10 V10") 
                            .attr("stroke", "red")
                            .attr("stroke-width", 2)
                            .attr("fill", "none");
                }
                //  Text label
                a.append( "text")
                    .attr( "dy", 4 )
                    .attr( "x", d => ( d.group === "post" ? 12 : 14 ) )
                    .attr( "fill", "black" )
                    .style("font-size", "12px" )
                    .text( d.label );
            });

            //  Standard helper functions to make nodes draggable
            function dragStarted( event, d ) {
                if ( !event.active ) simulation.alphaTarget(0.3).restart();
                d.fx = d.x;
                d.fy = d.y;
            }
            function dragged( event, d ) {
                d.fx = event.x;
                d.fy = event.y;
            }
            function dragEnded( event, d ) {
                if (!event.active) simulation.alphaTarget(0);
                d.fx = null;
                d.fy = null;
            }

        </script>
    </body>
</html>

Next Steps

It needs a bit of cleaning up if I want to turn it into a WordPress plugin. It might be nice to make it a static SVG rather than relying on JavaScript. And the general æsthetic needs a bit of work.

Perhaps I could make it 3D like my MSc Dissertation?

But I'm pretty happy with that for an afternoon hack!

You can get the code if you want to play.

//  Add ordering by comments
add_action( 'pre_get_posts', 'pre_get_posts_by_comments' );
function pre_get_posts_by_comments( $query ) {
    //  Do nothing if the post_status parameter in the URL is not "comment-order"
    if ( ! isset( $_GET['comment-order'] ) ) {
        return;
    }

    $query->set( "orderby", "comment_count" );  //  Default: date
    $query->set( "order", "DESC" ); //  Biggest first
}

This makes use of the pre_get_posts hook to rewrite the posts query. That means it works on most WordPress pages.

For example:

• My homepage https://shkspr.mobi/blog/?comment-order
• Posts with a specific tag https://shkspr.mobi/blog/tag/blockchain/?comment-order
• Dates https://shkspr.mobi/blog/2012/?comment-order

Did you find this post useful? Please leave a comment here!

After a brief chat about the latest shenanigans, I publicly replied to the CEO:

Here's a link to the full exchange

There was no reply forthcoming - although, as you can see, my message gathered a fair few positive reactions. As was inevitable, the next morning I found myself locked out of the Slack. I had been permabanned.

Then things got weird.

Someone claiming to be an employee of Automattic sent me a message saying that Matt had personally told people to ban me. I didn't know if they were telling the truth, but the GDPR gives me the right to see the data a company holds about me. That includes messages about me stored on their internal systems.

The WordPress.org Privacy Policy gave me an email address for their Data Protection Officer (DPO). So I sent a friendly(ish) message. After a little back-and-forth to clarify which data I wanted, I received this truly bizarre reply.

We are in receipt of your request, which you claim is justified by GDPR. Accordingly, we are processing your request pursuant to section 15(3) of GDPR, which requires us to provide personal information about the person that we are processing. You refer to messages sent about you on internal systems. To the extent those are outside the scope of GDPR, they are not covered by your request.

This betrays a fundamental misunderstanding of GDPR. There is not, as far as I know, an exemption for records held on internal systems. There are a list of GDPR exemptions - but they mostly relate to things like the detection of crime, academic and journalistic exemptions, health and social work data, etc.

Of course, there is an exemption for the purposes of self-incrimination. Perhaps that's what they're relying upon?

I replied with a (not so-friendly) email pointing out that I was entitled to a copy of any messages because they contain my personal data. I also pointed out that my request was neither manifestly unfounded nor manifestly excessive (another common get-out clause).

A week later, they replied:

I’ve followed up looking for any related records, and can confirm no records which use your likeness exist, other than the following: edent was deactivated by <<REDACTEDUSER>> No records exist where this was discussed beforehand.

I take this to mean that either Matt personally swung the ban-hammer, without discussing it with anyone else, or that a flunky wanted to protect their master's ego and took unilateral action.

They only provided me with messages from Slack that I had sent. They didn't provide any of the messages that mentioned me.

I pushed for further clarification - but their answer baffled me:

The Slack instance you are asking about is a communication tool used by the WordPress volunteer community to coordinate on the project to build and maintain the open source WordPress software. There is no business or data controller that owns or manages this Slack. If one or more of the volunteers had a private discussion about you in this Slack you would need to direct your request to those individuals and they would need to decide themselves how to handle your request.

(Emphasis added.)

This, to me, implies that they are not following Slack's term's and conditions which explicitly say the owner of the Slack has to comply with data requests.

As between [Slack] and the customer, you agree that it is solely the customer’s responsibility to […] respond to and resolve any dispute with you and any authorised user relating to or based on customer data

Is this Slack really owned by volunteers? According to https://wordpress.slack.com/account/workspace-settings#admins - the primary owner is WordPress.org itself. Although there are several other users listed as owners, including Matt himself.

I specifically asked WordPress.org for details of their GDPR registration. Their reply is hilarious:

WordPress.org is privately owned by a person, not by a registered or covered entity.

While the email address says “Data Protection Officer” this is merely to make it easy for Europeans to find and contact the privacy volunteers who, of course, want to do their best to assist persons with privacy related questions and requests. This does not indicate that WordPress.org is a GDPR covered website or owned by any entity which is subject to the GDPR.

So now we're at an impasse. I have no way of knowing if the anonymous tip-off I received was genuine and I can't prove if WordPress are concealing messages to me. I think it is fair to say that other people feel that WordPress.org doesn't really understand the GDPR - so we can add this example to the list.

To sum up:

• WordPress.org is personally owned by Matt Mullenweg
• The website processes millions of users' data, yet has no GDPR policy.
• Volunteers are apparently cosplaying as Data Protection Officers, without any real knowledge of how GDPR works.
• An official WordPress.org Slack is run by WordPress.org with Matt & others as admins.
• This Slack processes the data of over 50,000 users without any GDPR compliance.

In my opinion, this is no way to run a major piece of web infrastructure. The community deserves better.

<a href="https://shkspr.mobi/blog/2024/12/change-wordpress-fragment-links-in-rss-feeds-to-be-permalinks/#where-is-this-a-problem>Jump%20to%20heading</a>/code/prepSo%20when%20someone%20clicks%20on%20a%20link,%20they%20a%20href="#where-is-this-a-problem">go straight to the relevant section.  For example, they might want to skip straight to how to fix it.


Isn't that clever?

Where is this a problem?

This works great when someone is on my website. They're on the page, and a fragment links straight to the correct section of that page.

But some people view this blog in RSS & Atom feeds - and those feeds also power my newsletter.

When those people see a fragment, it is devoid of its original context. So they end up going to some random location, or my homepage.

How to fix it?

Stick this into your WordPress theme's functions.php file:

//  In the RSS feed, change #whatever to <permalink>#whatever
function rewrite_fragment_links_in_rss($content) {
    global $post;

    //  Ensure this is a feed
    if ( is_feed() && $post instanceof WP_Post ) {
        //  Get the permalink
        $base_url = get_permalink( $post );

        //  Regex to get href="https://shkspr.mobi/blog/2024/12/change-wordpress-fragment-links-in-rss-feeds-to-be-permalinks/#%20%20%20%20%20%20%20%20$content%20=%20preg_replace_callback(%20%20%20%20%20%20%20%20%20%20%20%20"/href=["\']#([^"\']+)["\']/',
            function ( $matches ) use ( $base_url ) {
                return 'href="' . esc_url( $base_url . '#' . $matches[1] ) . '"';
            },
            $content
        );
    }

    return $content;
}

//  Hook into feed filters for both excerpts and full content
add_filter( "the_excerpt_rss",  "rewrite_fragment_links_in_rss" );
add_filter( "the_content_feed", "rewrite_fragment_links_in_rss" );


That listens out for the RSS feed being generated and replaces #whatever with https://shkspr.mobi/blog/2024/12/change-wordpress-fragment-links-in-rss-feeds-to-be-permalinks#whatever

Nifty!

Hopefully, if you click on the links in my emails and feeds, it should take you to the right place now.
]]>
					
					https://shkspr.mobi/blog/2024/12/change-wordpress-fragment-links-in-rss-feeds-to-be-permalinks/feed/
			1
		
		
			
		
		
		https://shkspr.mobi/blog/2024/10/using-phplist-for-a-blogs-newsletter/
					https://shkspr.mobi/blog/2024/10/using-phplist-for-a-blogs-newsletter/#comments
				
		Thu, 31 Oct 2024 12:34:36 +0000
				
		
		
		
		
		
		
		https://shkspr.mobi/blog/?p=53583

					
										Some people like to receive this blog via email. I previously used JetPack to send out subscriber messages - but it became increasingly clear that Automattic isn't a good steward of such things.  I couldn't find any services which would let me send a few thousand subscribers a few emails per week, at zero cost.


So, redecentralise!

I installed phpList which is an open source email campaign tool.  My webhost - Krystal - had a one-click install option. But, phpList isn't quite one-click for sending out a regular blog newsletter.  I found the set-up to be quite confusing, so here are the steps I took to turn an RSS feed into an Email Newsletter for free.

Install the plugins


Navigate to Config → Manage plugins
Enable "CommonPlugin"
Add the RSS Feed Plugin using the Plugin package URL https://github.com/bramley/phplist-plugin-rssfeed/archive/master.zip


Configure the RSS Feed Plugin


Navigate to Config → Settings
Scroll down to the RSS Settings
Set both Minimum and Maximum number of items to 1

That will ensure you only send the latest RSS item as your newsletter.
Set "Use the item summary content (the description or summary element) instead of the content element" to "No". This will allow the full text of the RSS item to be sent.


Edit config.php

For some reason, you need to manually edit this file in a text editor, rather than a GUI.


Set define('USE_REPETITION', 1); - this allows the newsletter to be sent whenever there is a new RSS item.
Set define('CLICKTRACK', 0); - this removes tracking links from your emails. I don't care who opens my emails or what they click on.


Add The Campaign


Go to  Campaigns → Send a campaign.
Start a new campaign.


Tab 1


Campaign subject should be [RSSITEM:TITLE] - that will make the subject line the same as your post's title
Compose message should be [RSS] - that will ensure the contents come from your RSS feed.


Tab 2


Add your RSS feed's URl
Order items "Newest" first - to get the most recent item.
Add a custom HTML template. I used one from https://emailframe.work/


<div style="margin:0; padding:0; background-color:#F2F2F2;">
  <h1><a href="[URL]">[TITLE]</a></h1>
  <table width="100%" border="0" cellpadding="0" cellspacing="0" bgcolor="#F2F2F2">
      <tr>
          <td valign="top">
              [CONTENT]
          </td>
      </tr>
  </table>
</div>


Tab 3


Send as HTML


Tab 4


"Stop sending after" - choose the furthest date in the future possible.
"Repeat campaign every" - I chose "hour". That should check the RSS feed each hour.


Tab 5


"Lists" - pick the email list you want to send from.


Tab 6


You should be finished! It will tell you if there are any errors.
Place the campaign in the queue for processing.


WordPress Sign Up Form

You can either redirect users to your phpList subscription page, or put a form directly on your site.

<form method="post" action="/YourSubscribePage/?p=subscribe&id=1" name="subscribeform">
    <label for="email">Email address:</label>
    <input type="email" name="email" required="required" placeholder="" size="40" id="email">
    <input type="hidden" name="htmlemail" value="1">
    <input type="hidden" name="list[2]" value="signup">
    <input type="hidden" name="listname[2]" value="newsletter">
    <div style="display:none">
        <input type="text" name="VerificationCodeX" value="" size="20">
    </div>
    <input type="submit" name="subscribe" value="Subscribe">
</form>


Adjust the hidden parameters based on your list.

If in doubt, go to Config →  Subscribe pages, and generate a new subscribe page. Then copy the form from that.

Cron Jobs

You need two cron jobs set up.

Update the RSS feed

I run this every hour:

/usr/bin/php /path/to/YourSubscribePage/admin/index.php -p get -m RssFeedPlugin -c /path/to/YourSubscribePage/config/config.php

Process the Queue

I run this a few minutes after the RSS feed is updated

/usr/bin/php -q /path/to/YourSubscribePage/admin/index.php -p processqueue -c /path/to/YourSubscribePage/config/config.php >/dev/null

And then...

That should be it.  There are lots of options which you can fiddle around with. But the above should be enough to get your first newsletter out.

Huge thanks to Duncan Cameron for graciously answering my noddy questions and helping me out with the config.
]]>
					
					https://shkspr.mobi/blog/2024/10/using-phplist-for-a-blogs-newsletter/feed/
			2
		
		
			
		
		
		https://shkspr.mobi/blog/2024/10/wordpress-sic-transit-gloria-mundi/
					https://shkspr.mobi/blog/2024/10/wordpress-sic-transit-gloria-mundi/#comments
				
		Mon, 21 Oct 2024 11:34:59 +0000
				
		
		
		
		https://shkspr.mobi/blog/?p=53533

					
										Why do so many vastly-wealthy tech personalities go mad?


My ideal job involves being employed by a millionaire tech-bro. Just before they get on stage, or moments before they file a lawsuit, or an instant before they publish their thought leadership - I will appear to them. I will be dressed in rags, body smeared with excrement, weeping sores blotching my face. I will sidle up to them, lean down, and whisper into their ear "Sic Transit Gloria Mundi!"

This used to be the way, of course. When a new Pope or Emperor was paraded through the streets, the people cheered and the acolytes coo'd. But someone would chant at them in Latin, "Thus passes all Earthly glory."

The sun sets on every empire. Each god-king was eventually proved to be mortal. The evil that men do lives after them and the good is oft interred within their bones. And so on. We know this. No one is perfect all the time. Every genius has a moment of idiocy.

For small projects, it makes sense to have only one gaffer. All the work passes through him. Too many cooks poison the well.

As projects get bigger, one person doesn't scale. It is functionally impossible to know everything, see everything, please everyone. Yet the sole arbiter remains. We (almost-jokingly) call this position BDFL. The Benevolent Dictator For Life.

But BDFL only works if the D is genuinely B. Otherwise the FL becomes FML.

It must be psychologically difficult being responsible for a mega-project. I certainly couldn't do it. If you're wasting time reading this blog post, you almost certainly couldn't do it.  I like my friends to challenge my occasional missteps. I want people to be somewhat honest to my face. I can't imagine what it would do to my ego to receive endless praise. Of course I'd tune out the negative voices.

This isn't to excuse their excesses. Nor to fully demystify their demagoguery. I just want them to have good mental health so their public meltdowns don't reverberate through the æther, infecting us all with their psychic fallout.

*sigh* I'd rather not be blogging about blogging.
]]>
					
					https://shkspr.mobi/blog/2024/10/wordpress-sic-transit-gloria-mundi/feed/
			3
		
		
			
		
		
		https://shkspr.mobi/blog/2024/10/import-jetpack-statistics-into-koko/
					https://shkspr.mobi/blog/2024/10/import-jetpack-statistics-into-koko/#comments
				
		Fri, 18 Oct 2024 11:34:10 +0000
				
		
		
		
		https://shkspr.mobi/blog/?p=53483

					
										I've quit JetPack stats. I've moved to Koko Analytics. All the stats code is self hosted, it is privacy preserving, and the codebase is small and simple.


But I am vain. I want all my old JetPack stats to appear in Koko so I can look back on the glory days of blogging.

Koko has two main tables.  The first is a summary table called wpbp_koko_analytics_site_stats :




  
date
  
visitors
  
pageviews




  
2009-10-30
  
25
  
47


  
2009-10-31
  
70
  
86


  
2009-11-01
  
61
  
72




That's the total number of visitors and page views for each date.

Then there's a more detailed breakdown at wpbp_koko_analytics_post_stats




  
date
  
id
  
visitors
  
pageviews




  
2009-10-30
  
123
  
2
  
2


  
2009-10-30
  
456
  
5
  
6


  
2009-10-30
  
789
  
1
  
1




That shows every individual post's number of views and visitors per day.

WordPress's database is MySQL. It can handle CSV imports. So, given these tables are pretty simple, it is possible to get the old WordPress stats, convert them to CSV, and then import them.

Let's go!

As described in a previous post, the JetPack stats API is fairly basic. It doesn't differentiate between visitors and pageviews. So, for this import, we'll pretend they're the same.

This will be a 4 step process.

1. Get all your stats in JSON format

This code loops through your stats and downloads a JSON file for each one.

You will need:


Your API key - find it at https://apikey.wordpress.com/
Your blog's web address - I assume you know this
The earliest date you have for JetPack - you will need to find this yourself


import requests
import datetime
import os
import json

# Directory to save the JSON files
save_dir = "jetpack_stats"
os.makedirs(save_dir, exist_ok=True)

# URL of the API
base_url = "https://stats.wordpress.com/csv.php?api_key=123456789012"+\
           "&blog_uri=https://example.com/"+\
           "&table=postviews"+\
           "&days=1"+\
           "&format=json"+\
           "&limit=-1"+\
           "&end="

# Make API call and save the response
def fetch_and_save_json(date):
    # Format the date as ISO8601 (YYYY-MM-DD)
    formatted_date = date.isoformat()

    # Make the API call
    url = f"{base_url}{formatted_date}"
    response = requests.get(url)

    if response.status_code == 200:
        data = response.json()
        file_name = f"{formatted_date}.json"
        file_path = os.path.join(save_dir, file_name)
        with open(file_path, "w") as f:
            json.dump(data, f, indent=4)

        print(f"Saved {formatted_date}")
    else:
        print(f"Failed! {formatted_date} status code: {response.status_code}")

# Iterate over a date range
start_date = datetime.date(2020,  1 , 1)
end_date   = datetime.date(2024, 10, 30)

# Loop through all dates 
current_date = start_date
while current_date <= end_date:
    fetch_and_save_json(current_date)
    current_date += datetime.timedelta(days=1)


2. Generate The Individual Posts' Stats

This takes those JSON files and creates a single CSV ready to upload to wpbp_koko_analytics_post_stats.

import os
import json
import csv

# Directory where the JSON files are stored
json_dir = "jetpack_stats"

# List to hold the loaded data
all_data = []

json_files = sorted( [ file for file in os.listdir( json_dir ) if file.endswith( ".json" ) ] )

# Loop through all files in the directory
for file_name in json_files :
    if file_name.endswith( ".json" ) :
        file_path = os.path.join(json_dir, file_name)
        with open(file_path, "r") as json_file :
            data = json.load(json_file)
            all_data.append(data)  # Add the data to the list

print(f"Total files loaded: {len(all_data)}")
with open( "wpbp_koko_analytics_post_stats.csv", "w", newline="") as csvfile:
    csvwriter = csv.writer( csvfile, delimiter="," )
    for stat in all_data:
        for views in stat[0]["postviews"] :
            csvwriter.writerow( [ stat[0]["date"], views["post_id"], views["views"], views["views"] ] )


3. Generate the total site views

It is possible to get this separately from the JetPack API using &table=views - but that's a lot more API calls. So we're just going to sum it up instead 😄

This, again, inserts a dummy value for visitors.

import pandas as pd

input_csv  = "wpbp_koko_analytics_post_stats.csv"
output_csv = "wpbp_koko_analytics_site_stats.csv"

column_names = ['Date', 'Post ID', 'Visitors', 'Page Views']
df = pd.read_csv( input_csv, names=column_names )

# Group by Date and sum the Page Views
df_grouped = df.groupby( "Date" )["Page Views"].sum().reset_index()

# Add a new column with a copy of the Page Views
df_grouped['Visitors'] = df_grouped['Page Views']

# Rename the Page Views column to Total Page Views
df_grouped = df_grouped.rename(columns={"Page Views": "Total Page Views"})

# Write the dataframe to the output CSV file
df_grouped.to_csv( output_csv, index=False,  header=False )


4. Upload to MySQL

You're on your own here, Sparky. If you have something like PHPMyAdmin, you should be able to load the file in directly. Anything else… good luck!

Once done, your stats dashboard should be filled with historic data.



Huge thanks to Koko Analytics for providing such a great tool and answering my questions.
]]>
					
					https://shkspr.mobi/blog/2024/10/import-jetpack-statistics-into-koko/feed/
			6
		
		
			
		
		
		https://shkspr.mobi/blog/2024/10/liberate-your-daily-statistics-from-jetpack/
					https://shkspr.mobi/blog/2024/10/liberate-your-daily-statistics-from-jetpack/#comments
				
		Thu, 17 Oct 2024 11:34:16 +0000
				
		
		
		
		https://shkspr.mobi/blog/?p=53473

					
										Because Ma.tt continues to burn all of the goodwill built up by WordPress, and JetPack have decided to charge a ridiculous sum for their statistics, I've decided to move to a new stats provider.  But I don't want to lose all the statistics I've built up over the years.


How do I download a day-by-day export of my JetPack stats0?

Luckily, there is an API for downloading all your JetPack stats!

First, get your API key by visiting https://apikey.wordpress.com/ - it should be a 12 character string. For this example, I'm going to use 123456789012. You will need to use your own API key.

There is some brief documentation on that page. Here are the bits we are interested in:

api_key     String    A secret unique to your WordPress.com user account.
blog_uri    String    The full URL to the root directory of your blog. Including the full path.
table       String    One of views, postviews, referrers, referrers_grouped, searchterms, clicks, videoplays.
end         String    The last day of the desired time frame. Format is 'Y-m-d' (e.g. 2007-05-01) and default is UTC date.
days        Integer   The length of the desired time frame. Default is 30. "-1" means unlimited.
limit       Integer   The maximum number of records to return. Default is 100. "-1" means unlimited. If days is -1, limit is capped at 500.
format      String    The format the data is returned in, 'csv', 'xml' or 'json'. Default is 'csv'.


In order to get all of the statistics from a single day, the URl is:

https://stats.wordpress.com/csv.php?api_key=123456789012
     &blog_uri=https://shkspr.mobi/blog/
     &table=postviews
     &end=2024-10-07
     &days=1
     &limit=-1


That gets all of the statistics from one specific day. The limit=-1 means it will retrieve all the records of that day1.

That will get you a CSV which looks like:

"date","post_id","post_title","post_permalink","views"
"2024-10-09",0,"Home page","https://shkspr.mobi/blog/",59
"2024-10-09",42171,"Review: HP's smallest laser printer - M140w + Linux set up","https://shkspr.mobi/blog/2022/04/review-hps-smallest-laser-printer-m140w-linux-set-up/",7
"2024-10-09",49269,"No, Oscar Wilde did not say ""Imitation is the sincerest form of flattery that mediocrity can pay to greatness""","https://shkspr.mobi/blog/2024/01/no-oscar-wilde-did-not-say-imitation-is-the-sincerest-form-of-flattery-that-mediocrity-can-pay-to-greatness/",7
"2024-10-09",53333,"The Cleaner 🆚 Der Tatortreiniger - Series 3","https://shkspr.mobi/blog/2024/10/the-cleaner-%f0%9f%86%9a-der-tatortreiniger-series-3/",7
"2024-10-09",49943,"Solved! ""Access Point Name settings are not available for this user""","https://shkspr.mobi/blog/2024/03/solved-access-point-name-settings-are-not-available-for-this-user/",7
"2024-10-09",43690,"WhatsApp Web for Android - a reasonable compromise?","https://shkspr.mobi/blog/2022/11/whatsapp-web-for-android-a-reasonable-compromise/",5


You can also get a JSON file using &format=json, although it doesn't contain the permalinks.

[
    {
        "date": "2024-10-09",
        "postviews": [
            {
                "post_id": 0,
                "post_title": "",
                "permalink": "",
                "views": 59
            },
            {
                "post_id": 49269,
                "post_title": "No, Oscar Wilde did not say \"Imitation is the sincerest form of flattery that mediocrity can pay to greatness\"",
                "permalink": "",
                "views": 9
            },
            {
                "post_id": 42171,
                "post_title": "Review: HP's smallest laser printer - M140w + Linux set up",
                "permalink": "",
                "views": 7
            },


From there, I wrote a scrap of Python to download every single date individually.

import requests
import datetime
import os
import json

# Directory to save the JSON files
save_dir = "jetpack_stats"
os.makedirs(save_dir, exist_ok=True)

# URL of the API
base_url = "https://stats.wordpress.com/csv.php?api_key=123456789012"+\
           "&blog_uri=https://example.com/"+\
           "&table=postviews"+\
           "&days=1"+\
           "&format=json"+\
           "&limit=-1"+\
           "&end="

# Make API call and save the response
def fetch_and_save_json(date):
    # Format the date as ISO8601 (YYYY-MM-DD)
    formatted_date = date.isoformat()

    # Make the API call
    url = f"{base_url}{formatted_date}"
    response = requests.get(url)

    if response.status_code == 200:
        data = response.json()
        file_name = f"{formatted_date}.json"
        file_path = os.path.join(save_dir, file_name)
        with open(file_path, "w") as f:
            json.dump(data, f, indent=4)

        print(f"Saved {formatted_date}")
    else:
        print(f"Failed! {formatted_date} status code: {response.status_code}")

# Iterate over a date range
start_date = datetime.date(2023,  1 , 1)
end_date   = datetime.date(2024, 10, 30)

# Loop through all dates 
current_date = start_date
while current_date <= end_date:
    fetch_and_save_json(current_date)
    current_date += datetime.timedelta(days=1)


You'll need to manually find the earliest date for which your blog has statistics.

Running the code is a little slow. Expect about 3 minutes per year of data. I'm sure you could parallelise it if you really needed to.

Now, for my next trick, how do I import these data into a new stats plugin? That's tomorrow's blog post!






When people ask on the official support forum, they're told to privately contact JetPack. There's a help page which shows how to download a summary. But I couldn't find anything more fine-grained than that. ↩︎



The maximum number of records for a specific day in my dataset was 978. ↩︎




]]>
					
					https://shkspr.mobi/blog/2024/10/liberate-your-daily-statistics-from-jetpack/feed/
			2
		
		
			
		
		
		https://shkspr.mobi/blog/2024/10/how-to-make-markdown-footnotes-start-at-zero-in-wordpress/
					https://shkspr.mobi/blog/2024/10/how-to-make-markdown-footnotes-start-at-zero-in-wordpress/#comments
				
		Fri, 11 Oct 2024 11:34:59 +0000
				
		
		
		
		
		https://shkspr.mobi/blog/?p=52307

					
										As a dedicated and professional computer scientician0, I believe that all indices must start at zero. Not one, not two, but zero1.


The zeroth2 element is sacrosanct to our creed; for in the beginning there was nothing.

If you're using WordPress's JetPack, it uses an ancient version of Markdown Extra.  You can either monkeypatch this, or install a separate Markdown plugin.

I've patched my fork of it in two specific places.

Firstly, I set $this->footnote_counter = 0; in the initial config of the footnotes.

Secondly, I changed the display so that the ordered list began from zero: <ol start="0">

Wait… should that be zerothly and firstly?

There's no way to change footnote links to symbols like * or ♪. Perhaps I'll add that next3😉?

Anyway, I enjoy hacking around on my theme.






I've even got certificates in it! ↩︎



Five is right out! ↩︎



Or is it "noughtst"? ↩︎



OK, maybe there is a way. But it isn't particularly easy or automated. ↩︎




]]>
					
					https://shkspr.mobi/blog/2024/10/how-to-make-markdown-footnotes-start-at-zero-in-wordpress/feed/
			5
		
		
			
		
		
		https://shkspr.mobi/blog/2024/08/wordpress-display-hook-action-priority-in-the-dashboard/
					https://shkspr.mobi/blog/2024/08/wordpress-display-hook-action-priority-in-the-dashboard/#comments
				
		Sat, 31 Aug 2024 11:34:14 +0000
				
		
		
		
		https://shkspr.mobi/blog/?p=52230

					
										If your WordPress site has lots of plugins, it's sometimes difficult to keep track of what is manipulating your content. Ever wondered what priority all your various actions and filters have? This is a widget which will show you which actions are registered to your blog's hooks, and their priority order.


It looks like this:



Stick this code in your theme's functions.php or in its own plugin.

function edent_priority_dashboard_widget_contents() {
    global $wp_filter; 
    //  Change this to the hook you're interested in
    $hook_name = "the_content";
    if ( isset( $wp_filter[$hook_name] ) ) {

        //  Display the hook name in the widget
        echo "<h3>{$hook_name}</h3>";

        //  Start a list
        echo "<ul>";

        //  Loop through the callbacks in priority order
        foreach ( $wp_filter[$hook_name]->callbacks as $priority => $callbacks ) {
            echo "<li>Priority: {$priority}<ul>";

            foreach ( $callbacks as $callback ) {
                //  Some callbacks are arrays
                if ( is_array( $callback["function"] ) ) {
                    if (is_object($callback["function"][0])) {
                        $callback_info = get_class($callback["function"][0]) . '::' . $callback["function"][1];
                    } else {
                        $callback_info = $callback["function"][0] . '::' . $callback["function"][1];
                    }
                } else {
                    $callback_info = $callback["function"];
                }
                //  Show the information
                echo "<li>Callback: {$callback_info}</li>";
            }
            echo "</ul></li>";
        }
        echo '</ul>';

    } 
    else {
        echo "No filters found for hook: {$hook_name}";
    }

    //  Scrap of CSS to ensure list items display properly on the dashboard
    $priority_css_code = "#edent_dashboard_widget ul { list-style: circle; padding: 1em; }";
    //  Inline the CSS
    echo "<link rel=\"stylesheet\" type=\"text/css\" href=\"data:text/css;base64," . 
        base64_encode($priority_css_code) . "\">";

}

//  Register the widget with the admin dashboard
function edent_register_dashboard_widget() {
    wp_add_dashboard_widget(
        "edent_dashboard_widget",   //  ID of the widget
        "Priorities",   //  Title of the widget
        "edent_priority_dashboard_widget_contents"  //  Function to run
    );
}
add_action( "wp_dashboard_setup", "edent_register_dashboard_widget" );


Why?

WordPress lets you add actions and filters to hooks.  For example, whenever your blog wants to show some content, a hook of the_content is run.

You can add an action to run a function when that happens. For example, if you want to make all the text in your blog posts uppercase, you could add this to your theme or plugin:

function lower_case_everything( $content ) {
   return strtolower( $content );
}
add_filter( 'the_content', 'lower_case_everything', 99 );


The add_filter says "When the hook called the_content is fired, run the function lower_case_everything, with a priority of 99".  The lower the number, the sooner the function is run.
]]>
					
					https://shkspr.mobi/blog/2024/08/wordpress-display-hook-action-priority-in-the-dashboard/feed/
			2
		
		
			
		
		
		https://shkspr.mobi/blog/2024/08/liberate-your-markdown-posts-from-jetpack-in-wordpress/
					https://shkspr.mobi/blog/2024/08/liberate-your-markdown-posts-from-jetpack-in-wordpress/#respond
				
		Sun, 25 Aug 2024 11:34:20 +0000
				
		
		
		
		
		https://shkspr.mobi/blog/?p=51755

					
										A scrap of code which I hope helps you.


Problem

You installed the WordPress JetPack plugin and wrote all your blog posts in Markdown. Now you want to remove JetPack or replace it with a better Markdown parser.

You turn off JetPack's "Write posts or pages in plain-text Markdown syntax".  You click edit on a post and see the HTML version of your page. Where did the Markdown version go?

Background

When you write using JetPack's Markdown plugin, the Markdown version is stored in post_content_filtered. When you hit "publish" or "update", the page is parsed as Markdown and the HTML output is stored in post_content.

When you hit "edit", the post_content_filtered version is loaded into the editor - and the process starts again.

Solution

When you edit a post, replace the content with the filtered version, then delete the filtered version.

Place this code in your theme's functions.php.

function edit_markdown_content( $content, $id ) {
    $post = get_post( $id );
    if ( $post && ! empty( $post->post_content_filtered ) ) {
        //  Get the Markdown version
        $markdown = $post->post_content_filtered;

        //  Delete the post_content_filtered version
        global $wpdb;
        $debug = $wpdb->query( 
            $wpdb->prepare(
                "UPDATE $wpdb->posts SET `post_content_filtered` = '' WHERE `wp_posts`.`ID` = %d",
                                                                                              $id
            )
        );

        //  Replace the post_content with the Markdown version
        $post->post_content = $markdown;

        //  Send it to the editor with a message saying that it was restored, along with the date of restoration
        return "<!-- Restored from post_content_filtered \n" . date("c") . "\n-->" . $post->post_content;
    }
    return $post->post_content;
}
add_filter( "edit_post_content", "edit_markdown_content", 1, 2 );


I adapted it from WP Githuber MD

Direct MySQL

If you want to automatically convert all your posts, you can edit your database directly.

UPDATE wp_posts
SET 
    post_content = post_content_filtered,
    post_content_filtered = ''
WHERE post_content_filtered IS NOT NULL AND post_content_filtered<>'';


Warning

If you do not have a Markdown parser installed, posts will come out looking *very* strange.
]]>
					
					https://shkspr.mobi/blog/2024/08/liberate-your-markdown-posts-from-jetpack-in-wordpress/feed/
			0
		
		
			
		
		
		https://shkspr.mobi/blog/2024/08/replace-twitter-embeds-with-semantic-html/
					https://shkspr.mobi/blog/2024/08/replace-twitter-embeds-with-semantic-html/#comments
				
		Sat, 24 Aug 2024 11:34:34 +0000
				
		
		
		
		https://shkspr.mobi/blog/?p=51484

					
										I logged into Twitter using a fresh account last week. No followers, no preferences set. The default experience was an unending slurry of racism and porn.  I don't care to use Twitter any more. Whatever good that was there is now drowned in a cess-pit of violent filth.


I still have a lot of Tweets embedded on this blog. Using WordPress, it was easy to paste in a link and have it converted to an embed. But I don't want to direct people to a dangerous site.

So here's a somewhat automated way to replace embedded Tweets with good-looking and semantic HTML.  You no longer need to worry about Twitter tracking people if they visit your site. It in-lines all images and avatars so there's no data leakage. Links go direct rather than through the obnoxious t.co service. The HTML is semantic, short, and accessible.

The simple Python code is available on GitHub - feedback welcome!

Demos

Here are some examples. You'll see all the links work - to external sites, hashtags, or mentions. Media is loaded, emoji work, alt text is included where available, and the CSS is roughly right.  The number of likes and replies is shown - but the number of retweets isn't always available in the embed API. The number of quotes and bookmarks aren't available.

Polls



polls
@polls
Which Direction?
North: (13,835)
13835
South: (5,584)
5584
East: (4,597)
4597
One: (18,469)
18469


Embedded Images

hackaday
@hackaday
Can a hacker do YouTube full time? @XRobotsUK says yes (with an asterisk) and talks gory details #HackadayUncon pic.x.com/7h1ozav0wt


Quote Tweets

Terence Eden is on Mastodon
@edent
Whoever buys the gu.com domain will effectively get to rewrite history.
They can redirect links like these - and change the nature of the content being commented on.
Joyce Alene
@JoyceWhiteVance
The Steele Dossier asserted Russian hacking of the DNC was "conducted with the full knowledge & support of Trump & senior members of his campaign.” Trump's war against the FBI & efforts to obstruct make sense if he thought they could prove it. gu.com/p/axa7k/stw


Replies

Terence Eden is on Mastodon
@edent
Working from home is tricky when @virginmedia goes down so hard even its status page falls over.
Time for lunch. pic.x.com/mje6nh38cz
Sky
@SkyUK
Replying to @edent@edent I can definitely see how this would get in the way of making your day a productive one. Do you find this happens often? If it does, I'd be happy to chat to you about a reliable alternative with us during your lunch break! ☕ PM me for a chat! ^JH


Videos

The poster of the video is embedded - the actual MP4 is still loaded off Twitter's site.

Ruben Casas 🦊
@Infoxicador
Attending my first in person event since the pandemic. 

#TapIntoTwitter hosted by @gerardsans and @coderinheels

Nothing better than a cool live demo. 

🤯 pic.x.com/qw1ifom7fh


Get The Code

The simple Python code is available on GitHub - feedback welcome!
]]>
					
					https://shkspr.mobi/blog/2024/08/replace-twitter-embeds-with-semantic-html/feed/
			5
		
		

			
		
		
		https://shkspr.mobi/blog/2024/07/remove-unnecessary-closing-slash-on-get_the_post_thumbnail-in-wordpress/
					https://shkspr.mobi/blog/2024/07/remove-unnecessary-closing-slash-on-get_the_post_thumbnail-in-wordpress/#comments
				
		Wed, 24 Jul 2024 11:34:13 +0000
				
		
		https://shkspr.mobi/blog/?p=51115

					
										I am a pedant. I like it when validators say "nothing to report". No errors, no warnings, no information messages.


My blog is plagued with messages on the HTML validator saying

Info: Trailing slash on void elements has no effect and interacts badly with unquoted attribute values.

By default, the WordPress function get_the_post_thumbnail() spits out HTML like:

<img width="1024" height="593" 
     src="example.jpg"
     alt="whatever"
/>


That final / is unnecessary. Having it there doesn't do any harm. It doesn't break anything - except my calm - and is safe to leave in place.

Let's get rid of it anyway!

Place this in your theme's functions.php file:

//  get_the_post_thumbnail() returns <img ... /> - this removes the unnecessary closing of a void element
function remove_self_closing_slash_from_thumbnail( $html ) {
    //  Check if the string ends with " />"
    if ( substr( $html, -3 ) === " />" ) {
        //  Remove the " />" and add ">"
        $html = substr( $html, 0, -3 ) . ">";
    }
    return $html;
}

add_filter( "post_thumbnail_html", "remove_self_closing_slash_from_thumbnail" );


That adds a filter to the post_thumbnail_html hook and edits the string it returns.

There are various ways to approach this, you could load the element into a DOMDocument or have a complex regular expression - but this seems the simplest and safest.

Now, how do I remove the rest of the needless /> that WordPress scatters about?
]]>
					
					https://shkspr.mobi/blog/2024/07/remove-unnecessary-closing-slash-on-get_the_post_thumbnail-in-wordpress/feed/
			5