Plugins are a key piece of the webpack ecosystem and provide the community with a powerful way to tap into webpack's compilation process. A plugin is able to hook into key events that are fired throughout each compilation. Every step of the way, the plugin will have full access to the compiler and, when applicable, the current compilation .

For a high-level introduction to writing plugins, start with writing a plugin .

Let's start by going over tapable utility, which provides the backbone of webpack's plugin interface.

Tapable

This small library is a core utility in webpack but can also be used elsewhere to provide a similar plugin interface. Many objects in webpack extend the Tapable class. The class exposes tap , tapAsync , and tapPromise methods which plugins can use to inject custom build steps that will be fired throughout a compilation.

It is possible to customize the printed output by passing different arguments to the reportProgress function of ProgressPlugin .

To report progress, a plugin must tap into a hook using the context: true option:

Compiler. hooks. emit. tapAsync (( name: "MyPlugin" , context: true ) , (context, compiler, callback) => ( const reportProgress = context && context. reportProgress; if (reportProgress) reportProgress (0.95, "Starting work" ) ; setTimeout (( ) => ( if (reportProgress) reportProgress (0.95, "Done work" ) ; callback () ; ) , 1000 ) ; ) ) ;

The reportProgress function may be called with these arguments:

reportProgress(percentage, ... args);

• percentage: This argument is unused; instead, ProgressPlugin will calculate a percentage based on the current hook.
• ...args: Any number of strings, which will be passed to the ProgressPlugin handler to be reported to the user.

Note that only a subset of compiler and compilation hooks support the reportProgress function. See ProgressPlugin for a full list.

Logging

Logging API is available since the release of webpack 4.37. When logging is enabled in stats configuration and/or when infrastructure logging is enabled, plugins may log messages which will be printed out in the respective logger format (stats, infrastructure).

• Plugins should prefer to use compilation.getLogger("PluginName") for logging. This kind of logging is stored in the Stats and formatted accordingly. It can be filtered and exported by the user.
• Plugins may use the compiler.getInfrastructureLogger("PluginName") for logging. Using infrastructure logging is not stored in the Stats and therefore not formatted. It"s usually logged to the console/dashboard/GUI directly. It can be filtered by the user.
• Plugins may use special fallback logic for detecting logging support compilation.getLogger ? compilation.getLogger("PluginName") : console to provide a fallback for cases when an older webpack version is used which does not support getLogger method on compilation object.

Next Steps

See the compiler hooks section for a detailed listing of all the available compiler hooks and the parameters they make available.

The plugin is a dynamically loaded library (DLL). After installing the program, all plugins included in the distribution are placed in the directory c:\Program Files (x86)\Common Files\Soft Gold\Inventory 14\Plugins\... The *.abl extension is required for automatic download plugin from the specified directory when the application starts. The plugin can also be loaded from any other location on the disk by specifying the search path in the settings.

Initializing the plugin API

(Delphi VCL Extensions)

(Plugin interface for ABViewer/Inventory)

(Copyright (c) 2002-2010 SoftGold software company)

{************************************************************}

unit sgPluginItem;

interface

implementation

XMLDocRef: IXMLDocument = nil;

ClientRef: IXMLNode = nil;

P: Pointer = nil;

PluginsHostWnd: HWND = 0;

PluginsHostWndName: string = "";

XMLAtomString: string = "";

procedure InitializeDoc;

begin

// getting the unique name of the window class with parameters

PluginsHostWndName:= Format("TsgPluginsHost:%.8X:%.8X", );

// finding the window itself

PluginsHostWnd:= FindWindow(PChar(PluginsHostWndName), nil);

If PluginsHostWnd<>0 then

Begin

// get the atom string to get xml parameter document

