First Look at Themosis, a Framework for WordPress Developers

Themosis: A Modern Approach to WordPress Development

My disdain for WordPress's tangled codebase is well-known. I advise against its use unless you're technically proficient. However, my criticism stems from a desire for improvement—a hope that a superior alternative will emerge, offering a more logical and efficient development process. Any attempt to streamline WordPress is, in my view, a positive step.

Recently, a project called Themosis surfaced, billed as a "framework for WordPress developers." This article explores Themosis, its usage, and examines its example project—a bookstore application.

Key Highlights:

• Themosis is a novel project designed as a framework for WordPress developers, aiming to simplify development and impose structure on WordPress's chaotic plugin architecture.
• Unlike traditional frameworks, Themosis functions as an API that integrates with WordPress to enhance development. It enables developers to build WordPress components using modern PHP features (namespaces, classes, anonymous functions) and Composer.
• Themosis installation relies on Composer and the WordPress command-line tool. Composer creates a Themosis project, automatically incorporating the latest WordPress version. A standard WordPress installation script completes the setup.
• Themosis is still in its early stages (version 1.0 pending). Despite its youth, it shows promise in promoting better design practices within the PHP ecosystem, even within the constraints of WordPress's core.

Understanding Themosis

The term "framework" might be misleading to PHP developers. WordPress already contains numerous unnecessary components. Frameworks typically adhere to minimalist principles and decoupled components, with complex applications built upon them—not the other way around.

Themosis isn't a framework in the traditional sense. It's an API that integrates with WordPress to simplify development but doesn't necessarily reduce its size. Themosis provides APIs for creating WordPress components using modern PHP, including namespaces, classes, anonymous functions, and Composer support.

Essentially, Themosis is an MVC-powered, Laravel-inspired WordPress plugin used to build other plugins. It includes its own router (Laravel-style route definition) and templating engine (Scout), similar to Laravel and Phalcon, with added WordPress support. For instance, the template loop:

@loop(array('post_type' => 'post', 'posts_per_page' => -1))

    <h1>{{ Loop::title() }}</h1>
    <div>
        {{ Loop::content() }}
    </div>

@endloop

utilizes the WordPress API for data retrieval, and the Loop class is specifically designed for WordPress content loops.

Installation

Themosis installation involves Composer and the WordPress command-line tool. Creating a Themosis project with Composer automatically includes the latest WordPress version; a standard WordPress installation script finalizes the setup. Refer to the official installation instructions, or experiment with the example project first (detailed below).

Example Project: The Bookstore App

Themosis provides a bookstore application example.

Testing the Bookstore App

To test it, you can use Homestead Improved. Register a new site with:

@loop(array('post_type' => 'post', 'posts_per_page' => -1))

    <h1>{{ Loop::title() }}</h1>
    <div>
        {{ Loop::content() }}
    </div>

@endloop

Remember to add bookstore.local to your host's /etc/hosts file (as per Homestead Improved instructions).

Clone the repository (git clone https://www.php.cn/link/7101e4daaff4511510bbd4e6a0862fb7 themosis_example), and access the installation procedure at http://bookstore.local:8000. Follow the instructions. This setup allows experimentation without risk—simply rebuild the VM to revert any changes.

While the initial appearance isn't groundbreaking (any WordPress site can be configured similarly), two key observations stand out:

1. Setup was remarkably quick and straightforward.
2. Performance was surprisingly fast, considering Themosis's additional layers accessing the WordPress API.

Code Examination

The bookstore's code resides on GitHub: https://www.php.cn/link/7101e4daaff4511510bbd4e6a0862fb7. As Themosis is a plugin, the bookstore's code is located within its plugin directory:

Three main subfolders exist: app (Themosis-powered WordPress logic), src (Themosis source code—resembling other frameworks), and vendor (Composer dependencies).

While the code incorporates modern practices (namespaces, classes, comprehensive documentation), minor outdated elements remain (e.g., <?php defined('DS') or die('No direct script access.');, closing PHP tags).

Themosis code is distributed across two locations: routing and presentation reside in the theme, while application logic is in the plugin folder.

MVC Structure

The MVC structure is well-defined, although the fragmentation across two parent folders could be improved. The routes folder (similar to Laravel) uses comparable syntax. Controllers are separated from views, and models are used by controllers, passing data to views. An example from home.controller.php:

@loop(array('post_type' => 'post', 'posts_per_page' => -1))

    <h1>{{ Loop::title() }}</h1>
    <div>
        {{ Loop::content() }}
    </div>

@endloop

Views use dot notation for traversal (e.g., pages.home maps to app/views/pages/home.scout.php).

Routing with Parameters

Routing is simple. The Search page, for instance, directly uses WordPress's search functionality:

- map: bookstore.local
      to: /home/vagrant/Code/themosis_example

This approach abstracts WordPress's inherently flawed search function, facilitating easier replacement.

Creating a Custom Page

Let's create a custom page with a controller and view.

1. Add a route to routes.php:

return View::make('pages.home')->with(array(

            'promo'     => Books::getPromoBook($this->page),
            'books'     => Books::getPopularBooks($this->bookId),
            'news'      => News::get(),
            'newspage'  => get_page_by_path('news')

        ));

2. Create pages/test.scout.php:

// Search page
Route::is('search', function(){
    return View::make('search', array('search' => $_GET['s']));
});

3. Add a controller (controllers/Test_Controller.php):

Route::only('page', 'test', 'test@index');

This would render "Hello World" for /test in most frameworks. However, because Themosis relies on WordPress, we must add the page to the system.

The "Hello World" message renders after reloading.

To include the page content, we need to access the global $post variable and pass it to the view. This highlights WordPress's global variable reliance.

Modifying the controller:

@include('header')

Hello World

@include('footer')

and the view:

<?php

class Test_Controller{

    public function index(){

        return View::make('pages.test');

    }

}

renders the page correctly.

While somewhat complex, the powerful wrappers for rendering WordPress content provide structure and clarity, improving WordPress's rigidity.

Conclusion

Themosis provides a Laravel-like experience for WordPress plugin development. It introduces much-needed structure and encapsulation to WordPress's plugin architecture.

Although still in its early stages (version 0.8), Themosis is a promising project. The adoption of good design practices is crucial for the PHP community, and Themosis offers a valuable contribution, even within the limitations of WordPress's core.

(The Frequently Asked Questions section has been omitted due to length constraints but could be easily paraphrased and incorporated similarly to the rest of the text.)

The above is the detailed content of First Look at Themosis, a Framework for WordPress Developers. For more information, please follow other related articles on the PHP Chinese website!