Ticket #4955: 4955.01.patch

bp-groups/bp-groups-classes.php

@@ -1367 +1367 @@
  * API for creating group extensions without having to hardcode the content into
  * the theme.
  *
- * This class must be extended for each group extension and the following methods overridden:
+ * To implement, extend this class. In your constructor, pass an optional array
+ * of arguments to parent::init() to configure your widget. The config array
+ * supports the following values:
+ *   - 'slug' A unique identifier for your extension. This value will be used
+ *     to build URLs, so make it URL-safe
+ *   - 'name' A translatable name for your extension. This value is used to
+       populate the navigation tab, as well as the default titles for admin/
+       edit/create tabs.
+ *   - 'visibility' Set to 'public' (default) for your extension (the main tab
+ *     as well as the widget) to be available to anyone who can access the
+ *     group, 'private' otherwise.
+ *   - 'nav_item_position' An integer explaining where the nav item should
+ *     appear in the tab list
+ *   - 'enable_nav_item' Set to true for your extension's main tab to be
+ *     available to anyone who can access the group.
+ *   - 'nav_item_name' The translatable text you want to appear in the nav tab.
+ *     Defaults to the value of 'name'.
+ *   - 'display_hook' The WordPress action that the widget_display() method is
+ *     hooked to
+ *   - 'template_file' The template file that will be used to load the content
+ *     of your main extension tab. Defaults to 'groups/single/plugins.php'.
+ *   - 'screens' A multi-dimensional array, described below
  *