XMLAtomString:= Format("XMLOfs%.8X%.8X",

XMLDocRef:= IXMLDocument(GetProp(PluginsHostWnd, PChar(XMLAtomString)));

If Assigned(XMLDocRef) then

Begin

// adding an element to the list

ClientRef:= XMLDocRef.DocumentElement.ChildNodes.ChildNodes.AddChild(sClient);

// initializing the address of the Invoke function

ClientRef.ChildValues["Invoke"] := IntToId(Integer(@Invoke)); // hexadecimal $XXXXXXXX

End;

End;

end;

initialization

CoInitialize(P);

InitializeDoc;

Setting up and running the demo version of the plugin

The demo version of the plugin is configured automatically when installing the program and is connected immediately after launching Inventory. The package includes the source code of the component (project name sgPlugin.dpk) and a demo version of the plugin (project name plug1.dpr).

The procedure for launching the plugin from debug mode:

▪ Open C:\Users\USER_NAME\Documents\Inventory 14\Plugins\Source\Delphi\Demos\Plug1\plug1.dpr

▪ Set in project options:

Search Path : "..\..\Components\PlugItem";

Output derectory , for example: “c:\Program Files\Common Files\Soft Gold\Inventory 14\Plugins”;

Host application, on again installed application, for example: “c:\Program Files\Soft Gold\Inventory 14\Inventory 14.exe”.

▪ Launch for execution.

To use the component in designtime you need to open, rebuild and install C:\Users\USER_NAME\Documents\Inventory 14\Plugins\Source\Delphi\Components\PlugItem\sgPlugin.dpk. After installing the component, in the palette Delphi components, the TsgPluginItem component will appear on the Soft Gold tab, which can be used in designtime, i.e. place on the form.

Hooks are provided by WordPress to allow your plugin to "hook into" the rest of WordPress; that is, to call functions in your plugin at specific times, and thereby set your plugin in motion. There are two kinds of hooks:

1. (Codex)
2. (Codex)

You can sometimes accomplish the same goal with either an action or a filter. For example, if you want your plugin to change the text of a post, you might add an action function to publish_post (so the post is modified as it is saved to the database), or a filter function to the_content (so the post is modified as it is displayed in the browser screen).

For a thorough listing of all action and filter hooks in WP see Adam Brown's WordPress Hooks Database.

Function Reference

Filter Functions

Actions Functions

Activation/Deactivation/Uninstall Functions

Actions

Actions are triggered by specific events that take place in WordPress, such as publishing a post, changing themes, or displaying an . An Action is a custom PHP function defined in your plugin (or theme) and hooked, i.e. set to respond, to some of these events. Actions usually do one or more of the following:

• Modify database data.
• Send an email message.
• Modify the generated administration screen or front-end page sent to a user browser.

The basic steps to make this happen (described in more detail below) are:

1. Create a PHP function that should execute when a specific WordPress event occurs, in your plugin file.
2. Hook this function to the event by using the function.
3. Put your PHP function in a plugin file, and activate it.

Create an Action Function

The first step in creating an action in your plugin is to create a PHP function with the action functionality of your plugin and put it in your plugin file (your plugin file must go into the wp-content/plugins directory). For example, if you want your friends to get an email message whenever you create a new post, you might define the following function:

Function email_friends($post_ID) ( $friends = " [email protected],[email protected]"; mail($friends, "sally"s blog updated", "I just put something on my blog: http://blog.example.com"); return $post_ID; )

For most actions, your function should accept a single parameter (usually the post or comment ID, depending on the action). Some actions take more than one parameter -- check the documentation for the action (if available) or the WordPress source code for more information. Besides the one parameter, you can also access the , and call other WordPress functions (or functions in your plugin file).

Any text output by the function (e.g. with print) will appear in the page source at the location where the action was invoked.

NOTE: Keep in mind that other plugins or the WordPress core may already be using the function name you have thought of. See the next section, for more information.

Avoiding Function Name Collisions

It is possible that someone has created a plugin with a function named the same as one in your plugin.

This is a problem because PHP does not allow multiple functions with the same name. If two plugins provide a function with the same name, or a plugin provides a function with a name the same as a WordPress function, the blog could cease to function. There are two ways to avoid this problem.

The first solution is to prefix every function in your plugin with a unique set of characters. If your name is John Q. Public, you might declare your functions as function jqp_output() (...) . The likelihood that someone with the same initials does the same thing with their plugin is possible but low.

The second - and possibly easier - a solution is to enclose your plugin functions in a class and call the class methods statically. This sounds more complicated than it is.

Consider this class, which expands on the examples provided above:

Class emailer ( static function send($post_ID) ( $friends = " [email protected],[email protected]"; mail($friends,"sally"s blog updated","I just put something on my blog: http://blog.example.com"); return $post_ID; ) ) add_action("publish_post", array("emailer", "send"));

This class called emailer has a method send that implements the plugin functionality.

The add_action() function outside of the class adds the action to WordPress that tells it to call the send method when a post is published. The array used in the second parameter tells the plugin system to call the static method of the class "emailer" named "send".

The function send is protected from the global namespace by the class declaration. It is not possible to call send() directly, and so any other function named send will not collide with this one. If you did want to call send(), you would need to use a scope resolution operator, like this: emailer::send()

The above example is for static methods. If you have an instance of a class then that won"t work. To call a method of an instance you need to pass the instance as a variable. Consider the above example modified to take this into account:

Class emailer ( function send($post_ID) ( $friends = " [email protected],[email protected]"; mail($friends,"sally"s blog updated","I just put something on my blog: http://blog.example.com"); return $post_ID; ) ) $myEmailClass = new emailer(); add_action("publish_post", array($myEmailClass, "send"));

Classes are a complicated subject. Read more about them in the PHP documentation on classes.

Hook to WordPress

After your function is defined, the next step is to "hook" or register it with WordPress. To do this, call in the global execution space of your plugin file:

Add_action("hook_name", "your_function_name", , );

Hook_name The name of an action hook provided by WordPress, that tells what event your function should be associated with. your_function_name The name of the function that you want to be executed following the event specified by hook_name . This can be a standard php function, a function present in the WordPress core, or a function defined by you in the plugin file (such as "email_friends" defined above). priority An optional integer argument used to specify the order in which the functions associated with a particular action are executed (default: 10). Lower correspond numbers with earlier execution, and functions with the same priority are executed in the order added to the action. accepted_args An optional integer argument defining how many arguments your function can accept (default 1), useful because some hooks can pass more than one argument to your function. This parameter is new in release 1.5.1.

In the example above, we would put the following line in the plugin file:

Add_action("publish_post", "email_friends");

Install and Activate

The last step in getting your filter hook to work is to install the file and activate the plugin. The PHP function you wrote and the call must go into a PHP file together, and the PHP file must be installed in the wp-content/plugins directory. Once it is installed, you will need to visit the admin section of WordPress and activate your plugin; see for more details.

Current Hooks for Filters

Activation/Deactivation/Uninstall

If your plugin has tasks to complete only at activation or deactivation time, it can use and Action Reference - A listing of WordPress's action hooks

External Resources

• Adam Brown"s WordPress Hooks Database, a database of all WordPress" hooks, showing which version they come from, and linking to the source code spots that use them. This is the most complete.
• Otto on WordPress:

By Yandex.
It"s a web service, so you don"t need to add that.

Server owners need a special key to enable this plugin.
Login to the Yandex website and then obtain this key , then put it in the API's config.
Please note that the free key supports "only" 10,000,000 characters every month, but you can create how many keys you want.

These are the available languages:

SpoilerTarget">Spoiler

AZERBAIJAN
ALBANIAN
ENGLISH
ARABIC
AFRIKAANS
BASQUE
BELARUSIAN
BULGARIAN
BOSNIAN
WELSH
HUNGARIAN
VIETNAMESE
HAITIAN
GALICIAN
DUTCH
GREEK
GEORGIAN
DANISH
INDONESIAN
IRISH
ITALIAN
ICELANDIC
SPANISH
KANNADA
CHINESE
KOREAN
LATIN
LITHUANIAN
MACEDONIAN
MONGOLIAN
GERMAN
NEPALI
NORWEGIAN
PERSIAN
POLISH
PORTUGUESE
ROMANIAN
RUSSIAN
SERBIAN
SLOVAKIAN
SLOVENIAN
SUNDANESE
TURKISH
UZBEK
UKRAINIAN
FINNISH
FRENCH
HINDI
CROATIAN
CZECH
SWEDISH
SCOTTISH
ESTONIAN
JAPANESE

When you join the server, your language is the server language.
To change it, just type /lang(permission: translator.lang) and select your language from the menu.

If you don't know how to add dependencies, read here.

Developer
Be sure you are using Java >= 8.
Add the JAR to your build path. Then set the "Manual Manifest" setting and create your MANIFEST.MF to the project. Write:

Main-Class: your.package.Class
Class-Path: ..\lib\Translator.jar

Server owners
Be sure you are using Java >= 8.
Create a folder named lib in the main server root, and put here the JAR.
Also, you need to put it in your plugins folder.

//Sending a message translated automatically to the player language
p.sendMessage("§a" + Translator.translate("Hello!", p));

//Sending a message translated manually
p.sendMessage("§a" + Translator.translate("Hello!", Language.ENGLISH, Language.ITALIAN));

//Getting the server language
Language serverLang = Translator.getServerLanguge();

//Getting player's language
Language playerLang = Translator.getPlayerLanguage(p);

• If you reload the API while a plugin that uses it is enabled, it will crash. To fix manually, unload the plugin, reload the API and load the plugin
• Color codes are not supported. To use them see the examples above
• Little lag (the API needs to translate the original text and receive JSON)

If you have any problem, write a post in the discussion or contact me via private messages. I will not reply to bug reports on the reviews section.

Currently there are not plugins that are using this API. If you are using it, tell me it and I will add it here

Recent Reviews

1. Version: 1.0

   Grande frate! Ho letto Powered by Gamehosting, quindi penso tu sia italiano? se si: sai perché da questo errore all" avvio?

   P.s (ho letto impossibile trovare il percorso specificato, ma la cartella ci sta)

   : java.io.IOException: Impossible trovare il percorso specificato
   : at java.io.WinNTFileSystem.createFileExclusively(Native Method)
   : at java.io.File.createNewFile(Unknown Source)
   : at eu.iamgio.translator.UsersFileLoader.loadRegisterFile(UsersFileLoader.java:21)
   : at eu.iamgio.translator.Translator.onEnable(Translator.java:35)
   : at org.bukkit.plugin.java.JavaPlugin.setEnabled(JavaPlugin.java:321)
   : at org.bukkit.plugin.java.JavaPluginLoader.enablePlugin(JavaPluginLoader.java:340)
   : at org.bukkit.plugin.SimplePluginManager.enablePlugin(SimplePluginManager.java:405)
   : at org.bukkit.craftbukkit.v1_8_R3.CraftServer.loadPlugin(CraftServer.java:357)
   : at org.bukkit.craftbukkit.v1_8_R3.CraftServer.enablePlugins(CraftServer.java:317)
   : at net.minecraft.server.v1_8_R3.MinecraftServer.s(MinecraftServer.java:414)
   : at net.minecraft.server.v1_8_R3.MinecraftServer.k(MinecraftServer.java:378)
   : at net.minecraft.server.v1_8_R3.MinecraftServer.a(MinecraftServer.java:333)
   : at net.minecraft.server.v1_8_R3.DedicatedServer.init(DedicatedServer.java:263)
   : at net.minecraft.server.v1_8_R3.MinecraftServer.run(MinecraftServer.java:525)
   : at java.lang.Thread.run(Unknown Source)

Released at the end of 2015. However, by and large, only advanced developers have taken the time to find out how powerful this offering is.

The WordPress REST API package brings together all the modern updates, providing a built-in API that can be integrated into themes, mobile apps, and more. In other words, it allows developers to separate the front-end interface from data management, allowing any application to interact with WordPress. Learning how this tool works can open the door to almost endless possibilities for expanding your WordPress site.

In this article, we'll introduce you to the WordPress REST API project, explain why it's so good, and then offer some ideas for using it. So let’s not waste time and get started!

Introducing the WordPress REST API

The WordPress REST API project (REST from Representational State Transfer) confirms that WordPress is taking steps towards becoming a full-fledged application platform. Its presence is compelling because it adds a standard REST API to the core of WordPress.

The project was first uploaded to GitHub for developers in 2013 by developers Ryan McCue and Rachel Baker. The independent REST API plugin was built into WordPress core in December 2015 after receiving overwhelming support and attracting nearly 100 contributors willing to work on improving its capabilities.

Since the WordPress REST API became part of the core, it has proven its effectiveness. Here are just a few real examples for clarity of application and inspiration in your projects:

1. Event Espresso uses a REST API to provide developers with access to their global infrastructure, allowing them to develop applications using their services.
2. Simmer allows developers access to the API in order to expand their functionality into a full-fledged mobile app or customizing themes.
3. JoinIn provides its own "embeddable" widget using a REST API, populating it with relevant data wherever it is displayed.

This is just the tip of the iceberg when it comes to the innovative purposes of REST APIs. However, let's discuss how the REST API itself works.

How the WordPress REST API works

In short, a REST API works by manipulating text data from one location to another without directly accessing the database or user interface. There are many types of APIs (Application Programming Interfaces), despite this, REST remains a modern and relevant standard.

The REST API is transmitted over Hyper Text Transfer Protocol (HTTP) access points using the JavaScript Object Notation (JSON) format. Simply put, these technologies provide access to APIs using unique web addresses to deliver data that behave like JavaScript objects.

If you've never worked with JavaScript or its object definitions, learn the basics of JSON. Now that we've cleared up the concept of the REST API a little, let's talk about how it can have a big impact on the development process using WordPress.

What does the WordPress REST API mean for developers?

WordPress REST API is a universal integrator of any WordPress installation with any application on the web server or your operating system. Ultimately, this means that the only limit to what can be built with using WordPress, is only our imagination. You can create any application written in any platform or language and use WordPress to process data through the REST API. The open and friendly WordPress community offers tremendous opportunities.

The REST API is based on JavaScript, which is receiving increasing attention, which hints at which programming languages ​​are important to know. You'll soon discover that server-side JavaScript is the new PHP. This can already be seen in WordPress.com's new software, Calypso, which runs entirely on JavaScript and a REST API.

By standardizing the way applications (including WordPress core) interact with WordPress data, WordPress development will become easier and more intuitive. Moreover, it will facilitate integration with third-party platforms.

I hope you now have more reasons why it is important to start learning how to use this technology now. It's time to take your first steps towards using the REST API in your own work!

5 Steps to Get Started with WordPress REST API

As we covered earlier, the REST API can be used with any application or any programming language that can call HTTP resources. We'll focus on using the command line to make REST API requests because it's the simplest method with the least chance of introducing errors that can detract from the learning process.

To do this, you need to open a program with a command line interface (Command Line Interface CLI) on your computer - terminal on macOS or Linux and command line on Windows. The CLI allows you to directly interact with the REST API, without the need to write additional scripts to request and process information. Any request you write in the CLI can be a script in PHP, JavaScript or another language, but the method will be different for each. Direct execution of commands in the CLI. Just type the command you want and press Enter.

We also recommend setting up a demo site or testing locally rather than trying these steps on a live site. And finally, one more condition is that the WordPress version of your site is 4.4 or higher. If you are ready, then let's get started!

Step 1: Get to know the basic concepts of the REST API

Before we begin, let's familiarize ourselves with the key concepts of the REST API. There are only five basic concepts and terms that you should become familiar with. Let's look at them:

1. Routes ('Routes') and Resources or access points ('Endpoints'). This is the most important aspect in understanding REST API. Routes help you navigate between your resources when a specific HTTP method (such as a static dataset or action) is connected to a specific route. For example, /wp-json/ is a route configured as a resource created to show us the available routes.
2. Requests. They are created by running the right resources and passing through the data.
3. Answer ( Responses). In short, providing the data you requested or returning an error to let you know something went wrong.
4. Schemas. Below are template answers so you always know exactly where to look for the data you need.
5. Controller classes. They allow you to create your own routes and resources. As long as you don't have to worry about it, they will become more useful later on.

Once you understand these five concepts, you can start diving deeper into the REST API itself, starting with its access points.

Step 2: Find out the most useful REST API access points

The WordPress REST API offers a reference handbook with all the access points (resources) where you can find the ones that are most useful to you. First of all, you need to know how to construct an HTTP REST API call. The basic part of any WordPress API call looks like this, replace yourdomain.com to yours:

Http://yourdomain.com/wp-json/

You can test the connection by running the curl command in your CLI using your own URL:

Curl -X OPTIONS -i http://yourdomain.com/wp-json/

You should be greeted with a message from HTTP. You can further modify this command using some of the main resources. Now we just use the GET version of curl.

To get a JSON list of your posts in WordPress, you can use the following:

Following this, try the following to check all existing WordPress pages:

Curl -X GET -i http://yourdomain.com/wp-json/wp/v2/pages

You can experiment with each of these access points (and more!) in the CLI to see what response each one produces.

Step 3: Learn the Basics of REST API Authentication

Now is the time to learn about authentication. Some actions and data in the REST API are public, while others require you to be logged in as an administrator. However, this is a REST API and there is no place to log in for authorization. Instead, you can authenticate during requests that require admin access, such as viewing unpublished posts or changing posts.

Let's start by installing the WordPress REST API Basic Auth plugin. This is a simple plugin for developers to quickly learn the REST API, and is not intended for real websites. However, the installation process is the same as for any other plugin.

Once Basic Auth is installed, you will be able to authenticate via the CLI with the flag user. Here is an example of how to apply the user authentication method using curl to view unpublished posts:

Curl -X GET --user username:password -i http://yourdomain.com/wp-json/wp/v2/posts?status=draft

Authentication will be required for any operation other than viewing public information. Once you get the hang of basic authentication, you can explore other options recommended by the REST API documentation for your development.

Step 4: Select your first WordPress post using the REST API

Once you understand how to make basic REST API calls with curl, try selecting a specific entry. First, let's display all publications, as we did earlier:

Curl -X GET -i http://yourdomain.com/wp-json/wp/v2/posts

You can use this ID appendix trick for any REST API resource, whether you want to display a post, page, or taxonomy.

Step 5: Making changes to your WordPress post via REST API

Finally, let's try to make changes to the publication you selected. Instead of commands OPTION or GET, this time we will use POST to make changes. GET is used to read data while POST- to send them.

Let's rename your post by submitting a request POST along with authentication data. New changes will be made using the flag d at the end of the command. We will transmit the user's JavaScript object by setting the title variable to its value, such as My New Title as shown in the code below:

Curl -X POST --user username:password http://yourdomain.com/wp-json/wp/v2/posts/ -d "("title":"My New Title")"

Make sure you replace the username, password, post ID, and title with your own. You can select the given publication again to check the changes:

Curl -X GET -i http://yourdomain.com/wp-json/wp/v2/posts/

Congratulations! You've just made your first admin edits using the WordPress REST API. Of course, this basic guide only scratches the surface of the capabilities provided by the REST API, but it's a pretty solid start!

Conclusion

WordPress REST API is a powerful new version of WordPress core and many developers have already started using its capabilities. Accordingly, having now become familiar with how to work with new opportunity, you will improve your programming skills and be able to create an application using WordPress as a framework.

To recap, we went through five steps on our way to learning how to interact with the WordPress REST API:

1. Introduction to basic REST API concepts.
2. Most useful resources/REST API access points.
3. Learn the basics of REST API authentication.
4. Retrieving a post on WordPress using the REST API.
5. Modify a WordPress post using the REST API.

What questions do you have about the WordPress REST API? Write to us in the comments!