Register global WP object.

@return void
343408
public function registerGlobalWP()
    {
        $this->app->singleton('wp', function () {
            global $wp;

            return $wp;
        });

        $this->app->alias('wp', WP::class);
    }
530336
public function register_cron() {
		if ( ! wp_next_scheduled( $this->event ) ) {
			wp_schedule_event( $this->start_at(), $this->schedule, $this->event, $this->args() );
		}
		add_action( $this->event, [ $this, 'process' ] );
	}
652388
protected function registerWordpressAction()
    {
        if (function_exists('add_action')) {
            if (Router::isAjax() || is_admin()) {
                add_action('init', array($this, "onWordpressEarlyInit"));
            } else {
                add_action('wp', array($this, "onWordpressInit"), 10);
            }
        }

        $this->registered = true;
    }
1101015
public function register()
    {
        $this->app['actions']->listen('wp', function () {
            $wpPost = get_post(
                (is_home() && is_archive()) && !is_post_type_archive() ?
                    get_option('page_for_posts') :
                    null
            ); // for post archive get post page instead of first post

            if ($wpPost !== null && $post = Post::resolveWordPressPostToModel($wpPost)) {
                $this->app->instance('post', $post);
            }
        });

        $this->registerLoopAndQuery();
        $this->registerPostManager();
        $this->registerPostTypeManager();
    }
739300
public function init() {
		if ( ! post_type_exists( $this->post_type ) ) {
			$post_type = register_post_type( $this->post_type, $this->args );
			if ( is_wp_error( $post_type ) ) {
				return $post_type;
			}
		}
		if ( '' !== $this->title_placeholder ) {
			add_filter( 'enter_title_here', array( $this, 'update_placeholder' ) );
		}
	}
455301
protected function registerGlobalViewComposers()
    {
        $me = $this;

        $this->app->make('view')->composer('pragmarx/tracker::*', function ($view) use ($me) {
            $view->with('stats_layout', $me->getConfig('stats_layout'));

            $template_path = url('/').$me->getConfig('stats_template_path');

            $view->with('stats_template_path', $template_path);
        });
    }
73987
public function registerEditorPage()
    {
        $this->register(
            $pageTitle = __('Modularity editor'),
            $menuTitle = __('Editor'),
            $capability = 'edit_posts',
            $menuSlug = 'modularity-editor',
            $iconUrl = null,
            $position = 1,
            $parent = 'options.php'
        );
    }
1042978
public function register()
    {
        if ($this->types !== null) {
            return;
        }

        $types = &Objects::getPropertyValue(Type::class, '_typeObjects', Type::class);

        if ($types instanceof self) {
            $this->types = $types->types;
        } else {
            $this->types = [];

            foreach ($types as $name => $type) {
                $this->addType($type);
            }
        }

        $types = $this;
    }
1200160
private function register() {

		$this->options['labels'] = $this->label;
		if (!isset($this->options['rewrite'])) {
			$this->options['rewrite'] = array('slug' => $this->singular);
		}

		$_self = &$this;

		add_action('init', function () use (&$_self) {
			register_taxonomy($_self->singular, $_self->post_types, $this->options);
		});

	}
454315
public function register()
    {
        // adjust network url to reflect proper location
        filters()->listen('network_admin_url', function ($url) {
            return str_replace('/wp-admin', '/cms/wp-admin', $url);
        });

        // adjust site url to reflect proper location
        filters()->listen('wpmu_new_blog', function ($blog_id) {
            $siteUrl = get_blog_option($blog_id, 'siteurl');
            update_blog_option($blog_id, 'siteurl', $siteUrl . '/cms');
        });
    }
206673
protected function registerPlugin()
    {
        if (!isset($this->options['id'])) {
            $this->options['id'] = $this->hasModel() ? Html::getInputId($this->model, $this->attribute) : $this->getId();
        } else {
            $this->setId($this->options['id']);
        }
        
        $clientOptions = [];
        $this->clientOptions = ArrayHelper::merge($clientOptions, $this->clientOptions);
        
        if ($this->hasModel()) {
            $this->querySelector = '#' . $this->options['id'];
        } elseif (empty($this->querySelector)) {
            $this->querySelector = ArrayHelper::remove($this->clientOptions, 'querySelector', '#' . $this->options['id']);
        }
    }
841455
public function register()
    {
        // Store details
        $args = $this->getModel()->getArgs();
        $fields = $this->getModel()->getFields();
        $posttype = $this->getModel()->getPosttype();
        $slug = $this->getModel()->getSlug();

        $is_single = 'single' === $args['choice'] ? true : false;

        // Register post type if not post or page
        if (!in_array($slug, $this->reserved_slugs)) {
            register_taxonomy($slug, $posttype, $args);
        }

        // Works on hook
        $hook = new TermHook($slug, $posttype, $fields, $is_single);
        $this->getModel()->setHook($hook);
    }
977640
public function register()
    {
        $postTypes = get_post_types(array(), 'objects');

        add_settings_section(
            'wp_page_for_post_type',
            __('Page and template for post type archives', 'wp-page-for-post-type'),
            '__return_false',
            'reading'
        );

        $postTypes = array_filter($postTypes, function ($item) {
            return $item->has_archive;
        });

        foreach ($postTypes as $postType) {
            $id = 'page_for_' . $postType->name;

            register_setting('reading', $id, array($this, 'flush'));
            register_setting('reading', 'page_for_' . $postType->name . '_template');
            register_setting('reading', 'page_for_' . $postType->name . '_content');

            add_settings_field(
                $id,
                $postType->label,
                array($this, 'pageDropDown'),
                'reading',
                'wp_page_for_post_type',
                array(
                    'name' => $id,
                    'post_type' => $postType,
                    'value'     => get_option($id)
                )
            );
        }
    }
978879
public function register()
  {
    $middleware = ($this->middleware !== null) ? ['middleware' => $this->middleware] : [];
    $prefix     = ($this->prefix !== null) ? ['prefix' => $this->prefix] : [];
    $domain     = ($this->domain !== null) ? ['domain' => $this->domain] : [];

    Swish::group(array_merge($domain, $middleware, $prefix), function() {
      startphp($this->file);
    });
  }
1361677
function register_taxonomies() {

        if ( is_array( $this->taxonomy_settings ) ) {

            // Foreach taxonomy registered with the post type.
            foreach ( $this->taxonomy_settings as $taxonomy_name => $options ) {

                // Register the taxonomy if it doesn't exist.
                if ( ! taxonomy_exists( $taxonomy_name ) ) {

                    // Register the taxonomy with Wordpress
                    register_taxonomy( $taxonomy_name, $this->post_type_name, $options );

                } else {

                    // If taxonomy exists, register it later with register_exisiting_taxonomies
                    $this->exisiting_taxonomies[] = $taxonomy_name;
                }
            }
        }
    }
167918
public function register()
    {
        wp_register_style(
            $this->handle,
            $this->url,
            $this->dependencies,
            $this->version,
            $this->media
        );
        $this->is_registered = true;
    }
913058
public function register()
    {
        $this->mergeConfigFrom(__DIR__ . '/resources/config/config.php', 'datatables-html');

        $this->app->register(CollectiveHtml::class);

        $this->app->bind('datatables.html', function () {
            return $this->app->make(Html\Builder::class);
        });
    }