- * BP_Group_Extension::widget_display(), BP_Group_Extension::display(),
- * BP_Group_Extension::edit_screen_save(), BP_Group_Extension::edit_screen(),
- * BP_Group_Extension::create_screen_save(), BP_Group_Extension::create_screen()
+ * BP_Group_Extension uses the concept of "settings screens". There are three
+ * contexts for settings screens:
+ *   - 'create', which inserts a new step into the group creation process
+ *   - 'edit', which adds a tab for your extension into the Admin section of
+ *     a group
+ *   - 'admin', which adds a metabox to the Groups administration panel in the
+ *     WordPress Dashboard
+ * Each of these settings screens is populated by a pair of methods: one that
+ * creates the markup for the screen, and one that processes form data
+ * submitted from the screen. If your plugin needs screens in all three
+ * contexts, and if the markup and form processing logic will be the same in
+ * each case, you can define two methods to handle all of the screens:
+ *   function settings_screen() {}
+ *   function settings_screen_save() {}
+ * If one or more of your settings screen needs separate logic, you may define
+ * context-specific methods, for example:
+ *   function edit_screen() {}
+ *   function edit_screen_save() {}
+ * BP_Group_Extension will use the more specific methods if they are available.
+ *
+ * You can further customize the settings screens (tab names, etc) by passing
+ * an optional 'screens' parameter to the init array. The format is as follows:
+ *   'screens' => array(
+ *       'create' => array(
+ *           'slug' => 'foo',
+ *           'name' => 'Foo',
+ *           'position' => 55,
+ *           'screen_callback' => 'my_create_screen_callback',
+ *           'screen_save_callback' => 'my_create_screen_save_callback',
+ *       ),
+ *       'edit' => array( // ...
+ *   ),
+ * Only provide those arguments that you actually want to change from the
+ * default configuration. BP_Group_Extension will do the rest.
+ *
+ * Note that the 'edit' screen accepts an additional parameter: 'submit_text',
+ * which defines the text of the Submit button automatically added to the Edit
+ * screen of the extension (defaults to 'Save Changes'). Also, the 'admin'
+ * screen accepts two additional parameters: 'metabox_priority' and
+ * 'metabox_context'. See the docs for add_meta_box() for more details on these
+ * arguments.
+ *
+ * Prior to BuddyPress 1.7, group extension configurations were set slightly
+ * differently. The legacy method is still supported, though deprecated.
  *
  * @package BuddyPress
  * @subpackage Groups
  * @since BuddyPress (1.1)
  */
 class BP_Group_Extension {
-        var $name = false;
-        var $slug = false;
 
-        // The name/slug of the Group Admin tab for this extension
-        var $admin_name = '';
-        var $admin_slug = '';
+        /**
+         * @var array Information about this extension's screens
+         * @since BuddyPress (1.8)
+         */
+        var $screens = array();
+
+        /**
+         * @var string The name of the extending class
+         * @since BuddyPress (1.8)
+         */
+        var $class_name;
+
+        /**
+         * @var object A ReflectionClass object of the current extension
+         * @since BuddyPress (1.8)
+         */
+        var $class_reflection;
 
-        // The name/slug of the Group Creation tab for this extension
-        var $create_name = '';
-        var $create_slug = '';
+        /**
+         * @var array Parsed configuration paramaters for the extension
+         * @since BuddyPress (1.8)
+         */
+        var $params = array();
 
-        // Will this extension be visible to non-members of a group? Options: public/private
-        var $visibility = 'public';
+        /**
+         * @var int The id of the current group
+         * @since BuddyPress (1.8)
+         */
+        var $group_id;
 
-        var $create_step_position = 81;
-        var $nav_item_position = 81;
+        /**
+         * @var string The slug of the current extension
+         */
+        var $slug;
 
         /**
-         * @var string Context for the optional admin metabox
-         * @see https://codex.wordpress.org/Function_Reference/add_meta_box for
-         *      possible values
-         * @since BuddyPress (1.7)
+         * @var string The translatable name of the current extension
          */
-        var $admin_metabox_context = 'normal';
+        var $name;
 
         /**
-         * @var string Priority for the optional admin menabox
-         * @see https://codex.wordpress.org/Function_Reference/add_meta_box for
-         *      possible values
-         * @since BuddyPress (1.7)
+         * @var string Whether the extension tab is visible. 'public'
+         *   or 'private'
          */
-        var $admin_metabox_priority = 'core';
+        var $visibility;
 
-        var $enable_create_step = true;
-        var $enable_nav_item = true;
-        var $enable_edit_item = true;
-        var $enable_admin_item = true;
+        /**
+         * @var int The numeric position of the main nav item
+         */
+        var $nav_item_position;
 
-        var $nav_item_name = false;
+        /**
+         * @var bool Whether to show the nav item
+         */
+        var $enable_nav_item;
 
-        var $display_hook = 'groups_custom_group_boxes';
-        var $template_file = 'groups/single/plugins';
+        /**
+         * @var string The text of the nav item. Defaults to self::name
+         */
+        var $nav_item_name;
+
+        /**
+         * @var string The WP action that self::widget_display() is attached
+         *   to. Defaults to 'groups_custom_group_boxes'
+         */
+        var $display_hook;
+
+        /**
+         * @var string The template file used to load the plugin content.
+         *   Defaults to 'groups/single/plugins'
+         */
+        var $template_file;
 
-        // Methods you should override
+        /**
+         * @var bool Has the extension been initialized?
+         * @since BuddyPress (1.8)
+         */
+        protected $initialized = false;
 
-        function display() {}
+        /**
+         * @var array Extension properties as set by legacy extensions
+         * @since BuddyPress (1.8)
+         */
+        protected $legacy_properties = array();
 
-        function widget_display() {}
+        /**
+         * @var array Extension properties as set by legacy extensions, but
+         *   converted to match the new format for params
+         * @since BuddyPress (1.8)
+         */
+        protected $legacy_properties_converted = array();
 
-        function edit_screen( $group_id = null ) {}
+        /**
+         * @var array Miscellaneous data as set by the __set() magic method
+         * @since BuddyPress (1.8)
+         */
+        protected $data = array();
 
-        function edit_screen_save( $group_id = null ) {}
+        /** Screen Overrides **************************************************/
 
-        function create_screen( $group_id = null ) {}
+        /**
+         * Screen override methods are how your extension will display content
+         * and handle form submits. Your extension should only override those
+         * methods that it needs for its purposes.
+         */
 
-        function create_screen_save( $group_id = null ) {}
+        // The content of the group tab
+        public function display() {}
 
-        // Private Methods
+        // Content displayed in a widget sidebar, if applicable
+        public function widget_display() {}
 
-        function _register() {
-                global $bp;
+        // *_screen() displays the settings form for the given context
+        // *_screen_save() processes data submitted via the settings form
+        // The settings_* methods are generic fallbacks, which can optionally
+        // be overridden by the more specific edit_*, create_*, and admin_*
+        // versions.
+        public function settings_screen( $group_id = null ) {}
+        public function settings_screen_save( $group_id = null ) {}
+        public function edit_screen( $group_id = null ) {}
+        public function edit_screen_save( $group_id = null ) {}
+        public function create_screen( $group_id = null ) {}
+        public function create_screen_save( $group_id = null ) {}
+        public function admin_screen( $group_id = null ) {}
+        public function admin_screen_save( $group_id = null ) {}
 
-                // If admin/create names and slugs are not provided, they fall back on the main
-                // name and slug for the extension
-                if ( ! $this->admin_name ) {
-                        $this->admin_name = $this->name;
+        /** Setup *************************************************************/
+
+        /**
+         * Initialize the extension, using your config settings
+         *
+         * Your plugin should call this method at the very end of its
+         * constructor, like so:
+         *
+         *   public function __construct() {
+         *       $args = array(
+         *           'slug' => 'my-group-extension',
+         *           'name' => 'My Group Extension',
+         *           // ...
+         *       );
+         *
+         *       parent::init( $args );
+         *   }
+         *
+         * @since BuddyPress (1.8)
+         * @param array $args See inline definition below for arguments
+         */
+        public function init( $args = array() ) {
+
+                // Before this init() method was introduced, plugins were
+                // encouraged to set their config directly. For backward
+                // compatibility with these plugins, we detect whether this is
+                // one of those legacy plugins, and parse any legacy arguments
+                // with those passed to init()
+                $this->parse_legacy_properties();
+                $args = $this->parse_args_r( $args, $this->legacy_properties_converted );
+
+                // Parse with defaults
+                $this->params = $this->parse_args_r( $args, array(
+                        'slug'                   => '',
+                        'name'                   => '',
+                        'visibility'             => 'public',
+                        'nav_item_position'      => 81,
+                        'enable_nav_item'        => true,
+                        'nav_item_name'          => false,
+                        'display_hook'           => 'groups_custom_group_boxes',
+                        'template_file'          => 'groups/single/plugins',
+                        'screens'                => $this->get_default_screens(),
+                ) );
+
+                $this->initialized = true;
+        }
+
+        /**
+         * The main setup routine for the extension
+         *
+         * This method contains the primary logic for setting up an extension's
+         * configuration, setting up backward compatibility for legacy plugins,
+         * and hooking the extension's screen functions into WP and BP.
+         *
+         * Marked 'public' because it must be accessible to add_action().
+         * However, you should never need to invoke this method yourself - it
+         * is called automatically at the right point in the load order by
+         * bp_register_group_extension().
+         *
+         * @since BuddyPress (1.1)
+         */
+        public function _register() {
+                // Detect and parse properties set by legacy extensions
+                $this->parse_legacy_properties();
+
+                // Initialize, if necessary. This should only happen for
+                // legacy extensions that don't call parent::init() themselves
+                if ( ! $this->initialized ) {
+                        $this->init();
                 }
 
-                if ( ! $this->admin_slug ) {
-                        $this->admin_slug = $this->slug;
+                // Set some config values, based on the parsed params
+                $this->group_id          = $this->get_group_id();
+                $this->slug              = $this->params['slug'];
+                $this->name              = $this->params['name'];
+                $this->visibility        = $this->params['visibility'];
+                $this->nav_item_position = $this->params['nav_item_position'];
+                $this->nav_item_name     = $this->params['nav_item_name'];
+                $this->display_hook      = $this->params['display_hook'];
+                $this->template_file     = $this->params['template_file'];
+
+                // Configure 'screens': create, admin, and edit contexts
+                $this->setup_screens();
+
+                // Mirror configuration data so it's accessible to plugins
+                // that look for it in its old locations
+                $this->setup_legacy_properties();
+
+                // Hook the extension into BuddyPress
+                $this->setup_display_hooks();
+                $this->setup_create_hooks();
+                $this->setup_edit_hooks();
+                $this->setup_admin_hooks();
+        }
+
+        /**
+         * Set up some basic info about the Extension
+         *
+         * Here we collect the name of the extending class, as well as a
+         * ReflectionClass that is used in get_screen_callback() to determine
+         * whether your extension overrides certain callback methods.
+         *
+         * @since BuddyPress (1.8)
+         */
+        protected function setup_class_info() {
+                if ( is_null( $this->class_name ) ) {
+                        $this->class_name = get_class( $this );
                 }
 
-                if ( ! $this->create_name ) {
-                        $this->create_name = $this->name;
+                if ( is_null( $this->class_reflection ) ) {
+                        $this->class_reflection = new ReflectionClass( $this->class_name );
                 }
+        }
 
-                if ( ! $this->create_slug ) {
-                        $this->create_slug = $this->slug;
+        /**
+         * Get the current group id
+         *
+         * Check for:
+         *   - current group
+         *   - new group
+         *   - group admin
+         *
+         * @since BuddyPress (1.8)
+         */
+        public static function get_group_id() {
+                // Usually this will work
+                $group_id = bp_get_current_group_id();
+
+                // On the admin, get the group id out of the $_GET params
+                if ( ! $group_id && is_admin() && isset( $_GET['page'] ) && 'bp-groups' === $_GET['page'] && ! empty( $_GET['gid'] ) ) {
+                        $group_id = (int) $_GET['gid'];
                 }
 
-                if ( ! empty( $this->enable_create_step ) ) {
-                        // Insert the group creation step for the new group extension
-                        $bp->groups->group_creation_steps[ $this->create_slug ] = array(
-                                'name'     => $this->create_name,
-                                'slug'     => $this->create_slug,
-                                'position' => $this->create_step_position,
-                        );
+                // This fallback will only be hit when the create step is
+                // very early
+                if ( ! $group_id && bp_get_new_group_id() ) {
+                        $group_id = bp_get_new_group_id();
+                }
 
-                        // The maybe_ methods check to see whether the create_*
-                        // callbacks should be invoked (ie, are we on the
-                        // correct group creation step). Hooked in separate
-                        // methods because current creation step info not yet
-                        // available at this point
-                        add_action( 'groups_custom_create_steps', array( $this, 'maybe_create_screen' ) );
-                        add_action( 'groups_create_group_step_save_' . $this->create_slug, array( $this, 'maybe_create_screen_save' ) );
-                }
-
-                // When we are viewing a single group, add the group extension nav item
-                if ( bp_is_group() ) {
-                        if ( $this->visibility == 'public' || ( $this->visibility != 'public' && $bp->groups->current_group->user_has_access ) ) {
-                                if ( $this->enable_nav_item ) {
-                                        bp_core_new_subnav_item( array(
-                                                'name' => !$this->nav_item_name ? $this->name : $this->nav_item_name,
-                                                'slug' => $this->slug,
-                                                'parent_slug' => $bp->groups->current_group->slug,
-                                                'parent_url' => bp_get_group_permalink( $bp->groups->current_group ),
-                                                'position' => $this->nav_item_position,
-                                                'item_css_id' => 'nav-' . $this->slug,
-                                                'screen_function' => array( &$this, '_display_hook' ),
-                                                'user_has_access' => $this->enable_nav_item
-                                        ) );
-
-                                        // When we are viewing the extension display page, set the title and options title
-                                        if ( bp_is_current_action( $this->slug ) ) {
-                                                add_action( 'bp_template_content_header', create_function( '', 'echo "' . esc_attr( $this->name ) . '";' ) );
-                                                add_action( 'bp_template_title', create_function( '', 'echo "' . esc_attr( $this->name ) . '";' ) );
-                                        }
-                                }
+                // On some setups, the group id has to be fetched out of the
+                // $_POST array
+                // @todo Figure out why this is happening during group creation
+                if ( ! $group_id && isset( $_POST['group_id'] ) ) {
+                        $group_id = (int) $_POST['group_id'];
+                }
 
-                                // Hook the group home widget
-                                if ( ! bp_current_action() && bp_is_current_action( 'home' ) ) {
-                                        add_action( $this->display_hook, array( &$this, 'widget_display' ) );
-                                }
+                return $group_id;
+        }
+
+        /**
+         * Gather configuration data about your screens
+         *
+         * @since BuddyPress (1.8)
+         */
+        protected function get_default_screens() {
+                $this->setup_class_info();
+
+                $screens = array(
+                        'create' => array(),
+                        'edit'   => array(),
+                        'admin'  => array(
+                                'metabox_context'  => 'normal',
+                                'metabox_priority' => 'core',
+                        ),
+                );
+
+                foreach ( $screens as $context => &$screen ) {
+                        $screen['enabled'] = true;
+
+                        $screen['screen_callback']      = $this->get_screen_callback( $context, 'screen' );
+                        $screen['screen_save_callback'] = $this->get_screen_callback( $context, 'screen_save' );
+
+                        $screen['name']        = '';
+                        $screen['slug']        = '';
+                        $screen['position']    = 81;
+                        $screen['submit_text'] = __( 'Save Changes', 'buddypress' );
+                }
+
+                return $screens;
+        }
+
+        /**
+         * Set up screens array based on params
+         *
+         * @since BuddyPress (1.8)
+         */
+        protected function setup_screens() {
+                foreach ( (array) $this->params['screens'] as $context => $screen ) {
+                        if ( empty( $screen['slug'] ) ) {
+                                $screen['slug'] = $this->slug;
+                        }
+
+                        if ( empty( $screen['name'] ) ) {
+                                $screen['name'] = $this->name;
                         }
+
+                        $this->screens[ $context ] = $screen;
                 }
+        }
 
-                // Construct the admin edit tab for the new group extension
-                if ( ! empty( $this->enable_edit_item ) && bp_is_item_admin() ) {
-                        add_action( 'groups_admin_tabs', create_function( '$current, $group_slug',
-                                '$selected = "";
-                                if ( "' . esc_attr( $this->admin_slug ) . '" == $current )
-                                        $selected = " class=\"current\"";
-                                echo "<li{$selected}><a href=\"' . trailingslashit( bp_get_root_domain() . '/' . bp_get_groups_root_slug() . '/{$group_slug}/admin/' . esc_attr( $this->admin_slug ) ) . '\">' . esc_attr( $this->admin_name ) . '</a></li>";'
-                        ), 10, 2 );
+        /** Display *************************************************************/
 
-                        // Catch the edit screen and forward it to the plugin template
-                        if ( bp_is_groups_component() && bp_is_current_action( 'admin' ) && bp_is_action_variable( $this->admin_slug, 0 ) ) {
-                                $this->edit_screen_save( bp_get_current_group_id() );
+        /**
+         * Hook this extension's group tab into BuddyPress, if necessary
+         *
+         * @since BuddyPress (1.8)
+         */
+        protected function setup_display_hooks() {
+                if ( ! bp_is_group() ) {
+                        return;
+                }
+
+                if ( 'public' != $this->visibility && ! buddypress()->groups->current_group->user_has_access ) {
+                        false;
+                }
+
+                if ( $this->enable_nav_item ) {
+                        bp_core_new_subnav_item( array(
+                                'name'            => ! $this->nav_item_name ? $this->name : $this->nav_item_name,
+                                'slug'            => $this->slug,
+                                'parent_slug'     => bp_get_current_group_slug(),
+                                'parent_url'      => bp_get_group_permalink( groups_get_current_group() ),
+                                'position'        => $this->nav_item_position,
+                                'item_css_id'     => 'nav-' . $this->slug,
+                                'screen_function' => array( &$this, '_display_hook' ),
+                                'user_has_access' => $this->enable_nav_item
+                        ) );
+
+                        // When we are viewing the extension display page, set the title and options title
+                        if ( bp_is_current_action( $this->slug ) ) {
+                                add_action( 'bp_template_content_header', create_function( '', 'echo "' . esc_attr( $this->name ) . '";' ) );
+                                add_action( 'bp_template_title', create_function( '', 'echo "' . esc_attr( $this->name ) . '";' ) );
+                        }
+                }
 
-                                add_action( 'groups_custom_edit_steps', array( &$this, 'call_edit_screen' ) );
+                // Hook the group home widget
+                if ( ! bp_current_action() && bp_is_current_action( 'home' ) ) {
+                        add_action( $this->display_hook, array( &$this, 'widget_display' ) );
+                }
+        }
 
-                                if ( '' != bp_locate_template( array( 'groups/single/home.php' ), false ) ) {
-                                        bp_core_load_template( apply_filters( 'groups_template_group_home', 'groups/single/home' ) );
-                                } else {
-                                        add_action( 'bp_template_content_header', create_function( '', 'echo "<ul class=\"content-header-nav\">"; bp_group_admin_tabs(); echo "</ul>";' ) );
-                                        add_action( 'bp_template_content', array( &$this, 'call_edit_screen' ) );
-                                        bp_core_load_template( apply_filters( 'bp_core_template_plugin', '/groups/single/plugins' ) );
-                                }
+        /**
+         * Hooks the main display method, and loads the template file
+         */
+        public function _display_hook() {
+                add_action( 'bp_template_content', array( &$this, 'display' ) );
+                bp_core_load_template( apply_filters( 'bp_core_template_plugin', $this->template_file ) );
+        }
+
+        /** Create *************************************************************/
+
+        /**
+         * Hook this extension's Create step into BuddyPress, if necessary
+         *
+         * @since BuddyPress (1.8)
+         */
+        protected function setup_create_hooks() {
+                if ( ! $this->is_screen_enabled( 'create' ) ) {
+                        return;
+                }
+
+                $screen = $this->screens['create'];
+
+                // Insert the group creation step for the new group extension
+                buddypress()->groups->group_creation_steps[ $screen['slug'] ] = array(
+                        'name'     => $screen['name'],
+                        'slug'     => $screen['slug'],
+                        'position' => $screen['position'],
+                );
+
+                // The maybe_ methods check to see whether the create_*
+                // callbacks should be invoked (ie, are we on the
+                // correct group creation step). Hooked in separate
+                // methods because current creation step info not yet
+                // available at this point
+                add_action( 'groups_custom_create_steps', array( $this, 'maybe_create_screen' ) );
+                add_action( 'groups_create_group_step_save_' . $screen['slug'], array( $this, 'maybe_create_screen_save' ) );
+        }
+
+        /**
+         * Call the create_screen() method, if we're on the right page
+         *
+         * @since 1.8
+         */
+        public function maybe_create_screen() {
+                if ( bp_is_group_creation_step( $this->screens['create']['slug'] ) ) {
+                        call_user_func( $this->screens['create']['screen_callback'], $this->group_id );
+                        $this->nonce_field( 'create' );
+
+                        // The create screen requires an additional nonce field
+                        // due to a quirk in the way the templates are built
+                        wp_nonce_field( 'groups_create_save_' . bp_get_groups_current_create_step() );
+                }
+        }
+
+        /**
+         * Call the create_screen_save() method, if we're on the right page
+         *
+         * @since 1.8
+         */
+        public function maybe_create_screen_save() {
+                if ( bp_is_group_creation_step( $this->screens['create']['slug'] ) ) {
+                        $this->check_nonce( 'create' );
+                        call_user_func( $this->screens['create']['screen_save_callback'], $this->group_id );
+                }
+        }
+
+        /** Edit *************************************************************/
+
+        /**
+         * Hook this extension's Edit panel into BuddyPress, if necessary
+         *
+         * @since BuddyPress (1.8)
+         */
+        protected function setup_edit_hooks() {
+                if ( ! $this->is_screen_enabled( 'edit' ) || ! bp_is_item_admin() ) {
+                        return;
+                }
+
+                $screen = $this->screens['edit'];
+
+                // Add the tab
+                // @todo BP should be using bp_core_new_subnav_item()
+                add_action( 'groups_admin_tabs', create_function( '$current, $group_slug',
+                        '$selected = "";
+                        if ( "' . esc_attr( $screen['slug'] ) . '" == $current )
+                                $selected = " class=\"current\"";
+                        echo "<li{$selected}><a href=\"' . trailingslashit( bp_get_root_domain() . '/' . bp_get_groups_root_slug() . '/{$group_slug}/admin/' . esc_attr( $screen['slug'] ) ) . '\">' . esc_attr( $screen['name'] ) . '</a></li>";'
+                ), 10, 2 );
+
+                // Catch the edit screen and forward it to the plugin template
+                if ( bp_is_groups_component() && bp_is_current_action( 'admin' ) && bp_is_action_variable( $screen['slug'], 0 ) ) {
+                        $this->call_edit_screen_save( $this->group_id );
+
+                        add_action( 'groups_custom_edit_steps', array( &$this, 'call_edit_screen' ) );
+
+                        if ( '' != bp_locate_template( array( 'groups/single/home.php' ), false ) ) {
+                                bp_core_load_template( apply_filters( 'groups_template_group_home', 'groups/single/home' ) );
+                        } else {
+                                add_action( 'bp_template_content_header', create_function( '', 'echo "<ul class=\"content-header-nav\">"; bp_group_admin_tabs(); echo "</ul>";' ) );
+                                add_action( 'bp_template_content', array( &$this, 'call_edit_screen' ) );
+                                bp_core_load_template( apply_filters( 'bp_core_template_plugin', '/groups/single/plugins' ) );
                         }
                 }
+        }
+
+        /**
+         * Call the edit_screen() method
+         *
+         * Previous versions of BP_Group_Extension required plugins to provide
+         * their own Submit button and nonce fields when building markup. In
+         * BP 1.8, this requirement was lifted - BP_Group_Extension now handles
+         * all required submit buttons and nonces.
+         *
+         * We put the edit screen markup into an output buffer before echoing.
+         * This is so that we can check for the presence of a hardcoded submit
+         * button, as would be present in legacy plugins; if one is found, we
+         * do not auto-add our own button.
+         *
+         * @since BuddyPress (1.8)
+         */
+        public function call_edit_screen() {
+                ob_start();
+                call_user_func( $this->screens['edit']['screen_callback'], $this->group_id );
+                $screen = ob_get_contents();
+                ob_end_clean();
+
+                echo $this->maybe_add_submit_button( $screen );
+
+                $this->nonce_field( 'edit' );
+        }
+
+        /**
+         * Check the nonce, and call the edit_screen_save() method
+         *
+         * @since BuddyPress (1.8)
+         */
+        public function call_edit_screen_save() {
+                if ( ! empty( $_POST ) ) {
+                        $this->check_nonce( 'edit' );
+                        call_user_func( $this->screens['edit']['screen_save_callback'], $this->group_id );
+                }
+        }
+
+        /**
+         * Add a submit button to the edit form, if it needs one
+         *
+         * There's an inconsistency in the way that the group Edit and Create
+         * screens are rendered: the Create screen has a submit button built
+         * in, but the Edit screen does not. This function allows plugin
+         * authors to write markup that does not contain the submit button for
+         * use on both the Create and Edit screens - BP will provide the button
+         * if one is not found.
+         *
+         * @since BuddyPress (1.8)
+         * @param string $screen The screen markup, captured in the output buffer
+         * @param string $screen The same markup, with a submit button added
+         */
+        protected function maybe_add_submit_button( $screen ) {
+                if ( ! $this->has_submit_button( $screen ) ) {
+                        $screen .= sprintf(
+                                '<div id="%s"><input type="submit" name="save" value="%s" id="%s"></div>',
+                                'bp-group-edit-' . $this->slug . '-submit-wrapper',
+                                $this->screens['edit']['submit_text'],
+                                'bp-group-edit-' . $this->slug . '-submit'
+                        );
+                }
+
+                return $screen;
+        }
+
+        /**
+         * Does the given markup have a submit button?
+         *
+         * @since BuddyPress (1.8)
+         * @param $screen The markup to check
+         * @return bool
+         */
+        public static function has_submit_button( $screen ) {
+                $pattern = "/<input[^>]+type=[\'\"]submit[\'\"]/";
+                preg_match( $pattern, $screen, $matches );
+                return ! empty( $matches[0] );
+        }
+
+        /** Admin *************************************************************/
 
-                // Construct the admin metabox
-                // Plugin authors: Note that $this->enable_admin_item must be
-                // set to true, and self::admin_screen() must be defined
-                if ( ! empty( $this->enable_admin_item ) && is_admin() && method_exists( get_class( $this ), 'admin_screen' ) ) {
+        /**
+         * Hook this extension's Admin metabox into BuddyPress, if necessary
+         *
+         * @since BuddyPress (1.8)
+         */
+        protected function setup_admin_hooks() {
+                if ( $this->is_screen_enabled( 'admin' ) && is_admin() ) {
                         // Hook the admin screen markup function to the content hook
-                        add_action( 'bp_groups_admin_meta_box_content_' . $this->slug, array( $this, 'admin_screen' ) );
+                        add_action( 'bp_groups_admin_meta_box_content_' . $this->slug, array( $this, 'call_admin_screen' ) );
 
                         // Initialize the metabox
                         add_action( 'bp_groups_admin_meta_boxes', array( $this, '_meta_box_display_callback' ) );
 
                         // Catch the metabox save
-                        if ( method_exists( get_class( $this ), 'admin_screen_save' ) ) {
-                                add_action( 'bp_group_admin_edit_after', array( $this, 'admin_screen_save' ), 10 );
-                        }
+                        add_action( 'bp_group_admin_edit_after', array( $this, 'call_admin_screen_save' ), 10 );
                 }
         }
 
-        function _display_hook() {
-                add_action( 'bp_template_content', array( &$this, 'display' ) );
-                bp_core_load_template( apply_filters( 'bp_core_template_plugin', $this->template_file ) );
+        /**
+         * Call the admin_screen() method, and add a nonce field
+         *
+         * @since BuddyPress (1.8)
+         */
+        public function call_admin_screen( $group_id = null ) {
+                call_user_func( $this->screens['admin']['screen_callback'], $this->group_id );
+                $this->nonce_field( 'admin' );
+        }
+
+        /**
+         * Check the nonce, and call the admin_screen_save() method
+         *
+         * @since BuddyPress (1.8)
+         */
+        public function call_admin_screen_save( $group_id = null ) {
+                $this->check_nonce( 'admin' );
+                call_user_func( $this->screens['admin']['screen_save_callback'], $this->group_id );
         }
 
         /**
@@ -1556 +2036 @@
          *
          * @since BuddyPress (1.7)
          */
-        function _meta_box_display_callback() {
+        public function _meta_box_display_callback() {
                 $group_id = isset( $_GET['gid'] ) ? (int) $_GET['gid'] : 0;
 
+                $screen = $this->screens['admin'];
+
                 add_meta_box(
-                        $this->slug,
-                        $this->name,
+                        $screen['slug'],
+                        $screen['name'],
                         create_function( '', 'do_action( "bp_groups_admin_meta_box_content_' . $this->slug . '", ' . $group_id . ' );' ),
                         get_current_screen()->id,
-                        $this->admin_metabox_context,
-                        $this->admin_metabox_priority
+                        $screen['metabox_context'],
+                        $screen['metabox_priority']
                 );
         }
 
+
+        /** Utilities *********************************************************/
+
         /**
-         * Call the edit_screen() method
+         * Generate the nonce fields for a settings form
          *
-         * Broken into a standalone method so we can pass the current group id
-         * to edit_screen()
+         * The nonce field name (the second param passed to wp_nonce_field)
+         * contains this extension's slug and is thus unique to this extension.
+         * This is necessary because in some cases (namely, the Dashboard),
+         * more than one extension may generate nonces on the same page, and we
+         * must avoid name clashes.
          *
-         * @since 1.8
+         * @since BuddyPress (1.8)
+         * @uses wp_nonce_field()
+         * @param string $context 'create', 'edit', 'admin'
          */
-        public function call_edit_screen() {
-                $this->edit_screen( bp_get_current_group_id() );
+        public function nonce_field( $context = '' ) {
+                wp_nonce_field( 'bp_group_extension_' . $this->slug . '_' . $context, '_bp_group_' . $context . '_nonce_' . $this->slug );
         }
 
         /**
-         * Call the create_screen() method, if we're on the right page
+         * Check the nonce on a submitted settings form
          *
-         * @since 1.8
+         * @since BuddyPress (1.8)
+         * @uses check_admin_referer()
+         * @param string $context 'create', 'edit', 'admin'
          */
-        public function maybe_create_screen() {
-                if ( bp_is_group_creation_step( $this->slug ) ) {
-                        $this->create_screen( bp_get_new_group_id() );
+        public function check_nonce( $context = '' ) {
+                check_admin_referer( 'bp_group_extension_' . $this->slug . '_' . $context, '_bp_group_' . $context . '_nonce_' . $this->slug );
+        }
+
+        /**
+         * Is the specified screen enabled?
+         *
+         * To be enabled, a screen must both have the 'enabled' key set to true
+         * (legacy: $this->enable_create_step, etc), and its screen_callback
+         * must also exist and be callable.
+         *
+         * @since BuddyPress (1.8)
+         * @param string $context 'create', 'edit', 'admin'
+         * @return bool
+         */
+        public function is_screen_enabled( $context = '' ) {
+                $enabled = false;
+
+                if ( isset( $this->screens[ $context ] ) ) {
+                        $enabled = $this->screens[ $context ]['enabled'] && is_callable( $this->screens[ $context ]['screen_callback'] );
                 }
+
+                return $enabled;
         }
 
         /**
-         * Call the create_screen_save() method, if we're on the right page
+         * Get the appropriate screen callback for the specified context/type
          *
-         * @since 1.8
+         * BP Group Extensions have three special "screen contexts": create,
+         * admin, and edit. Each of these contexts has a corresponding
+         * _screen() and _screen_save() method, which allow group extension
+         * plugins to define different markup and logic for each context.
+         *
+         * BP also supports fallback settings_screen() and
+         * settings_screen_save() methods, which can be used to define markup
+         * and logic that is shared between context. For each context, you may
+         * either provide context-specific methods, or you can let BP fall back
+         * on the shared settings_* callbacks.
+         *
+         * For example, consider a BP_Group_Extension implementation that looks
+         * like this:
+         *
+         *   // ...
+         *   function create_screen( $group_id ) { ... }
+         *   function create_screen_save( $group_id ) { ... }
+         *   function settings_screen( $group_id ) { ... }
+         *   function settings_screen_save( $group_id ) { ... }
+         *   // ...
+         *
+         * BP_Group_Extension will use your create_* methods for the Create
+         * steps, and will use your generic settings_* methods for the Edit
+         * and Admin contexts. This schema allows plugin authors maximum
+         * flexibility without having to repeat themselves.
+         *
+         * The get_screen_callback() method uses a ReflectionClass object to
+         * determine whether your extension has provided a given callback.
+         *
+         * @since BuddyPress (1.8)
+         * @param string $context 'create', 'edit', 'admin'
+         * @param string $type 'screen', 'screen_save'
+         * @return mixed A callable function handle
          */
-        public function maybe_create_screen_save() {
-                if ( bp_is_group_creation_step( $this->slug ) ) {
-                        $this->create_screen_save( bp_get_new_group_id() );
+        public function get_screen_callback( $context = '', $type = 'screen' ) {
+                $callback = '';
+
+                // Try the context-specific callback first
+                $method  = $context . '_' . $type;
+                $rmethod = $this->class_reflection->getMethod( $method );
+                if ( isset( $rmethod->class ) && $this->class_name === $rmethod->class ) {
+                        $callback = array( $this->class_name, $method );
+                }
+
+                if ( ! $callback ) {
+                        $fallback_method  = 'settings_' . $type;
+                        $rfallback_method = $this->class_reflection->getMethod( $fallback_method );
+                        if ( isset( $rfallback_method->class ) && $this->class_name === $rfallback_method->class ) {
+                                $callback = array( $this->class_name, $fallback_method );
+                        }
+                }
+
+                return $callback;
+        }
+
+        /**
+         * Recursive argument parsing
+         *
+         * This acts like a multi-dimensional version of wp_parse_args() (minus
+         * the querystring parsing - you must pass arrays).
+         *
+         * Values from $a override those from $b; keys in $b that don't exist
+         * in $a are passed through.
+         *
+         * This is different from array_merge_recursive(), both because of the
+         * order of preference ($a overrides $b) and because of the fact that
+         * array_merge_recursive() combines arrays deep in the tree, rather
+         * than overwriting the b array with the a array.
+         *
+         * The implementation of this function is specific to the needs of
+         * BP_Group_Extension, where we know that arrays will always be
+         * associative, and that an argument under a given key in one array
+         * will be matched by a value of identical depth in the other one. The
+         * function is NOT designed for general use, and will probably result
+         * in unexpected results when used with data in the wild. See, eg,
+         * http://core.trac.wordpress.org/ticket/19888
+         *
+         * @since BuddyPress (1.8)
+         * @arg array $a
+         * @arg array $b
+         * @return array
+         */
+        public static function parse_args_r( &$a, $b ) {
+                $a = (array) $a;
+                $b = (array) $b;
+                $r = $b;
+
+                foreach ( $a as $k => &$v ) {
+                        if ( is_array( $v ) && isset( $r[ $k ] ) ) {
+                                $r[ $k ] = self::parse_args_r( $v, $r[ $k ] );
+                        } else {
+                                $r[ $k ] = $v;
+                        }
+                }
+
+                return $r;
+        }
+
+        /** Legacy Support ****************************************************/
+
+        /**
+         * In BuddyPress 1.8, the recommended technique for configuring
+         * extensions changed from directly setting various object properties
+         * in the class constructor, to passing a configuration array to
+         * parent::init(). The following methods ensure that extensions created
+         * in the old way continue to work, by converting legacy configuration
+         * data to the new format.
+         */
+
+        /**
+         * Provide access to otherwise unavailable object properties
+         *
+         * This magic method is here for backward compatibility with plugins
+         * that refer to config properties that have moved to a different
+         * location (such as enable_create_step, which is now at
+         * $this->screens['create']['enabled']
+         *
+         * The legacy_properties array is set up in
+         * self::setup_legacy_properties().
+         *
+         * @since BuddyPress (1.8)
+         * @param string $key
+         * @return mixed
+         */
+        public function __get( $key ) {
+                if ( isset( $this->legacy_properties[ $key ] ) ) {
+                        return $this->legacy_properties[ $key ];
+                } else if ( isset( $this->data[ $key ] ) ) {
+                        return $this->data[ $key ];
+                } else {
+                        return null;
+                }
+        }
+
+        /**
+         * Allow plugins to set otherwise unavailable object properties
+         *
+         * This magic method is here for backward compatibility with plugins
+         * that may attempt to modify the group extension by manually assigning
+         * a value to an object property that no longer exists, such as
+         * $this->enable_create_step.
+         *
+         * @since BuddyPress (1.8)
+         * @param string $key
+         * @param mixed $value
+         */
+        public function __set( $key, $value ) {
+
+                if ( ! $this->is_initialized ) {
+                        $this->data[ $key ] = $value;
+                }
+
+                switch ( $key ) {
+                        case 'enable_create_step' :
+                                $this->screens['create']['enabled'] = $value;
+                                break;
+
+                        case 'enable_edit_item' :
+                                $this->screens['edit']['enabled'] = $value;
+                                break;
+
+                        case 'enable_admin_item' :
+                                $this->screens['admin']['enabled'] = $value;
+                                break;
+
+                        case 'create_step_position' :
+                                $this->screens['create']['position'] = $value;
+                                break;
+
+                        // Note: 'admin' becomes 'edit' to distinguish from Dashboard 'admin'
+                        case 'admin_name' :
+                                $this->screens['edit']['name'] = $value;
+                                break;
+
+                        case 'admin_slug' :
+                                $this->screens['edit']['slug'] = $value;
+                                break;
+
+                        case 'create_name' :
+                                $this->screens['create']['name'] = $value;
+                                break;
+
+                        case 'create_slug' :
+                                $this->screens['create']['slug'] = $value;
+                                break;
+
+                        case 'admin_metabox_context' :
+                                $this->screens['admin']['metabox_context'] = $value;
+                                break;
+
+                        case 'admin_metabox_priority' :
+                                $this->screens['admin']['metabox_priority'] = $value;
+                                break;
+
+                        default :
+                                $this->data[ $key ] = $value;
+                                break;
                 }
         }
 
+        /**
+         * Returns a list of legacy properties
+         *
+         * The legacy implementation of BP_Group_Extension used all of these
+         * object properties for configuration. Some have been moved.
+         *
+         * @since BuddyPress (1.8)
+         * @return array
+         */
+        protected function get_legacy_property_list() {
+                return array(
+                        'name',
+                        'slug',
+                        'admin_name',
+                        'admin_slug',
+                        'create_name',
+                        'create_slug',
+                        'visibility',
+                        'create_step_position',
+                        'nav_item_position',
+                        'admin_metabox_context',
+                        'admin_metabox_priority',
+                        'enable_create_step',
+                        'enable_nav_item',
+                        'enable_edit_item',
+                        'enable_admin_item',
+                        'nav_item_name',
+                        'display_hook',
+                        'template_file',
+                );
+        }
+
+        /**
+         * Parse legacy properties
+         *
+         * The old standard for BP_Group_Extension was for plugins to register
+         * their settings as properties in their constructor. The new method is
+         * to pass a config array to the init() method. In order to support
+         * legacy plugins, we slurp up legacy properties, and later on we'll
+         * parse them into the new init() array.
+         *
+         * @since BuddyPress (1.8)
+         */
+        protected function parse_legacy_properties() {
+
+                // Only run this one time
+                if ( empty( $this->legacy_properties_converted ) ) {
+                        $properties = $this->get_legacy_property_list();
+
+                        // By-reference variable for convenience
+                        $lpc =& $this->legacy_properties_converted;
+
+                        foreach ( $properties as $property ) {
+                                // No legacy config exists for this key
+                                if ( ! isset( $this->{$property} ) ) {
+                                        continue;
+                                }
+
+                                // Grab the value and record it as appropriate
+                                $value = $this->{$property};
+
+                                switch ( $property ) {
+                                        case 'enable_create_step' :
+                                                $lpc['screens']['create']['enabled'] = (bool) $value;
+                                                break;
+
+                                        case 'enable_edit_item' :
+                                                $lpc['screens']['edit']['enabled'] = (bool) $value;
+                                                break;
+
+                                        case 'enable_admin_item' :
+                                                $lpc['screens']['admin']['enabled'] = (bool) $value;
+                                                break;
+
+                                        case 'create_step_position' :
+                                                $lpc['screens']['create']['position'] = $value;
+                                                break;
+
+                                        // Note: 'admin' becomes 'edit' to distinguish from Dashboard 'admin'
+                                        case 'admin_name' :
+                                                $lpc['screens']['edit']['name'] = $value;
+                                                break;
+
+                                        case 'admin_slug' :
+                                                $lpc['screens']['edit']['slug'] = $value;
+                                                break;
+
+                                        case 'create_name' :
+                                                $lpc['screens']['create']['name'] = $value;
+                                                break;
+
+                                        case 'create_slug' :
+                                                $lpc['screens']['create']['slug'] = $value;
+                                                break;
+
+                                        case 'admin_metabox_context' :
+                                                $lpc['screens']['admin']['metabox_context'] = $value;
+                                                break;
+
+                                        case 'admin_metabox_priority' :
+                                                $lpc['screens']['admin']['metabox_priority'] = $value;
+                                                break;
+
+                                        default :
+                                                $lpc[ $property ] = $value;
+                                                break;
+                                }
+                        }
+                }
+        }
+
+        /**
+         * Set up legacy properties
+         *
+         * This method is responsible for ensuring that all legacy config
+         * properties are stored in an array $this->legacy_properties, so that
+         * they remain available to plugins that reference the variables at
+         * their old locations.
+         *
+         * @see self::__get()
+         *
+         * @since BuddyPress (1.8)
+         */
+        protected function setup_legacy_properties() {
+
+                // Only run this one time
+                if ( empty( $this->legacy_properties ) ) {
+                        $properties = $this->get_legacy_property_list();
+                        $params     = $this->params;
+                        $lp         =& $this->legacy_properties;
+
+                        foreach ( $properties as $property ) {
+                                switch ( $property ) {
+                                        case 'enable_create_step' :
+                                                $lp['enable_create_step'] = $params['screens']['create']['enabled'];
+                                                break;
+
+                                        case 'enable_edit_item' :
+                                                $lp['enable_edit_item'] = $params['screens']['edit']['enabled'];
+                                                break;
+
+                                        case 'enable_admin_item' :
+                                                $lp['enable_admin_item'] = $params['screens']['admin']['enabled'];
+                                                break;
+
+                                        case 'create_step_position' :
+                                                $lp['create_step_position'] = $params['screens']['create']['position'];
+                                                break;
+
+                                        // Note: 'admin' becomes 'edit' to distinguish from Dashboard 'admin'
+                                        case 'admin_name' :
+                                                $lp['admin_name'] = $params['screens']['edit']['name'];
+                                                break;
+
+                                        case 'admin_slug' :
+                                                $lp['admin_slug'] = $params['screens']['edit']['slug'];
+                                                break;
+
+                                        case 'create_name' :
+                                                $lp['create_name'] = $params['screens']['create']['name'];
+                                                break;
+
+                                        case 'create_slug' :
+                                                $lp['create_slug'] = $params['screens']['create']['slug'];
+                                                break;
+
+                                        case 'admin_metabox_context' :
+                                                $lp['admin_metabox_context'] = $params['screens']['admin']['metabox_context'];
+                                                break;
+
+                                        case 'admin_metabox_priority' :
+                                                $lp['admin_metabox_priority'] = $params['screens']['admin']['metabox_priority'];
+                                                break;
+
+                                        default :
+                                                // All other items get moved over
+                                                $lp[ $property ] = $params[ $property ];
+
+                                                // Also reapply to the object, for backpat
+                                                $this->{$property} = $params[ $property ];
+
+                                                break;
+                                }
+                        }
+                }
+        }
 }
 
 function bp_register_group_extension( $group_extension_class ) {

new file tests/assets/group-extensions.php

@@ +1 @@
+<?php
+
+/**
+ * The following implementations of BP_Group_Extension act as dummy plugins
+ * for our unit tests
+ */
+
+class BPTest_Group_Extension_Parse_Legacy_Properties extends BP_Group_Extension {
+        function __construct() {
+                $class_name = get_class( $this );
+                $this->name = $class_name;
+                $this->slug = sanitize_title( $class_name );
+                $this->admin_name = $this->name . ' Edit';
+                $this->admin_slug = $this->slug . '-edit';
+                $this->create_name = $this->name . ' Create';
+                $this->create_slug = $this->slug . '-create';
+                $this->visibility = 'private';
+                $this->create_step_position = 58;
+                $this->nav_item_position = 63;
+                $this->admin_metabox_context = 'high';
+                $this->admin_metabox_priority = 'side';
+                $this->enable_create_step = false;
+                $this->enable_nav_item = true;
+                $this->enable_edit_item = false;
+                $this->enable_admin_item = true;
+                $this->nav_item_name = $this->name . ' Nav';
+                $this->display_hook = 'foo_hook';
+                $this->template_file = 'foo_template';
+        }
+
+        /**
+         * Provides access to protected method unneeded in BP
+         */
+        function _parse_legacy_properties() {
+                return $this->parse_legacy_properties();
+        }
+
+        /**
+         * Provides access to protected property unneeded in BP
+         */
+        function _get_legacy_properties_converted() {
+                return $this->legacy_properties_converted;
+        }
+}
+
+class BPTest_Group_Extension_Setup_Screens_Use_Global_Fallbacks extends BP_Group_Extension {
+        function __construct() {
+                $class_name = get_class( $this );
+                $this->slug = sanitize_title( $class_name );
+                $this->name = $class_name;
+        }
+
+        /**
+         * Provides access to protected method unneeded in BP
+         */
+        function _get_default_screens() {
+                return $this->get_default_screens();
+        }
+
+        /**
+         * Provides access to protected method unneeded in BP
+         */
+        function _setup_class_info() {
+                return $this->setup_class_info();
+        }
+
+}
+
+class BPTest_Group_Extension_Setup_Screens_Define_Edit_Screens_Locally extends BP_Group_Extension {
+        function __construct() {
+                $class_name = get_class( $this );
+                $this->slug = sanitize_title( $class_name );
+                $this->name = $class_name;
+        }
+
+        function edit_screen() {}
+        function edit_screen_save() {}
+
+        /**
+         * Provides access to protected method unneeded in BP
+         */
+        function _get_default_screens() {
+                return $this->get_default_screens();
+        }
+
+        /**
+         * Provides access to protected method unneeded in BP
+         */
+        function _setup_class_info() {
+                return $this->setup_class_info();
+        }
+
+}
+
+class BPTest_Group_Extension_Access_Root_Property extends BP_Group_Extension {
+        function __construct() {
+                $class_name = get_class( $this );
+
+                $args = array(
+                        'slug' => sanitize_title( $class_name ),
+                        'name' => $class_name,
+                        'nav_item_position' => 39,
+                );
+
+                parent::init( $args );
+        }
+}
+
+class BPTest_Group_Extension_Access_Init_Property_Using_Legacy_Location extends BP_Group_Extension {
+        function __construct() {
+                $class_name = get_class( $this );
+
+                $args = array(
+                        'slug' => sanitize_title( $class_name ),
+                        'name' => $class_name,
+                        'screens' => array(
+                                'create' => array(
+                                        'position' => 18,
+                                ),
+                        ),
+                );
+
+                parent::init( $args );
+        }
+}
+
+class BPTest_Group_Extension_Get_Screen_Callback_Fallbacks extends BP_Group_Extension {
+        function __construct() {
+                $class_name = get_class( $this );
+
+                $args = array(
+                        'slug' => sanitize_title( $class_name ),
+                        'name' => $class_name,
+                );
+
+                parent::init( $args );
+        }
+
+        function settings_screen() {}
+        function settings_screen_save() {}
+
+        function edit_screen() {}
+        function edit_screen_save() {}
+}

tests/bootstrap.php

@@ -2 +2 @@
 
 define( 'BP_PLUGIN_DIR', dirname( dirname( __FILE__ ) ) . '/' );
 
+if ( ! defined( 'BP_TESTS_DIR' ) ) {
+        define( 'BP_TESTS_DIR', dirname( __FILE__ ) . '/' );
+}
+
 require_once getenv( 'WP_TESTS_DIR' ) . '/includes/functions.php';
 
 function _install_and_load_buddypress() {
-        require dirname( __FILE__ ) . '/includes/loader.php';
+        require BP_TESTS_DIR . '/includes/loader.php';
 }
 tests_add_filter( 'muplugins_loaded', '_install_and_load_buddypress' );
 
 require getenv( 'WP_TESTS_DIR' ) . '/includes/bootstrap.php';
 
 // Load the BP-specific testing tools
-require dirname( __FILE__ ) . '/includes/testcase.php';
+require BP_TESTS_DIR . '/includes/testcase.php';

new file tests/testcases/groups/class-bp-group-extension.php

@@ +1 @@
+<?php
+
+include_once BP_TESTS_DIR . '/assets/group-extensions.php';
+
+/**
+ * @group groups
+ */
+class BP_Tests_Group_Extension_TestCases extends BP_UnitTestCase {
+        public function setUp() {
+                parent::setUp();
+        }
+
+        public function tearDown() {
+                parent::tearDown();
+        }
+
+        public function test_parse_legacy_properties() {
+                $class_name = 'BPTest_Group_Extension_Parse_Legacy_Properties';
+                $class_slug = sanitize_title( $class_name );
+                $e = new $class_name();
+                $e->_register();
+
+                // Test most items separately so we can ignore irrelevant props
+                $l = $e->_get_legacy_properties_converted();
+                $this->assertEquals( $l['name'], $class_name );
+                $this->assertEquals( $l['slug'], $class_slug );
+                $this->assertEquals( $l['visibility'], 'private' );
+                $this->assertEquals( $l['nav_item_position'], 63 );
+                $this->assertEquals( $l['enable_nav_item'], true );
+                $this->assertEquals( $l['nav_item_name'], $class_name . ' Nav' );
+                $this->assertEquals( $l['display_hook'], 'foo_hook' );
+                $this->assertEquals( $l['template_file'], 'foo_template' );
+
+                // Build the screens array manually
+                $expected = array(
+                        'create' => array(
+                                'name' => $class_name . ' Create',
+                                'slug' => $class_slug . '-create',
+                                'position' => 58,
+                                'enabled' => false,
+                        ),
+                        'edit' => array(
+                                'name' => $class_name . ' Edit',
+                                'slug' => $class_slug . '-edit',
+                                'enabled' => false,
+                        ),
+                        'admin' => array(
+                                'enabled' => true,
+                                'metabox_context' => 'high',
+                                'metabox_priority' => 'side',
+                        ),
+                );
+
+                $this->assertEquals( $expected, $l['screens'] );
+        }
+
+        public function test_setup_screens_use_global_fallbacks() {
+                $class_name = 'BPTest_Group_Extension_Setup_Screens_Use_Global_Fallbacks';
+                $e = new $class_name();
+                $e->_setup_class_info();
+                $screens = $e->_get_default_screens();
+
+                $fallback = array(
+                        'screen_callback' => array( $class_name, 'settings_screen' ),
+                        'screen_save_callback' => array( $class_name, 'settings_screen_save' ),
+                );
+                $fallbacks = array(
+                        'create' => $fallback,
+                        'edit' => $fallback,
+                        'admin' => $fallback,
+                );
+
+                // strip everything from the screens array but what we we're
+                // testing
+                foreach ( $screens as &$screen ) {
+                        foreach ( $screen as $k => $v ) {
+                                if ( ! in_array( $k, array( 'screen_callback', 'screen_save_callback' ) ) ) {
+                                        unset( $screen[ $k ] );
+                                }
+                        }
+                }
+
+                $this->assertEquals( $screens, $fallbacks );
+        }
+
+        public function test_setup_screens_define_edit_screens_locally() {
+                $class_name = 'BPTest_Group_Extension_Setup_Screens_Define_Edit_Screens_Locally';
+                $e = new $class_name();
+                $e->_setup_class_info();
+                $screens = $e->_get_default_screens();
+
+                $fallback = array(
+                        'screen_callback' => array( $class_name, 'settings_screen' ),
+                        'screen_save_callback' => array( $class_name, 'settings_screen_save' ),
+                );
+                $expected = array(
+                        'create' => $fallback,
+                        'edit' => array(
+                                'screen_callback' => array( $class_name, 'edit_screen' ),
+                                'screen_save_callback' => array( $class_name, 'edit_screen_save' ),
+                        ),
+                        'admin' => $fallback,
+                );
+
+                // strip everything from the screens array but what we we're
+                // testing
+                foreach ( $screens as &$screen ) {
+                        foreach ( $screen as $k => $v ) {
+                                if ( ! in_array( $k, array( 'screen_callback', 'screen_save_callback' ) ) ) {
+                                        unset( $screen[ $k ] );
+                                }
+                        }
+                }
+
+                $this->assertEquals( $screens, $expected );
+        }
+
+        public function test_parse_args_r() {
+                $a = array(
+                        'veggies' => 'yes',
+                        'ice_cream' => 'dope',
+                        'fruit' => array(
+                                'apple' => 'gross',
+                                'berries' => array(
+                                        'blueberries' => array(
+                                                'in_season' => 'never',
+                                                'oh' => 'boy',
+                                        ),
+                                        'cherries' => 'sometimes',
+                                ),
+                        ),
+                );
+
+                $b = array(
+                        'veggies' => 'no',
+                        'cheese' => array(
+                                'cheddar' => 'good',
+                        ),
+                        'fruit' => array(
+                                'apple' => 'yum',
+                                'berries' => array(
+                                        'strawberries' => 'awesome',
+                                        'blueberries' => array(
+                                                'in_season' => 'yes',
+                                                'out_of_season' => 'no',
+                                        ),
+                                ),
+                        ),
+                );
+
+                $expected = array(
+                        'veggies' => 'yes',
+                        'ice_cream' => 'dope',
+                        'cheese' => array(
+                                'cheddar' => 'good',
+                        ),
+                        'fruit' => array(
+                                'apple' => 'gross',
+                                'berries' => array(
+                                        'strawberries' => 'awesome',
+                                        'blueberries' => array(
+                                                'in_season' => 'never',
+                                                'out_of_season' => 'no',
+                                                'oh' => 'boy',
+                                        ),
+                                        'cherries' => 'sometimes',
+                                ),
+                        ),
+                );
+
+                $this->assertEquals( $expected, BP_Group_Extension::parse_args_r( $a, $b ) );
+        }
+
+        /**
+         * Config that gets intentionally stored as a direct property of object
+         */
+        public function test_access_root_property() {
+                $class_name = 'BPTest_Group_Extension_Access_Root_Property';
+                $e = new $class_name();
+                $e->_register();
+
+                $this->assertEquals( 39, $e->nav_item_position );
+        }
+
+        /**
+         * Config that gets registered using init(), but is then accessed via
+         * the legacy location
+         */
+        public function test_access_init_property_using_legacy_location() {
+                $class_name = 'BPTest_Group_Extension_Access_Init_Property_Using_Legacy_Location';
+                $e = new $class_name();
+                $e->_register();
+
+                $this->assertEquals( 18, $e->create_step_position );
+        }
+
+        /**
+         * Provides settings_screen* and edit_screen*
+         */
+        public function test_get_screen_callback_fallbacks() {
+                $class_name = 'BPTest_Group_Extension_Get_Screen_Callback_Fallbacks';
+                $e = new $class_name();
+                $e->_register();
+
+                $this->assertEquals( array( $class_name, 'settings_screen' ), $e->screens['create']['screen_callback'] );
+                $this->assertEquals( array( $class_name, 'settings_screen_save' ), $e->screens['create']['screen_save_callback'] );
+                $this->assertEquals( array( $class_name, 'settings_screen' ), $e->screens['admin']['screen_callback'] );
+                $this->assertEquals( array( $class_name, 'settings_screen_save' ), $e->screens['admin']['screen_save_callback'] );
+                $this->assertEquals( array( $class_name, 'edit_screen' ), $e->screens['edit']['screen_callback'] );
+                $this->assertEquals( array( $class_name, 'edit_screen_save' ), $e->screens['edit']['screen_save_callback'] );
+        }
+
+        public function test_has_submit_button() {
+                $a = '<p>Foo bar</p><input type="text" name="awesome" /><input name="save" type="submit" id="saverrrr" />sweet';
+                $this->assertTrue( BP_Group_Extension::has_submit_button( $a ) );
+
+                $b = '<p>Foo bar</p><input type="text" name="awesome" />sweet';
+                $this->assertFalse( BP_Group_Extension::has_submit_button( $b ) );
+
+                // switch the quotation marks
+                $c = "<p>Foo bar</p><input type='text' name='awesome' /><input name='save' type='submit' id='saverrrr' />sweet";
+                $this->assertTrue( BP_Group_Extension::has_submit_button( $c ) );
+        }
+}