Ticket #4017: 4017.03.patch

src/bp-core/bp-core-actions.php

@@ -67 +67 @@
 add_action( 'bp_init', 'bp_core_set_uri_globals',    2  );
 add_action( 'bp_init', 'bp_setup_globals',           4  );
 add_action( 'bp_init', 'bp_setup_canonical_stack',   5  );
+add_action( 'bp_init', 'bp_register_taxonomies',     5  );
 add_action( 'bp_init', 'bp_setup_nav',               6  );
 add_action( 'bp_init', 'bp_setup_title',             8  );
 add_action( 'bp_init', 'bp_core_load_admin_bar_css', 12 );
@@ -96 +97 @@
  */
 add_action( 'bp_after_setup_theme', 'bp_load_theme_functions', 1 );
 
+/**
+ * Start the BP Term class
+ */
+add_action( 'bp_core_setup_globals', array( 'BP_Terms', 'start' ) );
+
 // Load the admin
 if ( is_admin() ) {
         add_action( 'bp_loaded', 'bp_admin' );

src/bp-core/bp-core-catchuri.php

@@ -396 +396 @@
 
                 // Template was located, lets set this as a valid page and not a 404.
                 status_header( 200 );
-                $wp_query->is_page     = true;
-                $wp_query->is_singular = true;
-                $wp_query->is_404      = false;
+                $wp_query->queried_object    = null;
+                $wp_query->queried_object_id = 0;
+                $wp_query->is_page           = true;
+                $wp_query->is_singular       = true;
+                $wp_query->is_404            = false;
 
                 do_action( 'bp_core_pre_load_template', $located_template );
 
@@ -417 +419 @@
                 // The rest will be done by bp_theme_compat_reset_post() later.
                 if ( is_buddypress() ) {
                         status_header( 200 );
-                        $wp_query->is_page     = true;
-                        $wp_query->is_singular = true;
-                        $wp_query->is_404      = false;
+                        $wp_query->queried_object    = null;
+                        $wp_query->queried_object_id = 0;
+                        $wp_query->is_page           = true;
+                        $wp_query->is_singular       = true;
+                        $wp_query->is_404            = false;
                 }
 
                 do_action( 'bp_setup_theme_compat' );

src/bp-core/bp-core-classes.php

@@ -2700 +2700 @@
                 return apply_filters( 'bp_members_suggestions_get_suggestions', $results, $this );
         }
 }
+
+/**
+ * Use WordPress term/taxonomy functions, forcing the table prefix to be the one of root blog id.
+ *
+ * This is needed for Multisite configs in case a component taxonomy is used from a child blog.
+ *
+ * @since BuddyPress (?)
+ */
+class BP_Terms {
+
+        /**
+         * Start the class
+         *
+         * @access public
+         * @since BuddyPress (?)
+         * @static
+         */
+        public static function start() {
+                $bp = buddypress();
+
+                if ( empty( $bp->terms ) ) {
+                        $bp->terms = new self;
+                }
+
+                return $bp->terms;
+        }
+
+        /**
+         * Constructor
+         *
+         * @access public
+         * @since BuddyPress (?)
+         */
+        public function __construct() {}
+
+        /**
+         * Set needed $wpdb->tables to be the one of root blog id
+         *
+         * @access public
+         * @since BuddyPress (?)
+         * @static
+         */
+        public static function set_tables() {
+                switch_to_blog( bp_get_root_blog_id() );
+        }
+
+        /**
+         * Reset $wpdb->tables to the one set by WordPress
+         *
+         * @access public
+         * @since BuddyPress (?)
+         * @static
+         */
+        public static function reset_tables() {
+                restore_current_blog();
+        }
+
+        /**
+         * Update term count
+         *
+         * @access public
+         * @since BuddyPress (?)
+         * @static
+         */
+        public static function update_term_count( $terms, $taxonomy ) {
+                self::set_tables();
+                _update_generic_term_count( $terms, $taxonomy );
+                self::reset_tables();
+        }
+
+        /**
+         * Get group tags
+         *
+         * @access public
+         * @since BuddyPress (?)
+         * @static
+         *
+         * @uses wp_get_object_terms()
+         */
+        public static function get_object_terms( $object_ids, $taxonomies, $args = array() ) {
+                self::set_tables();
+                $return = wp_get_object_terms( $object_ids, $taxonomies, $args );
+                self::reset_tables();
+                return $return;
+        }
+
+        /**
+         * Set group tags
+         *
+         * @access public
+         * @since BuddyPress (?)
+         * @static
+         *
+         * @uses wp_set_object_terms()
+         */
+        public static function set_object_terms( $object_id, $terms, $taxonomy, $append ) {
+                self::set_tables();
+                $return = wp_set_object_terms( $object_id, $terms, $taxonomy, $append );
+                self::reset_tables();
+                return $return;
+        }
+
+        /**
+         * Remove group tags
+         *
+         * @access public
+         * @since BuddyPress (?)
+         * @static
+         *
+         * @uses wp_remove_object_terms()
+         */
+        public static function remove_object_terms( $object_id, $terms, $taxonomy ) {
+                self::set_tables();
+                $return = wp_remove_object_terms( $object_id, $terms, $taxonomy );
+                self::reset_tables();
+                return $return;
+        }
+
+        /**
+         * Remove all group relationships
+         *
+         * @access public
+         * @since BuddyPress (?)
+         * @static
+         *
+         * @uses wp_delete_object_term_relationships()
+         */
+        public static function delete_object_term_relationships( $object_id, $taxonomies = 'bp_group_tags' ) {
+                self::set_tables();
+                $return = wp_delete_object_term_relationships( $object_id, $taxonomies );
+                self::reset_tables();
+                return $return;
+        }
+
+        /**
+         * Get group ids for a given tag
+         *
+         * @access public
+         * @since BuddyPress (?)
+         * @static
+         *
+         * @uses get_objects_in_term()
+         */
+        public static function get_objects_in_term( $term_ids, $taxonomies, $args = array() ) {
+                self::set_tables();
+                $return = get_objects_in_term( $term_ids, $taxonomies, $args );
+                self::reset_tables();
+                return $return;
+        }
+
+        /**
+         * Get all Term data from database by Term ID
+         *
+         * @access public
+         * @since BuddyPress (?)
+         * @static
+         *
+         * @uses get_term()
+         */
+        public static function get_term( $term, $taxonomy, $output, $filter ) {
+                self::set_tables();
+                $return = get_term( $term, $taxonomy, $output, $filter );
+                self::reset_tables();
+                return $return;
+        }
+
+        /**
+         * Get all terms for a given taxonomy
+         *
+         * @access public
+         * @since BuddyPress (?)
+         * @static
+         *
+         * @uses get_terms()
+         */
+        public static function get_terms( $taxonomies, $args = array() ) {
+                self::set_tables();
+                $return = get_terms( $taxonomies, $args );
+                self::reset_tables();
+                return $return;
+        }
+
+        /**
+         * Get all terms to edit for a given taxonomy
+         *
+         * @access public
+         * @since BuddyPress (?)
+         * @static
+         *
+         * @uses get_terms_to_edit()
+         */
+        public static function get_terms_to_edit( $post_id, $taxonomy ) {
+                self::set_tables();
+                $return = get_terms_to_edit( $post_id, $taxonomy );
+                self::reset_tables();
+                return $return;
+        }
+
+        /**
+         * Insert a term based on arguments provided.
+         *
+         * @access public
+         * @since BuddyPress (?)
+         * @static
+         *
+         * @uses wp_insert_term()
+         */
+        public static function insert_term( $term, $taxonomy, $args = array() ) {
+                self::set_tables();
+                $return = wp_insert_term( $term, $taxonomy, $args );
+                self::reset_tables();
+                return $return;
+        }
+
+        /**
+         * Update term based on arguments provided.
+         *
+         * @access public
+         * @since BuddyPress (?)
+         * @static
+         *
+         * @uses wp_update_term()
+         */
+        public static function update_term( $term_id, $taxonomy, $args = array() ) {
+                self::set_tables();
+                $return = wp_update_term( $term_id, $taxonomy, $args );
+                self::reset_tables();
+                return $return;
+        }
+
+        /**
+         * Delete term based on arguments provided.
+         *
+         * @access public
+         * @since BuddyPress (?)
+         * @static
+         *
+         * @uses wp_delete_term()
+         */
+        public static function delete_term( $term_id, $taxonomy, $args = array() ) {
+                self::set_tables();
+                $return = wp_delete_term( $term_id, $taxonomy, $args );
+                self::reset_tables();
+                return $return;
+        }
+
+        /**
+         * Get term thanks to a specific field
+         *
+         * @access public
+         * @since BuddyPress (?)
+         * @static
+         *
+         * @uses get_term_by()
+         */
+        public static function get_term_by( $field, $value, $taxonomy, $output, $filter ) {
+                self::set_tables();
+                $return = get_term_by( $field, $value, $taxonomy, $output, $filter );
+                self::reset_tables();
+                return $return;
+        }
+
+        /**
+         * Get the term link
+         *
+         * @access public
+         * @since BuddyPress (?)
+         * @static
+         *
+         * @uses get_term_link()
+         */
+        public static function get_term_link( $term, $taxonomy ) {
+                $root_blog = bp_is_root_blog();
+
+                if ( ! $root_blog ) {
+                        switch_to_blog( bp_get_root_blog_id() );
+                }
+
+                $return = get_term_link( $term, $taxonomy );
+
+                if ( ! $root_blog ) {
+                        restore_current_blog();
+                }
+
+                return $return;
+        }
+
+        /**
+         * Copy WordPress get_the_term_list without using get_the_terms()
+         * function as it checks for an existing post.
+         *
+         * @access public
+         * @since BuddyPress (?)
+         * @static
+         *
+         * @uses self::get_object_terms()
+         * @uses self::get_term_link()
+         */
+        public static function get_the_term_list( $object_id, $taxonomy, $before, $sep, $after ) {
+
+                $terms = self::get_object_terms( $object_id, $taxonomy );
+
+                if ( is_wp_error( $terms ) )
+                        return $terms;
+
+                if ( empty( $terms ) )
+                        return false;
+
+                self::set_tables();
+                foreach ( $terms as $term ) {
+                        $link = get_term_link( $term, $taxonomy );
+                        if ( is_wp_error( $link ) )
+                                return $link;
+                        $term_links[] = '<a href="' . esc_url( $link ) . '" rel="tag">' . $term->name . '</a>';
+                }
+                self::reset_tables();
+
+                $term_links = apply_filters( "term_links-$taxonomy", $term_links );
+
+                return $before . join( $sep, $term_links ) . $after;
+        }
+
+        /**
+         * Get the sql for a Tax Query
+         *
+         * @access public
+         * @since BuddyPress (?)
+         * @static
+         *
+         * @uses get_term_link()
+         */
+        public static function get_tax_sql( $tax_query, $primary_table, $primary_id_column ) {
+                global $wpdb;
+                self::set_tables();
+                $return = get_tax_sql( $tax_query, $primary_table, $primary_id_column );
+                self::reset_tables();
+                return $return;
+        }
+}

src/bp-core/bp-core-component.php

@@ -554 +554 @@
          *
          * @uses do_action() Calls 'bp_{@link bp_Component::name}_register_taxonomies'.
          */
-        public function register_taxonomies() {
+        public function register_taxonomies( $taxonomy = '', $object_type = '', $args = array(), $network = false ) {
+                if ( ! bp_is_root_blog() && empty( $network ) ) {
+                        return;
+                }
+
+                if ( ! taxonomy_exists( $taxonomy ) && ! empty( $object_type ) && ! empty( $args ) ) {
+                        register_taxonomy( $taxonomy, $object_type, $args );
+                }
+
                 do_action( 'bp_' . $this->id . '_register_taxonomies' );
         }
 

src/bp-core/bp-core-dependency.php

@@ -68 +68 @@
 }
 
 /**
+ * Fire the 'bp_register_taxonomies' action, where plugins should register bp_terms.
+ */
+function bp_register_taxonomies() {
+        do_action( 'bp_register_taxonomies' );
+}
+
+/**
  * Fire the 'bp_register_widgets' action, where plugins should register widgets.
  */
 function bp_setup_widgets() {

src/bp-core/bp-core-functions.php

@@ -2034 +2034 @@
         }
 
         return apply_filters( 'bp_core_get_suggestions', $retval, $args );
-}
- No newline at end of file
+}
+
+/** BuddyPress Terms **********************************************************/
+
+/**
+ * Get all Term data from database by Term ID.
+ *
+ * WordPress get_term function for BuddyPress root blog id
+ * @see get_term() for the full description.
+ *
+ * @since BuddyPress (?)
+ *
+ * @uses BP_Terms::get_term().
+ *
+ * @param int|object $term If integer, will get from database. If object will apply filters and return $term.
+ * @param string $taxonomy Taxonomy name that $term is part of.
+ * @param string $output Constant OBJECT, ARRAY_A, or ARRAY_N
+ * @param string $filter Optional, default is raw or no WordPress defined filter will applied.
+ * @return mixed|null|WP_Error Term Row from database. Will return null if $term is empty. If taxonomy does not
+ * exist then WP_Error will be returned.
+ */
+function bp_core_get_term( $term, $taxonomy, $output = OBJECT, $filter = 'raw' ) {
+        return BP_Terms::get_term( $term, $taxonomy, $output, $filter );
+}
+
+/**
+ * Retrieve the terms in a given taxonomy or list of taxonomies.
+ *
+ * WordPress get_terms function for BuddyPress root blog id
+ * @see get_terms() for the list of possible args.
+ *
+ * @since BuddyPress (?)
+ *
+ * @uses BP_Terms::get_terms().
+ *
+ * @param string|array $taxonomies Taxonomy name or list of Taxonomy names.
+ * @param string|array $args The values of what to search for when returning terms
+ * @return array|WP_Error List of Term Objects and their children. Will return WP_Error, if any of $taxonomies do not exist.
+ */
+function bp_core_get_terms( $taxonomies = '', $args = '' ) {
+        return BP_Terms::get_terms( $taxonomies, $args );
+}
+
+/**
+ * Retrieve the terms in a given taxonomy to edit.
+ *
+ * WordPress get_terms_to_edit function for BuddyPress root blog id
+ * @see get_terms_to_edit() for the list of possible args.
+ *
+ * @since BuddyPress (?)
+ *
+ * @uses BP_Terms::get_terms().
+ *
+ * @param int $object_id Object ID.
+ * @param string $taxonomy The taxonomy to which to edit the term
+ * @return array|WP_Error List of Term Objects and their children. Will return WP_Error, if any of $taxonomies do not exist.
+ */
+function bp_core_get_terms_to_edit( $object_id, $taxonomy = '' ) {
+        return BP_Terms::get_terms_to_edit( $object_id, $taxonomy );
+}
+
+/**
+ * Add a new term to the database.
+ *
+ * WordPress wp_insert_term function for BuddyPress root blog id
+ * @see wp_insert_term() for the list of possible args.
+ *
+ * @since BuddyPress (?)
+ *
+ * @uses BP_Terms::insert_term().
+ *
+ * @param string       $term     The term to add or update.
+ * @param string       $taxonomy The taxonomy to which to add the term
+ * @param array|string $args
+ * @return array|WP_Error An array containing the term_id and term_taxonomy_id, WP_Error otherwise.
+ */
+function bp_core_insert_term( $term, $taxonomy, $args = array() ) {
+        return BP_Terms::insert_term( $term, $taxonomy, $args );
+}
+
+/**
+ * Update term based on arguments provided.
+ *
+ * WordPress wp_update_term function for BuddyPress root blog id
+ * @see wp_update_term() for the list of possible args.
+ *
+ * @since BuddyPress (?)
+ *
+ * @uses BP_Terms::update_term().
+ *
+ * @param int $term_id The ID of the term
+ * @param string $taxonomy The context in which to relate the term to the object.
+ * @param array|string $args Overwrite term field values
+ * @return array|WP_Error Returns Term ID and Taxonomy Term ID
+ */
+function bp_core_update_term( $term_id, $taxonomy, $args = array() ) {
+        return BP_Terms::update_term( $term_id, $taxonomy, $args );
+}
+
+/**
+ * Removes a term from the database.
+ *
+ * WordPress wp_update_term function for BuddyPress root blog id
+ * @see wp_delete_term() for the list of possible args.
+ *
+ * @since BuddyPress (?)
+ *
+ * @uses BP_Terms::delete_term().
+ *
+ * @param int $term_id Term ID
+ * @param string $taxonomy Taxonomy Name
+ * @param array|string $args Optional. Change 'default' term id and override found term ids.
+ * @return bool|WP_Error Returns false if not term; true if completes delete action.
+ */
+function bp_core_delete_term( $term_id, $taxonomy, $args = array() ) {
+        return BP_Terms::delete_term( $term_id, $taxonomy, $args );
+}
+
+/**
+ * Get all Term data from database by Term field and data.
+ *
+ * WordPress get_term_by function for BuddyPress root blog id
+ * @see get_term_by() for the list of possible args.
+ *
+ * @since BuddyPress (?)
+ *
+ * @uses BP_Terms::get_term_by().
+ *
+ * @param string $field Either 'slug', 'name', 'id' (term_id), or 'term_taxonomy_id'
+ * @param string|int $value Search for this term value
+ * @param string $taxonomy Taxonomy Name
+ * @param string $output Constant OBJECT, ARRAY_A, or ARRAY_N
+ * @param string $filter Optional, default is raw or no WordPress defined filter will applied.
+ * @return mixed Term Row from database. Will return false if $taxonomy does not exist or $term was not found.
+ */
+function bp_core_get_term_by( $field, $value, $taxonomy = '', $output = OBJECT, $filter = 'raw' ) {
+        return BP_Terms::get_term_by( $field, $value, $taxonomy, $output, $filter );
+}
+
+/**
+ * Generates a permalink for a taxonomy term archive.
+ *
+ * WordPress get_term_link function for BuddyPress root blog id
+ * @see get_term_link()
+ *
+ * @since BuddyPress (?)
+ *
+ * @uses BP_Terms::get_term_link().
+ *
+ * @param object|int|string $term
+ * @param string $taxonomy (optional if $term is object)
+ * @return string|WP_Error HTML link to taxonomy term archive on success, WP_Error if term does not exist.
+ */
+function bp_core_get_term_link( $term, $taxonomy = '' ) {
+        return BP_Terms::get_term_link( $term, $taxonomy );
+}
+
+/**
+ * Retrieve a BuddyPress item terms as a list with specified format.
+ *
+ * WordPress get_the_term_list function adapted for BuddyPress
+ *
+ * @since BuddyPress (?)
+ *
+ * @uses BP_Terms::get_the_term_list().
+ *
+ * @param int $id BuddyPress item id (for instance a group id).
+ * @param string $taxonomy Taxonomy name.
+ * @param string $before Optional. Before list.
+ * @param string $sep Optional. Separate items using this.
+ * @param string $after Optional. After list.
+ * @return string|bool|WP_Error A list of terms on success, false or WP_Error on failure.
+ */
+function bp_core_get_the_term_list( $object_id, $taxonomy = '', $before = '', $sep = '', $after = '' ) {
+        return BP_Terms::get_the_term_list( $object_id, $taxonomy, $before, $sep, $after );
+}
+
+/**
+ * Retrieve object_ids of valid taxonomy and term.
+ *
+ * WordPress get_objects_in_term function for BuddyPress root blog id
+ * @see get_objects_in_term() for the list of possible args.
+ *
+ * @since BuddyPress (?)
+ *
+ * @uses BP_Terms::get_objects_in_term().
+ *
+ * @param int|array $term_ids Term id or array of term ids of terms that will be used
+ * @param string|array $taxonomies String of taxonomy name or Array of string values of taxonomy names
+ * @param array|string $args Change the order of the object_ids, either ASC or DESC
+ * @return WP_Error|array If the taxonomy does not exist, then WP_Error will be returned. On success
+ *      the array can be empty meaning that there are no $object_ids found or it will return the $object_ids found.
+ */
+function bp_core_get_objects_in_term( $term_ids, $taxonomies = '', $args = array() ) {
+        return BP_Terms::get_objects_in_term( $term_ids, $taxonomies, $args );
+}
+
+/**
+ * Retrieves the terms associated with the given object(s), in the supplied taxonomies.
+ *
+ * WordPress wp_get_object_terms function for BuddyPress root blog id
+ * @see wp_get_object_terms() for the list of possible args.
+ *
+ * @since BuddyPress (?)
+ *
+ * @uses BP_Terms::get_object_terms().
+ *
+ * @param int|array $object_ids The ID(s) of the object(s) to retrieve.
+ * @param string|array $taxonomies The taxonomies to retrieve terms from.
+ * @param array|string $args Change what is returned
+ * @return array|WP_Error The requested term data or empty array if no terms found. WP_Error if any of the $taxonomies don't exist.
+ */
+function bp_core_get_object_terms( $object_ids, $taxonomies = '', $args = array() ) {
+        return BP_Terms::get_object_terms( $object_ids, $taxonomies, $args );
+}
+
+/**
+ * Create Term and Taxonomy Relationships.
+ *
+ * WordPress wp_set_object_terms function for BuddyPress root blog id
+ * @see wp_set_object_terms()
+ *
+ * @since BuddyPress (?)
+ *
+ * @uses BP_Terms::set_object_terms().
+ *
+ * @param int $object_id The object to relate to.
+ * @param array|int|string $terms The slug or id of the term, will replace all existing
+ * related terms in this taxonomy.
+ * @param array|string $taxonomy The context in which to relate the term to the object.
+ * @param bool $append If false will delete difference of terms.
+ * @return array|WP_Error Affected Term IDs
+ */
+function bp_core_set_object_terms( $object_id, $terms, $taxonomy = '', $append = false ) {
+        return BP_Terms::set_object_terms( $object_id, $terms, $taxonomy, $append );
+}
+
+/**
+ * Remove term(s) associated with a given object.
+ *
+ * WordPress wp_remove_object_terms function for BuddyPress root blog id
+ * @see wp_remove_object_terms()
+ *
+ * @since BuddyPress (?)
+ *
+ * @uses BP_Terms::remove_object_terms().
+ *
+ * @param int $object_id The ID of the object from which the terms will be removed.
+ * @param array|int|string $terms The slug(s) or ID(s) of the term(s) to remove.
+ * @param array|string $taxonomy Taxonomy name.
+ * @return bool|WP_Error True on success, false or WP_Error on failure.
+ */
+function bp_core_remove_object_terms( $object_id, $terms, $taxonomy = '' ) {
+        return BP_Terms::remove_object_terms( $object_id, $terms, $taxonomy );
+}
+
+/**
+ * Will unlink the object from the taxonomy or taxonomies.
+ *
+ * WordPress wp_delete_object_term_relationships function for BuddyPress root blog id
+ * @see wp_delete_object_term_relationships()
+ *
+ * @since BuddyPress (?)
+ *
+ * @uses BP_Terms::delete_object_term_relationships().
+ *
+ * @param int $object_id The term Object Id that refers to the term
+ * @param string|array $taxonomies List of Taxonomy Names or single Taxonomy name.
+ */
+function bp_core_delete_object_term_relationships( $object_id, $taxonomies = '' ) {
+        return BP_Terms::delete_object_term_relationships( $object_id, $taxonomies );
+}
+
+/**
+ * Will update term count based on number of objects.
+ *
+ * WordPress _update_generic_term_count function for BuddyPress root blog id
+ * @see _update_generic_term_count()
+ *
+ * @since BuddyPress (?)
+ *
+ * @uses BP_Terms::update_term_count().
+ *
+ * @param array $terms List of Term taxonomy IDs
+ * @param object $taxonomy Current taxonomy object of terms
+ */
+function bp_core_update_term_count( $terms, $taxonomy = '' ) {
+        return BP_Terms::update_term_count( $terms, $taxonomy );
+}
+
+/**
+ * Given a taxonomy query, generates SQL to be appended to a main query.
+ *
+ * WordPress get_tax_sql function for BuddyPress root blog id
+ * @see get_tax_sql()
+ *
+ * @since BuddyPress (?)
+ *
+ * @param array $tax_query A compact tax query
+ * @param string $primary_table
+ * @param string $primary_id_column
+ * @return array
+ */
+function bp_core_get_tax_sql( $tax_query = array(), $primary_table = '', $primary_id_column ='' ) {
+        return BP_Terms::get_tax_sql( $tax_query, $primary_table, $primary_id_column );
+}

src/bp-core/bp-core-template.php

@@ -1898 +1898 @@
  */
 function bp_is_groups_directory() {
         if ( bp_is_groups_component() && ! bp_current_action() && ! bp_current_item() ) {
+                return true;
+        }
+
+        if ( bp_is_groups_component() && bp_is_groups_tag() ) {
+                return true;
+        }
+
+        return false;
+}
+
+/**
+ * Is the current page a groups tag page?
+ *
+ * @since BuddyPress (?)
+ *
+ * @return True if the current page is a groups tag page.
+ */
+function bp_is_groups_tag() {
+        if ( ! empty( buddypress()->groups->tag ) ) {
                 return true;
         }
 
@@ -1917 +1936 @@
         if ( ! empty( $retval ) ) {
                 $retval = bp_is_groups_component() && groups_get_current_group();
         }
-        
+
         return (bool) $retval;
 }
 
@@ -2719 +2738 @@
                 return $nav_menu;
         }
 }
+
+/**
+ * Display BuddyPress item tags form fields.
+ *
+ * An adapted copy of WordPress post_tags_meta_box()
+ * to avoid including the meta-boxes.php file and to
+ * be able to use in group edit/create/admin screens
+ *
+ * @since BuddyPress (?)
+ *
+ * @param Object BuddyPress item (such as BP_Groups_Group)
+ * @param array   $box {
+ *     Tags meta box arguments.
+ *
+ *     @type string   $id       Meta box ID.
+ *     @type string   $title    Meta box title.
+ *     @type callback $callback Meta box display callback.
+ *     @type array    $args {
+ *         Extra meta box arguments.
+ *
+ *         @type string $taxonomy Taxonomy. Default 'bp_group_tags'.
+ *     }
+ * }
+ */
+function bp_tags_meta_box( $item, $box ) {
+        $defaults = array( 'taxonomy' => 'bp_group_tags' );
+
+        if ( ! isset( $box['args'] ) || ! is_array( $box['args'] ) ) {
+                $args = array();
+        } else {
+                $args = $box['args'];
+        }
+
+        $r = wp_parse_args( $args, $defaults );
+        $tax = $r['taxonomy'];
+        $tax_name = esc_attr( $tax );
+        $taxonomy = get_taxonomy( $tax );
+        $user_can_assign_terms = bp_current_user_can( $taxonomy->cap->assign_terms );
+        $comma = _x( ',', 'tag delimiter', 'buddypress' );
+        ?>
+        <div class="tagsdiv" id="<?php echo $tax_name; ?>">
+                <div class="jaxtag">
+                <div class="nojs-tags hide-if-js">
+                <p><?php echo $taxonomy->labels->add_or_remove_items; ?></p>
+                <textarea name="<?php echo "tax_input[$tax_name]"; ?>" rows="3" cols="20" class="the-tags" id="tax-input-<?php echo $tax_name; ?>" <?php disabled( ! $user_can_assign_terms ); ?>><?php echo str_replace( ',', $comma . ' ', bp_core_get_terms_to_edit( $item->id, $tax_name ) ); // textarea_escaped by esc_attr() ?></textarea></div>
+                <?php if ( $user_can_assign_terms ) : ?>
+                <div class="ajaxtag hide-if-no-js">
+                        <label class="screen-reader-text" for="new-tag-<?php echo $tax_name; ?>"><?php echo $box['title']; ?></label>
+                        <div class="taghint"><?php echo $taxonomy->labels->add_new_item; ?></div>
+                        <p><input type="text" id="new-tag-<?php echo $tax_name; ?>" name="newtag[<?php echo $tax_name; ?>]" class="newtag form-input-tip" size="16" autocomplete="off" value="" />
+                        <input type="button" class="button tagadd" value="<?php esc_attr_e('Add'); ?>" /></p>
+                </div>
+                <p class="howto"><?php echo $taxonomy->labels->separate_items_with_commas; ?></p>
+                <?php endif; ?>
+                </div>
+                <div class="tagchecklist"></div>
+        </div>
+        <?php if ( $user_can_assign_terms ) : ?>
+        <p class="hide-if-no-js"><a href="#titlediv" class="tagcloud-link" id="link-<?php echo $tax_name; ?>"><?php echo $taxonomy->labels->choose_from_most_used; ?></a></p>
+        <?php endif;
+}

src/bp-core/css/tagbox.css

@@ +1 @@
+.bp-tag-editor {
+        overflow: hidden;
+}
+
+.bp-tag-editor .hide-if-js {
+        display:none;
+}
+
+.tagchecklist {
+        margin-left: 14px;
+        font-size: 12px;
+        overflow: auto;
+        margin-bottom:15px;
+}
+
+.tagchecklist br {
+        display: none;
+}
+
+.tagchecklist strong {
+        margin-left: -8px;
+        position: absolute;
+}
+
+.tagchecklist span {
+        margin-right: 25px;
+        display: block;
+        float: left;
+        font-size: 13px;
+        line-height: 1.8em;
+        white-space: nowrap;
+        cursor: default;
+}
+
+.tagchecklist span a {
+        margin: 1px 0 0 -10px;
+        cursor: pointer;
+        width: 20px;
+        height: 20px;
+        display: block;
+        float: left;
+        text-indent: 0;
+        overflow: hidden;
+        position: absolute;
+        color: #555;
+        font-weight:bold;
+        font-size: 90%;
+}
+
+.tagsdiv {
+        margin-top: -8px;
+}
+
+.taghint {
+        color: #aaa;
+        margin: 15px 0 -24px 12px;
+}
+
+.tagsdiv .howto {
+        margin: 0 0 6px 0;
+}
+
+.ajaxtag .newtag {
+        position: relative;
+}
+
+.tagsdiv .newtag {
+        width: 180px;
+}
+
+.tagsdiv .the-tags {
+        display: block;
+        height: 60px;
+        margin: 0 auto;
+        overflow: auto;
+        width: 260px;
+}
+
+body.buddypress .tagsdiv .the-tags {
+        margin: 0 5px;
+}
+
+/* tag hints */
+.taghint {
+        color: #aaa;
+        margin: -17px 0 0 7px;
+        visibility: hidden;
+}
+
+input.newtag ~ div.taghint {
+        visibility: visible;
+}
+
+input.newtag:focus ~ div.taghint {
+        visibility: hidden;
+}
+
+p.popular-tags {
+        border: none;
+        line-height: 2em;
+        max-width: 1000px;
+        padding: 8px 12px 12px;
+        text-align: justify;
+}
+
+p.popular-tags a {
+        padding: 0 3px;
+}
+
+.tagcloud {
+        width: 97%;
+        margin: 0 0 40px;
+        text-align: justify;
+}
+
+.tagcloud h3 {
+        margin: 2px 0 12px;
+}
+
+.ac_results {
+        padding: 0;
+        margin: 0;
+        list-style: none;
+        position: absolute;
+        z-index: 10000;
+        display: none;
+        border: 1px solid #808080;
+        background-color: #fff;
+}
+
+body.buddypress .ac_results {
+        z-index: 500000;
+}
+
+.ac_results li {
+        padding: 2px 5px;
+        white-space: nowrap;
+        color: #101010;
+        text-align: left;
+}
+
+.ac_over {
+        background-color: #f0f0b8;
+        cursor: pointer;
+}

src/bp-core/js/tagbox.js

@@ +1 @@
+// return an array with any duplicate, whitespace or values removed
+function array_unique_noempty(a) {
+        var out = [];
+        jQuery.each( a, function(key, val) {
+                val = jQuery.trim(val);
+                if ( val && jQuery.inArray(val, out) == -1 )
+                        out.push(val);
+                } );
+        return out;
+}
+
+( function($) {
+        var titleHasFocus = false;
+
+        tagBox = {
+                clean : function(tags) {
+                        var comma = tagvars.comma;
+                        if ( ',' !== comma )
+                                tags = tags.replace(new RegExp(comma, 'g'), ',');
+                        tags = tags.replace(/\s*,\s*/g, ',').replace(/,+/g, ',').replace(/[,\s]+$/, '').replace(/^[,\s]+/, '');
+                        if ( ',' !== comma )
+                                tags = tags.replace(/,/g, comma);
+                        return tags;
+                },
+
+                parseTags : function(el) {
+                        var id = el.id, num = id.split('-check-num-')[1], taxbox = $(el).closest('.tagsdiv'),
+                                thetags = taxbox.find('.the-tags'), comma = tagvars.comma,
+                                current_tags = thetags.val().split(comma), new_tags = [];
+                        delete current_tags[num];
+
+                        $.each( current_tags, function(key, val) {
+                                val = $.trim(val);
+                                if ( val ) {
+                                        new_tags.push(val);
+                                }
+                        });
+
+                        thetags.val( this.clean( new_tags.join(comma) ) );
+
+                        this.quickClicks(taxbox);
+                        return false;
+                },
+
+                quickClicks : function(el) {
+                        var thetags = $('.the-tags', el),
+                                tagchecklist = $('.tagchecklist', el),
+                                id = $(el).attr('id'),
+                                current_tags, disabled;
+
+                        if ( !thetags.length )
+                                return;
+
+                        disabled = thetags.prop('disabled');
+
+                        current_tags = thetags.val().split(tagvars.comma);
+                        tagchecklist.empty();
+
+                        $.each( current_tags, function( key, val ) {
+                                var span, xbutton;
+
+                                val = $.trim( val );
+
+                                if ( ! val )
+                                        return;
+
+                                // Create a new span, and ensure the text is properly escaped.
+                                span = $('<span />').text( val );
+
+                                // If tags editing isn't disabled, create the X button.
+                                if ( ! disabled ) {
+                                        xbutton = $( '<a id="' + id + '-check-num-' + key + '" class="ntdelbutton">X</a>' );
+                                        xbutton.click( function(){ tagBox.parseTags(this); });
+                                        span.prepend('&nbsp;').prepend( xbutton );
+                                }
+
+                                // Append the span to the tag list.
+                                tagchecklist.append( span );
+                        });
+                },
+
+                flushTags : function(el, a, f) {
+                        var tagsval, newtags, text,
+                                tags = $('.the-tags', el),
+                                newtag = $('input.newtag', el),
+                                comma = tagvars.comma;
+                        a = a || false;
+
+                        text = a ? $(a).text() : newtag.val();
+                        tagsval = tags.val();
+                        newtags = tagsval ? tagsval + comma + text : text;
+
+                        newtags = this.clean( newtags );
+                        newtags = array_unique_noempty( newtags.split(comma) ).join(comma);
+                        tags.val(newtags);
+                        this.quickClicks(el);
+
+                        if ( !a )
+                                newtag.val('');
+                        if ( 'undefined' == typeof(f) )
+                                newtag.focus();
+
+                        return false;
+                },
+
+                get : function(id) {
+                        var tax = id.substr(id.indexOf('-')+1);
+
+                        $.post(ajaxurl, {'action':'get-tagcloud', 'tax':tax}, function(r, stat) {
+                                if ( 0 === r || 'success' != stat )
+                                        r = wpAjax.broken;
+
+                                r = $('<p id="tagcloud-'+tax+'" class="the-tagcloud">'+r+'</p>');
+                                $('a', r).click(function(){
+                                        tagBox.flushTags( $(this).closest('.inside').children('.tagsdiv'), this);
+                                        return false;
+                                });
+
+                                $('#'+id).after(r);
+                        });
+                },
+
+                init : function() {
+                        var t = this, ajaxtag = $('div.ajaxtag');
+
+                        $('.tagsdiv').each( function() {
+                                tagBox.quickClicks(this);
+                        });
+
+                        $('input.tagadd', ajaxtag).click(function(){
+                                t.flushTags( $(this).closest('.tagsdiv') );
+                        });
+
+                        $('div.taghint', ajaxtag).click(function(){
+                                $(this).css('visibility', 'hidden').parent().siblings('.newtag').focus();
+                        });
+
+                        $('input.newtag', ajaxtag).blur(function() {
+                                if ( '' === this.value )
+                                        $(this).parent().siblings('.taghint').css('visibility', '');
+                        }).focus(function(){
+                                $(this).parent().siblings('.taghint').css('visibility', 'hidden');
+                        }).keyup(function(e){
+                                if ( 13 == e.which ) {
+                                        tagBox.flushTags( $(this).closest('.tagsdiv') );
+                                        return false;
+                                }
+                        }).keypress(function(e){
+                                if ( 13 == e.which ) {
+                                        e.preventDefault();
+                                        return false;
+                                }
+                        }).each(function(){
+                                var tax = $(this).closest('div.tagsdiv').attr('id');
+                                $(this).suggest( ajaxurl + '?action=ajax-tag-search&tax=' + tax, { delay: 500, minchars: 2, multiple: true, multipleSep: tagvars.comma + ' ' } );
+                        });
+
+                        // save tags on group save
+                        $('#post, #group-settings-form, #create-group-form').submit(function(){
+                                $('div.tagsdiv').each( function() {
+                                        tagBox.flushTags(this, false, 1);
+                                });
+                        });
+
+                        // tag cloud
+                        $('a.tagcloud-link').click(function(){
+                                tagBox.get( $(this).attr('id') );
+                                $(this).unbind().click(function(){
+                                        $(this).siblings('.the-tagcloud').toggle();
+                                        return false;
+                                });
+                                return false;
+                        });
+                }
+        };
+
+        if ( $( '#tagsdiv-bp_group_tags' ).length ) {
+                tagBox.init();
+        } else {
+                $('#side-sortables, #normal-sortables, #advanced-sortables').children('div.postbox').each(function(){
+                        if ( this.id.indexOf('tagsdiv-') === 0 ) {
+                                tagBox.init();
+                                return false;
+                        }
+                });
+        }
+
+}(jQuery));

src/bp-groups/admin/css/admin.css

@@ -1 @@
-body.toplevel_page_bp-groups table.groups th#status,
-body.toplevel_page_bp-groups table.groups th#members {
+#bp-groups-form #status,
+#bp-groups-form #members {
         width: 10%;
 }
-
-body.toplevel_page_bp-groups table.groups th#last_active {
+#bp-groups-form #last_active,
+#bp-groups-form #tag {
         width: 15%;
 }
 

src/bp-groups/admin/js/admin.js

@@ -1 +1 @@
 /* global BP_Group_Admin, group_id, isRtl */
 
 (function($) {
+
+        if ( $( 'body.groups_page_bp-group-tags' ).length ) {
+
+                if ( $( '#edittag' ).length ) {
+                        $( '#edittag' ).prop( 'action', BP_Group_Admin.edit_action );
+                }
+
+                if ( $( '#addtag' ).length ) {
+                        $( '#addtag' ).prop( 'action', BP_Group_Admin.edit_action );
+                        $( '#addtag input[name="screen"]' ).prop( 'value', BP_Group_Admin.ajax_screen );
+                }
+
+                if ( $( '.search-form' ).length ) {
+                        $( '.search-form' ).append( '<input type="hidden" name="page" value="' + BP_Group_Admin.search_page + '"/>' );
+                }
+
+                return;
+        }
+
         function add_member_to_list( e, ui ) {
                 $('#bp-groups-new-members-list').append('<li data-login="' + ui.item.value + '"><a href="#" class="bp-groups-remove-new-member">x</a> ' + ui.item.label + '</li>');
         }

src/bp-groups/bp-groups-actions.php

@@ -162 +162 @@
 
                         $new_group_id = isset( $bp->groups->new_group_id ) ? $bp->groups->new_group_id : 0;
 
-                        if ( !$bp->groups->new_group_id = groups_create_group( array( 'group_id' => $new_group_id, 'name' => $_POST['group-name'], 'description' => $_POST['group-desc'], 'slug' => groups_check_slug( sanitize_title( esc_attr( $_POST['group-name'] ) ) ), 'date_created' => bp_core_current_time(), 'status' => 'public' ) ) ) {
+                        if ( ! $bp->groups->new_group_id = groups_create_group( array( 'group_id' => $new_group_id, 'name' => $_POST['group-name'], 'description' => $_POST['group-desc'], 'slug' => groups_check_slug( sanitize_title( esc_attr( $_POST['group-name'] ) ) ), 'date_created' => bp_core_current_time(), 'status' => 'public' ) ) ) {
                                 bp_core_add_message( __( 'There was an error saving group details, please try again.', 'buddypress' ), 'error' );
                                 bp_core_redirect( bp_get_root_domain() . '/' . bp_get_groups_root_slug() . '/create/step/' . bp_get_groups_current_create_step() . '/' );
+                        } else {
+                                if ( ! empty( $_POST['tax_input'] ) ) {
+                                        bp_groups_set_taxonomy( $_POST['tax_input'], $bp->groups->new_group_id );
+                                }
                         }
                 }
 
@@ -482 +486 @@
         ) );
 }
 add_action( 'bp_actions', 'groups_action_group_feed' );
+
+/**
+ * Load the JS for the tagbox.
+ *
+ * @since BuddyPress (?)
+ */
+function bp_groups_tagbox_js() {
+        if ( is_multisite() && ! bp_is_root_blog() ) {
+                return false;
+        }
+
+        if ( ! ( bp_is_group_create() && 'group-details' == bp_get_groups_current_create_step() ) && ! ( bp_is_group_admin_page() && 'edit-details' == bp_get_group_current_admin_tab() && bp_is_item_admin() ) ) {
+                return false;
+        }
+
+        $bp = buddypress();
+
+        // Decide whether to load the dev version of the CSS and JavaScript
+        $min = defined( 'SCRIPT_DEBUG' ) && SCRIPT_DEBUG ? '' : 'min.';
+
+        wp_enqueue_style( 'bp-tagbox-css', $bp->plugin_url . "bp-core/css/tagbox.{$min}css", array(), bp_get_version() );
+        wp_enqueue_script( 'bp-tagbox-js', $bp->plugin_url . "bp-core/js/tagbox.{$min}js", array( 'suggest', 'wp-ajax-response' ), bp_get_version(), true  );
+
+        wp_localize_script( 'bp-tagbox-js', 'tagvars', array(
+                'comma' => _x( ',', 'tag delimiter', 'buddypress' ),
+        ) );
+}
+add_action( 'bp_enqueue_scripts', 'bp_groups_tagbox_js' );
+
+/**
+ * Set the groups current tag.
+ *
+ * @since BuddyPress (?)
+ */
+function bp_groups_directory_set_current_tag() {
+        $bp = buddypress();
+
+        if ( bp_is_groups_component() && empty( $bp->groups->current_group ) && bp_is_current_action( bp_get_groups_tag_slug() ) ) {
+                $bp->groups->tag = bp_core_get_term_by( 'slug', bp_action_variable( 0 ), 'bp_group_tags' );
+        }
+}
+add_action( 'bp_init', 'bp_groups_directory_set_current_tag', 10 );

src/bp-groups/bp-groups-admin.php

@@ -25 +25 @@
  *
  * @since BuddyPress (1.7.0)
  */
-function bp_groups_add_admin_menu() {
+  function bp_groups_add_admin_menu() {
 
-        // Add our screen
-        $hook = add_menu_page(
-                _x( 'Groups', 'Admin Groups page title', 'buddypress' ),
-                _x( 'Groups', 'Admin Groups menu', 'buddypress' ),
+        // Add our screen
+        $hooks['admin_load'] = add_menu_page(
+                __( 'Groups', 'buddypress' ),
+                __( 'Groups', 'buddypress' ),
                 'bp_moderate',
                 'bp-groups',
                 'bp_groups_admin',
                 'div'
         );
 
-        // Hook into early actions to load custom CSS and our init handler.
-        add_action( "load-$hook", 'bp_groups_admin_load' );
+        $hooks['admin_tags_load'] = add_submenu_page(
+                'bp-groups',
+                __( 'Group Tags', 'buddypress' ),
+                __( 'Group Tags', 'buddypress' ),
+                'bp_moderate',
+                'bp-group-tags',
+                'bp_groups_admin_tags'
+        );
+
+        foreach( $hooks as $key => $hook ) {
+                if ( 'admin_tags_load' == $key ) {
+                        buddypress()->groups->tags_action_screen = is_network_admin() ? $hook . '-network' : $hook ;
+                }
+
+                // Hook into early actions to load custom CSS and our init handler.
+                add_action( "load-$hook", "bp_groups_$key" );
+        }
 }
 add_action( bp_core_admin_hook(), 'bp_groups_add_admin_menu' );
 
@@ -126 +141 @@
                 add_meta_box( 'bp_group_add_members', _x( 'Add New Members', 'group admin edit screen', 'buddypress' ), 'bp_groups_admin_edit_metabox_add_new_members', get_current_screen()->id, 'normal', 'core' );
                 add_meta_box( 'bp_group_members', _x( 'Manage Members', 'group admin edit screen', 'buddypress' ), 'bp_groups_admin_edit_metabox_members', get_current_screen()->id, 'normal', 'core' );
 
+                // Group tags metabox
+                $taxonomy = get_taxonomy( 'bp_group_tags' );
+                // meta_box_cb argument of register_taxonomy was introduced in WordPress 3.8
+                if ( 'bp_group_tags' == $taxonomy->name && ( empty( $taxonomy->meta_box_cb ) || 'bp_tags_meta_box' != $taxonomy->meta_box_cb ) ) {
+                        $taxonomy->meta_box_cb = 'bp_tags_meta_box';
+                }
+
+                $tax_meta_box_id = 'tagsdiv-' . $taxonomy->name;
+                add_meta_box( $tax_meta_box_id, $taxonomy->labels->name, $taxonomy->meta_box_cb, get_current_screen()->id, 'side', 'core', array( 'taxonomy' => $taxonomy->name ) );
+                wp_enqueue_script( 'bp-tagbox-js', buddypress()->plugin_url . "bp-core/js/tagbox.{$min}js", array( 'suggest', 'wp-ajax-response' ), bp_get_version(), true  );
+                wp_localize_script( 'bp-tagbox-js', 'tagvars', array(
+                        'comma' => _x( ',', 'tag delimiter', 'buddypress' ),
+                ) );
+
                 do_action( 'bp_groups_admin_meta_boxes' );
 
                 // Enqueue javascripts
@@ -338 +367 @@
                         }
                 }
 
+                // Set group tags
+                if ( ! empty( $_POST['tax_input'] ) ) {
+                        bp_groups_set_taxonomy( $_POST['tax_input'], $group_id );
+                }
+
                 // Call actions for plugins to do something before we redirect
                 do_action( 'bp_group_admin_edit_after', $group_id );
 
@@ -1306 +1340 @@
                         'comment'     => _x( 'Name', 'Groups admin Group Name column header',               'buddypress' ),
                         'description' => _x( 'Description', 'Groups admin Group Description column header', 'buddypress' ),
                         'status'      => _x( 'Status', 'Groups admin Privacy Status column header',         'buddypress' ),
+                        'tag'         => _x( 'Tags', 'Groups admin Tags column header',                     'buddypress' ),
                         'members'     => _x( '# Members', 'Groups admin Members column header',             'buddypress' ),
                         'last_active' => _x( 'Last Active', 'Groups admin Last Active column header',       'buddypress' )
                 ) );
@@ -1467 +1502 @@
         }
 
         /**
+         * Markup for the Tags column.
+         *
+         * @since BuddyPress (?)
+         *
+         * @param array Information about the current row.
+         */
+        public function column_tag( $item = array() ) {
+                $tags = bp_core_get_the_term_list( $item['id'], 'bp_group_tags', '', ', ', '' );
+
+                if ( $tags ) {
+                        echo $tags;
+                } else {
+                        echo '&#8212';
+                }
+        }
+
+        /**
          * Markup for the Number of Members column.
          *
          * @since BuddyPress (1.7.0)
@@ -1502 +1554 @@
                 return apply_filters( 'bp_groups_admin_get_group_custom_column', '', $column_name, $item );
         }
 }
+
+/** Group Tags Admin screen ***************************************************/
+
+/**
+ * Register a fake post type for the groups component
+ * 
+ * @since BuddyPress (?)
+ * 
+ * @global $wp_post_types the list of available post types
+ */
+function bp_groups_admin_tags_register_post_type() {
+        global $wp_post_types;
+
+        // Since our post type doesn't really exist, we need to fool WP into thinking
+        // it really exists to avoid notices. So the following is a little tomfoolery!
+        $faux_post_type = 'bp_group';
+
+        // Set needed properties
+        $wp_post_types[$faux_post_type]               = new stdClass;
+        $wp_post_types[$faux_post_type]->show_ui      = false;
+        $wp_post_types[$faux_post_type]->labels       = new stdClass;
+        $wp_post_types[$faux_post_type]->labels->name = __( 'Groups', 'buddypress' );
+        $wp_post_types[$faux_post_type]->name         = $faux_post_type;
+}
+add_action( 'bp_admin_init', 'bp_groups_admin_tags_register_post_type' );
+
+/**
+ * Make sure the BP Group Tags Screen includes the post type and taxonomy properties
+ *
+ * @since BuddyPress (?)
+ *
+ * @param WP_Screen $current_screen
+ * @uses  buddypress()
+ */
+function bp_groups_admin_tags_set_current_screen( $current_screen = OBJECT ) {
+        $bp = buddypress();
+
+        if ( empty( $bp->groups->tags_action_screen ) || $bp->groups->tags_action_screen != $current_screen->id ) {
+                return;
+        }
+
+        $current_screen->post_type = 'bp_group';
+        $current_screen->taxonomy  = 'bp_group_tags';
+}
+add_action( 'current_screen', 'bp_groups_admin_tags_set_current_screen' );
+
+/**
+ * Set up the Group Tags admin page.
+ * 
+ * On multisite configs, the edit-tags.php page does not exist
+ * This function will include it to output the Group tags management forms
+ * But we still need to deal with actions before including this file. Some
+ * of this works thanks to the javascript part.
+ *
+ * @since BuddyPress (?)
+ *
+ * @uses bp_current_user_can()
+ * @uses add_query_arg()
+ * @uses bp_get_admin_url()
+ * @uses bp_admin_list_table_current_bulk_action() to get the current action
+ * @uses get_taxonomy() to get the group tags taxonomy
+ * @uses check_admin_referer()
+ * @uses bp_core_insert_term()
+ * @uses wp_redirect()
+ * @uses wp_parse_id_list()
+ * @uses bp_core_delete_term()
+ * @uses wp_enqueue_script()
+ * @uses wp_localize_script()
+ * @uses bp_core_get_term()
+ * @uses bp_core_update_term()
+ */
+function bp_groups_admin_tags_load() {
+        $cheating = __( 'Cheatin’ uh?', 'buddypress' );
+
+        if ( ! bp_current_user_can( 'bp_moderate' ) ) {
+                wp_die( $cheating );
+        }
+
+        $post_type = 'bp_group';
+        $taxnow    = $taxonomy = 'bp_group_tags';
+
+        // Decide whether to load the dev version of the CSS and JavaScript
+        $min = defined( 'SCRIPT_DEBUG' ) && SCRIPT_DEBUG ? '' : 'min.';
+        $redirect_to = add_query_arg( 'page', 'bp-group-tags', bp_get_admin_url( 'admin.php' ) );
+
+        // Filter the updated messages
+        add_filter( 'term_updated_messages', 'bp_groups_admin_updated_message', 10, 1 );
+
+        $doaction = bp_admin_list_table_current_bulk_action();
+
+        /**
+         * Eventually deal with actions before including the edit-tags.php file
+         */
+        if ( ! empty( $doaction ) ) {
+                $bp_group_tags_tax = get_taxonomy( $taxonomy );
+
+                if ( ! $bp_group_tags_tax ) {
+                        wp_die( __( 'Invalid taxonomy', 'buddypress' ) );
+                }
+
+                switch ( $doaction ) {
+                        case 'add-tag':
+
+                                check_admin_referer( 'add-tag', '_wpnonce_add-tag' );
+
+                                if ( ! bp_current_user_can( $bp_group_tags_tax->cap->edit_terms ) ) {
+                                        wp_die( $cheating );
+                                }
+
+                                $inserted = bp_core_insert_term( $_POST['tag-name'], $bp_group_tags_tax->name, $_POST );
+
+                                if ( ! empty( $inserted ) && ! is_wp_error( $inserted ) ){
+                                        $redirect_to = add_query_arg( 'message', 1, $redirect_to );
+                                } else {
+                                        $redirect_to = add_query_arg( 'message', 4, $redirect_to );
+                                }
+                                wp_redirect( $redirect_to );
+                        exit;
+
+                        case 'delete':
+                        case 'bulk-delete':
+                                $tag_IDs = array();
+                                $query_args = array();
+
+                                if ( empty( $_REQUEST['tag_ID'] ) && empty( $_REQUEST['delete_tags'] ) ) {
+                                        wp_redirect( $redirect_to );
+                                        exit;
+                                } else if ( ! empty( $_REQUEST['tag_ID'] ) ) {
+                                        $tag_ID = absint( $_REQUEST['tag_ID'] );
+                                        check_admin_referer( 'delete-tag_' . $tag_ID );
+                                        $tag_IDs = array( $tag_ID );
+                                        $query_args['message'] = 2;
+                                } else {
+                                        check_admin_referer( 'bulk-tags' );
+                                        $tag_IDs = wp_parse_id_list( $_REQUEST['delete_tags'] );
+                                        $query_args['message'] = 6;
+                                }
+
+                                if ( ! bp_current_user_can( $bp_group_tags_tax->cap->delete_terms ) ) {
+                                        wp_die( $cheating );
+                                }
+
+                                foreach ( $tag_IDs as $tag_ID ) {
+                                        bp_core_delete_term( $tag_ID, $bp_group_tags_tax->name );
+                                }
+
+                                $redirect_to = add_query_arg( $query_args, $redirect_to );
+                                wp_redirect( $redirect_to );
+                        exit;
+
+                        case 'edit':
+                                // We need to reset the action of the edit form
+                                wp_enqueue_script( 'bp_groups_admin_tags_js', buddypress()->plugin_url . "bp-groups/admin/js/admin.{$min}js", array( 'jquery' ), bp_get_version(), true );
+                                wp_localize_script( 'bp_groups_admin_tags_js', 'BP_Group_Admin', array(
+                                        'edit_action' => $redirect_to,
+                                ) );
+                                break;
+
+                        case 'editedtag':
+                                $tag_ID = (int) $_POST['tag_ID'];
+                                check_admin_referer( 'update-tag_' . $tag_ID );
+
+                                if ( ! bp_current_user_can( $bp_group_tags_tax->cap->edit_terms ) )
+                                        wp_die( $cheating );
+
+                                $tag = bp_core_get_term( $tag_ID, $bp_group_tags_tax->name );
+                                if ( ! $tag ) {
+                                        wp_die( __( 'You attempted to edit an item that doesn’t exist. Perhaps it was deleted?', 'buddypress' ) );
+                                }
+
+                                $ret = bp_core_update_term( $tag_ID, $bp_group_tags_tax->name, $_POST );
+
+                                if ( ! empty( $ret ) && ! is_wp_error( $ret ) ) {
+                                        $redirect_to = add_query_arg( 'message', 3, $redirect_to );
+                                } else {
+                                        $redirect_to = add_query_arg( 'message', 5, $redirect_to );
+                                }
+
+                                wp_redirect( $redirect_to );
+                        exit;
+                }
+
+        /**
+         * Make sure to "javascript change" some form attributes
+         * in edit-tags.php
+         */
+        } else {
+                wp_enqueue_script( 'bp_groups_admin_tags_js', buddypress()->plugin_url . "bp-groups/admin/js/admin.{$min}js", array( 'jquery' ), bp_get_version(), true );
+                wp_localize_script( 'bp_groups_admin_tags_js', 'BP_Group_Admin', array(
+                        'edit_action' => $redirect_to,
+                        'ajax_screen' => 'edit-' . $taxonomy,
+                        'search_page' => 'bp-group-tags',
+                ) );
+        }
+
+
+        require_once( ABSPATH . 'wp-admin/edit-tags.php' );
+        exit();
+}
+
+/**
+ * Make sure to display nothing on the group tags page
+ * as edit-tags.php will be loaded.
+ *
+ * @since BuddyPress (?)
+ */
+function bp_groups_admin_tags() {}

src/bp-groups/bp-groups-classes.php

@@ -678 +678 @@
                         'user_id'           => 0,
                         'search_terms'      => false,
                         'meta_query'        => false,
+                        'tax_query'         => false,
                         'include'           => false,
                         'populate_extras'   => true,
                         'update_meta_cache' => true,
@@ -724 +725 @@
                         $sql['meta'] = $meta_query_sql['where'];
                 }
 
+                /** Tax Query ************************************************/
+                $tax_query_sql = self::get_tax_query_sql( $r['tax_query'] );
+
+                if ( ! empty( $tax_query_sql['join'] ) ) {
+                        $sql['from'] .= $tax_query_sql['join'];
+                }
+
+                if ( ! empty( $tax_query_sql['where'] ) ) {
+                        $sql['tax'] = $tax_query_sql['where'];
+                }
+
                 if ( ! empty( $r['user_id'] ) ) {
                         $sql['user'] = $wpdb->prepare( " AND m.user_id = %d AND m.is_confirmed = 1 AND m.is_banned = 0", $r['user_id'] );
                 }
@@ -810 +822 @@
                         $total_sql['where'][] = $meta_query_clause;
                 }
 
+                if ( ! empty( $tax_query_sql['where'] ) ) {
+                        // Join the taxonomy table
+                        $total_sql['select'] .= ", ". substr( $tax_query_sql['join'], 0, -2 );
+
+                        // Modify the tax_query clause from paged_sql for our syntax
+                        $tax_query_clause = preg_replace( '/^\s*AND/', '', $tax_query_sql['where'] );
+                        $total_sql['where'][] = $tax_query_clause;
+                }
+
                 // Already escaped in the paginated results block
                 if ( ! empty( $include ) ) {
                         $total_sql['where'][] = "g.id IN ({$include})";
@@ -908 +929 @@
         }
 
         /**
+         * Get the SQL for the 'tax_query' param in BP_Groups_Group::get()
+         *
+         * We use WP_Tax_Query to do the heavy lifting of parsing the
+         * meta_query array and creating the necessary SQL clauses. However,
+         * since BP_Groups_Group::get() builds its SQL differently than
+         * WP_Query, we have to alter the return value
+         *
+         * @since BuddyPress (?)
+         * @access protected
+         *
+         * @param array $tax_query An array of tax_query filters. See the
+         *        documentation for {@link WP_Tax_Query} for details.
+         * @return array $sql_array 'join' and 'where' clauses.
+         */
+        protected static function get_tax_query_sql( $tax_query = array() ) {
+                $sql_array = array(
+                        'join'  => '',
+                        'where' => '',
+                );
+
+                if ( empty( $tax_query ) ) {
+                        return $sql_array;
+                }
+
+                $clauses = bp_core_get_tax_sql( $tax_query, 'g', 'id' );
+
+                /**
+                 * BP_Groups_Group::get() uses the comma syntax for table joins
+                 * meaning we need to do some parsing to adjust..
+                 */
+                $inner_joins = explode( 'INNER JOIN', $clauses['join'] );
+
+                foreach( $inner_joins as $key => $part ) {
+                        preg_match( '/(.*) ON/', $part, $matches_a );
+                        if ( ! empty( $matches_a[1] ) ) {
+                                $sql_array['join'][] = $matches_a[1];
+                        }
+                        preg_match( '/ON \((.*)\)/', $part, $matches_b );
+                        if ( ! empty( $matches_b[1] ) ) {
+                                $sql_array['where'][] = $matches_b[1];
+                        }
+                }
+                $sql_array['where'] = array_merge( $sql_array['where'], array( str_replace( ' AND ', '', $clauses['where'] ) ) );
+
+                $sql_array['join']  = implode( ',', $sql_array['join'] ). ', ';
+                $sql_array['where'] = ' AND ' . implode( ' AND ', $sql_array['where'] );
+
+                return $sql_array;
+        }
+
+        /**
          * Convert the 'type' parameter to 'order' and 'orderby'.
          *
          * @since BuddyPress (1.8.0)

src/bp-groups/bp-groups-filters.php

@@ -233 +233 @@
         return apply_filters( 'groups_filter_bbpress_root_page_sql', 't.topic_id' );
 }
 add_filter( 'get_latest_topics_fields', 'groups_filter_forums_root_page_sql' );
+
+
+/** Group Tags filters ********************************************************/
+
+/**
+ * Allow Group Creators/ Admins to assign group tags.
+ *
+ * @since BuddyPress (?)
+ *
+ * @see WP_User::has_cap()
+ *
+ * @param array $caps The caps that WP associates with the given role.
+ * @param array $cap The cap being tested for in WP_User::has_cap().
+ * @param integer $user_id the current user id
+ * @param array $args Miscellaneous arguments passed to the user_has_cap filter.
+ * @return array $caps the needed cap
+ */
+function bp_groups_tags_cap( $caps = array(), $cap = '', $user_id = 0, $args = array() ) {
+
+        switch( $cap ) {
+                case 'assign_group_tags' :
+                        // Members in multisite have no roles
+                        if ( ( bp_is_group_create() && is_user_logged_in() ) || bp_is_item_admin() ) {
+                                $caps = array( 'exist' );
+                        }
+                        break;
+
+                case 'manage_group_tags' :
+                case 'edit_group_tags'   :
+                case 'delete_group_tags' :
+                        $caps = array( 'manage_options' );
+                        break;
+        }
+
+        return $caps;
+}
+add_filter( 'bp_map_meta_caps', 'bp_groups_tags_cap', 10, 4 );
+
+/**
+ * Count text callback for the "bp_group_tags" widget tag cloud
+ *
+ * @since BuddyPress (?)
+ *
+ * @param  array $args arguments passed to the wp_tag_cloud widget.
+ * @return array       same arguments with the callback if relevant
+ */
+function bp_groups_widget_tag_cloud_args( $args = array() ) {
+        if ( ! empty( $args['taxonomy'] ) && 'bp_group_tags' == $args['taxonomy'] ) {
+                $args['topic_count_text_callback'] = 'bp_groups_tag_cloud_count_text_callback';
+        }
+
+        return $args;
+}
+add_filter( 'widget_tag_cloud_args', 'bp_groups_widget_tag_cloud_args', 10, 1 );
+
+/**
+ * Override the edit link for the bp_group_tags taxo
+ *
+ * @since BuddyPress (?)
+ * 
+ * @param  string  $link        the term edit link
+ * @param  integer $term_id     the term ID
+ * @param  string  $taxonomy    the taxonomy name (eg: bp_group_tags)
+ * @param  string  $object_type
+ * @return string               the term edit link
+ */
+function bp_groups_admin_tags_edit_term_link( $link = '', $term_id = 0, $taxonomy = '', $object_type = '' ) {
+        if ( empty( $taxonomy ) || 'bp_group_tags' != $taxonomy ) {
+                return $link;
+        }
+
+        $query_args = array(
+                'page'   => 'bp-group-tags',
+                'action' => 'edit',
+                'tag_ID' => $term_id,
+        );
+
+        return add_query_arg( $query_args, bp_get_admin_url( 'admin.php' ) );
+
+}
+add_filter( 'get_edit_term_link', 'bp_groups_admin_tags_edit_term_link', 10, 4 );
+
+/**
+ * Override the delete link for the bp_group_tags taxonomy
+ *
+ * @since BuddyPress (?)
+ * 
+ * @param  array  $actions list of available row action
+ * @param  Object $tag     Term Object
+ * @return array           same list, making sure the delete action is edited if needed
+ */
+function bp_groups_admin_tags_row_action( $actions = array(), $tag = null ) {
+        if ( empty( $tag ) ) {
+                return $actions;
+        }
+
+        // Only the delete action is to edit.
+        $query_args = array(
+                'page'     => 'bp-group-tags',
+                'action'   => 'delete',
+                'tag_ID'   => $tag->term_id,
+                'taxonomy' => 'bp_group_tags'
+        );
+        $delete_link = add_query_arg( $query_args, bp_get_admin_url( 'admin.php' ) );
+        $actions['delete'] = "<a class='delete-tag' href='" . esc_url( wp_nonce_url( $delete_link, 'delete-tag_' . $tag->term_id ) ) . "'>" . esc_html( _x( 'Delete', 'Group Tags term delete link', 'buddypress' ) ) . "</a>";
+
+        return $actions;
+}
+add_filter( 'bp_group_tags_row_actions', 'bp_groups_admin_tags_row_action', 10, 2 );
+
+/**
+ * Register the Group tags updated messages
+ * 
+ * @since BuddyPress (?)
+ * 
+ * @param  array  $messages list of term updated messages
+ * @return array            same list including Group tags ones
+ */
+function bp_groups_admin_updated_message( $messages = array() ) {
+        $messages['bp_group_tags'] = array(
+                0 => '', // Unused. Messages start at index 1.
+                1 => __( 'Group Tag added.',       'buddypress' ),
+                2 => __( 'Group Tag deleted.',     'buddypress' ),
+                3 => __( 'Group Tag updated.',     'buddypress' ),
+                4 => __( 'Group Tag not added.',   'buddypress' ),
+                5 => __( 'Group Tag not updated.', 'buddypress' ),
+                6 => __( 'Group Tags deleted.',    'buddypress' ),
+        );
+
+        return $messages;
+}

src/bp-groups/bp-groups-functions.php

@@ -273 +273 @@
         // Remove all outstanding invites for this group
         groups_delete_all_group_invites( $group_id );
 
+        // Remove Group Tags relationships
+        bp_core_delete_object_term_relationships( $group_id, 'bp_group_tags' );
+
         do_action( 'groups_delete_group', $group_id );
 
         return true;
@@ -595 +598 @@
                 'exclude'           => false,    // Do not include these specific groups (group_ids)
                 'search_terms'      => false,    // Limit to groups that match these search terms
                 'meta_query'        => false,    // Filter by groupmeta. See WP_Meta_Query for syntax
+                'tax_query'         => false,
                 'show_hidden'       => false,    // Show hidden groups to non-admins
                 'per_page'          => 20,       // The number of results to return per page
                 'page'              => 1,        // The page to return if limiting per page
@@ -611 +615 @@
                 'exclude'           => $r['exclude'],
                 'search_terms'      => $r['search_terms'],
                 'meta_query'        => $r['meta_query'],
+                'tax_query'         => $r['tax_query'],
                 'show_hidden'       => $r['show_hidden'],
                 'per_page'          => $r['per_page'],
                 'page'              => $r['page'],
@@ -1456 +1461 @@
 add_action( 'wpmu_delete_user',  'groups_remove_data_for_user' );
 add_action( 'delete_user',       'groups_remove_data_for_user' );
 add_action( 'bp_make_spam_user', 'groups_remove_data_for_user' );
+
+/* Group Tags *****************************************************************/
+
+/**
+ * Set group tags
+ *
+ * @since BuddyPress (?)
+ *
+ * @param array $taxonomies
+ * @param integer $group_id
+ * @return true on success, false on failure
+ */
+function bp_groups_set_taxonomy( $taxonomies = array(), $group_id = 0 ) {
+        $retval = true;
+
+        if ( empty( $group_id ) ) {
+                return false;
+        }
+
+        foreach ( $taxonomies as $taxonomy => $tags ) {
+                $taxonomy_obj = get_taxonomy( $taxonomy );
+
+                if ( is_array( $tags ) ) {
+                        $tags = array_filter( $tags );
+                } else {
+                        $comma = _x( ',', 'tag delimiter', 'buddypress' );
+                        if ( ',' !== $comma ){
+                                $tags = str_replace( $comma, ',', $tags );
+                        }
+
+                        $tags = explode( ',', trim( $tags, " \n\t\r\0\x0B," ) );
+                }
+                if ( bp_current_user_can( $taxonomy_obj->cap->assign_terms ) ) {
+                        $result = bp_core_set_object_terms( $group_id, $tags, $taxonomy );
+
+                        if ( is_wp_error( $result ) ) {
+                                $retval = false;
+                        }
+                }
+        }
+
+        return $retval;
+}
+
+/**
+ * Set tag cloud count text callback
+ *
+ * @since BuddyPress (?)
+ *
+ * @param integer $count
+ * @return string the count text callback
+ */
+function bp_groups_tag_cloud_count_text_callback( $count = 0 ) {
+        return sprintf( _n( '%d Group', '%d Groups', $count, 'buddypress' ), $count );
+}
+
+/**
+ * Add 'Tags' tab to groups directory page when we're on a group tag page.
+ *
+ * @since BuddyPress (?)
+ */
+function bp_groups_tag_add_directory_tab() {
+        if ( ! bp_is_groups_tag() ) {
+                return;
+        }
+?>
+
+        <li id="groups-tag"><a href="<?php echo bp_get_groups_directory_permalink() . bp_get_groups_tag_slug() . '/' . urldecode( esc_attr( buddypress()->groups->tag->slug ) ) . '/'; ?>" ><?php _ex( 'Tags', 'Group directory tab', 'buddypress' ); ?></a></li>
+<?php
+}
+add_action( 'bp_groups_directory_group_filter', 'bp_groups_tag_add_directory_tab', 0 );
+
+/**
+ * Set group loop scope when on a group tag page.
+ *
+ * @since BuddyPress (?)
+ */
+function bp_groups_tag_set_scope() {
+        // group tag page
+        if ( bp_is_groups_tag() ) {
+
+                // set scope to tag
+                $_POST['cookie'] = 'bp-groups-scope%3Dtag%3B%20bp-groups-filter%3D-1';
+
+                // reset the scope to 'tag' so our 'Tags' tab is highlighted
+                @setcookie( 'bp-groups-scope', 'tag', 0, '/' );
+
+                // reset the dropdown menu to 'Everything'
+                @setcookie( 'bp-groups-filter', '-1', 0, '/' );
+
+
+        // group directory
+        } elseif ( bp_is_groups_directory() ) {
+                $scope = ! empty( $_COOKIE['bp-groups-scope'] ) ? $_COOKIE['bp-groups-scope'] : '';
+
+                // if we're on the group directory and we last-visited a tag page,
+                // let's reset the scope to 'all'
+                if ( $scope == 'tag' ) {
+                        @setcookie( 'bp-groups-scope', 'all', 0, '/' );
+                }
+        }
+}
+add_action( 'bp_screens', 'bp_groups_tag_set_scope', 9 );
+
+/**
+ * Set querystring when on a group tag page.
+ *
+ * @since BuddyPress (?)
+ */
+function bp_groups_tag_querystring( $retval ) {
+        if ( ! bp_is_groups_tag() ) {
+                return $retval;
+        }
+
+        $args = wp_parse_args( $retval );
+
+        if ( ! isset( $args['scope'] ) ) {
+                return $retval;
+        }
+
+        if ( 'tag' !== $args['scope'] ) {
+                return $retval;
+        }
+
+        $args['type'] = 'tag';
+        $args['slug'] = bp_action_variable( 0 );
+
+        return $args;
+}
+add_filter( 'bp_ajax_querystring', 'bp_groups_tag_querystring', 20 );
+
+/**
+ * Inject a header on the group directory page if we're on a tag page.
+ *
+ * @since BuddyPress (?)
+ */
+function bp_groups_tag_header() {
+        if ( ! bp_is_groups_tag() ) {
+                return;
+        }
+
+        if ( defined( 'DOING_AJAX' ) ) {
+                // grab the AJAX querystring
+                $qs = ! empty( $_POST['cookie'] ) ? urldecode( $_POST['cookie'] ) : '';
+
+                // not a tag page? stop now!
+                if ( strpos( $qs, 'bp-groups-scope=tag' ) === false ) {
+                        return;
+                }
+        }
+
+        printf( '<h3>' . __( 'Groups tagged: "%s"', 'buddypress' ) . '</h3>', buddypress()->groups->tag->name );
+
+        if ( ! empty( buddypress()->groups->tag->description ) ) {
+                echo '<p>' . esc_html( buddypress()->groups->tag->description ) . '</p>';
+        }
+
+}
+add_action( 'bp_before_groups_loop', 'bp_groups_tag_header' );
+
+/**
+ * Add "Group Tags" input field to group creation and group admin edit pages.
+ *
+ * @since BuddyPress (?)
+ *
+ * @see bp_groups_the_tagbox()
+ */
+function bp_groups_tag_add_field_to_frontend_group_admin() {
+        // prevent duplicate fields on group creation page
+        if ( bp_is_group_creation_step( 'group-details' ) && did_action( 'groups_custom_group_fields_editable' ) ) {
+                return;
+        }
+?>
+
+        <label for="new-tag-bp_group_tags"><?php _e( 'Group Tags', 'buddypress' ); ?></label>
+        <div id="tagsdiv-bp_group_tags" class="bp-tag-editor">
+                <?php bp_groups_the_tagbox();?>
+        </div>
+
+<?php
+}
+add_action( 'bp_after_group_details_creation_step', 'bp_groups_tag_add_field_to_frontend_group_admin', 1 );
+add_action( 'groups_custom_group_fields_editable',  'bp_groups_tag_add_field_to_frontend_group_admin', 1 );

src/bp-groups/bp-groups-loader.php

@@ -247 +247 @@
                         'members',
                         'settings',
                         'avatar',
+                        bp_get_groups_tag_slug(),
                         $this->slug,
                         $this->root_slug,
                 ) );
@@ -625 +626 @@
 
                 parent::setup_title();
         }
+
+        public function register_taxonomies( $taxonomy = '', $object_type = '', $args = array(), $network = false ) {
+                $labels = array(
+                        'name'                       => _x( 'Group Tags',                           'groups tag general name',  'buddypress' ),
+                        'singular_name'              => _x( 'Group Tag',                            'groups tag singular name', 'buddypress' ),
+                        'search_items'               => _x( 'Search Group Tags',                    'groups tag search',        'buddypress' ),
+                        'popular_items'              => _x( 'Popular Group Tags',                   'groups tag popular',       'buddypress' ),
+                        'all_items'                  => _x( 'All Group Tags',                       'groups tag all',           'buddypress' ),
+                        'parent_item'                => null,
+                        'parent_item_colon'          => null,
+                        'edit_item'                  => _x( 'Edit Group Tag',                       'groups tag edit',          'buddypress' ),
+                        'update_item'                => _x( 'Update Group Tag',                     'groups tag update',        'buddypress' ),
+                        'add_new_item'               => _x( 'Add New Group Tag',                    'groups tag add new',       'buddypress' ),
+                        'new_item_name'              => _x( 'New Group Tag Name',                   'groups tag new',           'buddypress' ),
+                        'separate_items_with_commas' => _x( 'Separate Group Tags with commas',      'groups tag comma',         'buddypress' ),
+                        'add_or_remove_items'        => _x( 'Add or remove Group Tags',             'groups tag add remove',    'buddypress' ),
+                        'choose_from_most_used'      => _x( 'Choose from the most used Group Tags', 'groups tag most used',     'buddypress' ),
+                        'not_found'                  => _x( 'No Group Tags found.',                 'groups tag not found',     'buddypress' ),
+                );
+
+                $args = array(
+                        'hierarchical'          => false,
+                        'labels'                => $labels,
+                        'show_ui'               => false,
+                        'show_admin_column'     => false,
+                        'query_var'             => false,
+                        'show_tagcloud'         => true,
+                        'rewrite'               => array(
+                                'slug' => bp_get_groups_root_slug() . '/' . bp_get_groups_tag_slug(),
+                                'with_front' => false
+                        ),
+                        'capabilities' => array(
+                                'manage_terms'  => 'manage_group_tags',
+                                'edit_terms'    => 'edit_group_tags',
+                                'delete_terms'  => 'delete_group_tags',
+                                'assign_terms'  => 'assign_group_tags'
+                        ),
+                        'update_count_callback' => 'bp_core_update_term_count',
+                        'meta_box_cb'           => 'bp_tags_meta_box'
+                );
+
+                parent::register_taxonomies( 'bp_group_tags', array( 'bp_group' ), $args, true );
+        }
 }
 
 /**

src/bp-groups/bp-groups-screens.php

@@ -595 +595 @@
 
                         $group_notify_members = isset( $_POST['group-notify-members'] ) ? (int) $_POST['group-notify-members'] : 0;
 
-                        if ( !groups_edit_base_group_details( $_POST['group-id'], $_POST['group-name'], $_POST['group-desc'], $group_notify_members ) ) {
+                        $error = false;
+
+                        if ( ! groups_edit_base_group_details( $_POST['group-id'], $_POST['group-name'], $_POST['group-desc'], $group_notify_members ) ) {
+                                $error = true;
+                        }
+
+                        if ( ! empty( $_POST['tax_input'] ) ) {
+                                if ( ! bp_groups_set_taxonomy( $_POST['tax_input'], $bp->groups->current_group->id ) ) {
+                                        $error = true;
+                                }
+                        }
+
+                        if ( ! empty( $error ) ) {
                                 bp_core_add_message( __( 'There was an error updating group details; please try again.', 'buddypress' ), 'error' );
                         } else {
                                 bp_core_add_message( __( 'Group details were successfully updated.', 'buddypress' ) );
@@ -1043 +1055 @@
                         return;
 
                 // Group Directory
-                if ( ! bp_current_action() && ! bp_current_item() ) {
+                if ( ( ! bp_current_action() && ! bp_current_item() ) || bp_is_groups_tag() ) {
                         bp_update_is_directory( true, 'groups' );
 
                         do_action( 'groups_directory_groups_setup' );

src/bp-groups/bp-groups-template.php

@@ -206 +206 @@
                 }
 
                 $defaults = array(
-                        'type'            => 'active',
-                        'page'            => 1,
-                        'per_page'        => 20,
-                        'max'             => false,
-                        'show_hidden'     => false,
-                        'page_arg'        => 'grpage',
-                        'user_id'         => 0,
-                        'slug'            => false,
-                        'include'         => false,
-                        'exclude'         => false,
-                        'search_terms'    => '',
-                        'meta_query'      => false,
-                        'populate_extras' => true,
+                        'type'              => 'active',
+                        'page'              => 1,
+                        'per_page'          => 20,
+                        'max'               => false,
+                        'show_hidden'       => false,
+                        'page_arg'          => 'grpage',
+                        'user_id'           => 0,
+                        'slug'              => false,
+                        'include'           => false,
+                        'exclude'           => false,
+                        'search_terms'      => '',
+                        'meta_query'        => false,
+                        'tax_query'         => false,
+                        'populate_extras'   => true,
                         'update_meta_cache' => true,
                 );
 
@@ -267 +268 @@
                                 'user_id'           => $user_id,
                                 'search_terms'      => $search_terms,
                                 'meta_query'        => $meta_query,
+                                'tax_query'         => $tax_query,
                                 'include'           => $include,
                                 'exclude'           => $exclude,
                                 'populate_extras'   => $populate_extras,
@@ -445 +447 @@
  *     @type array $meta_query Optional. An array of meta_query
  *           conditions. See {@link WP_Meta_Query::queries} for
  *           description.
+ *     @type array $tax_query Optional. An array of tax_query
+ *           conditions. See {@link WP_Tax_Query::queries} for
+ *           description.
  *     @type array|string Optional. Array or comma-separated list of
  *           group IDs. Results will be limited to groups within the
  *           list. Default: false.
@@ -508 +513 @@
                 'slug'              => $slug,
                 'search_terms'      => $search_terms,
                 'meta_query'        => false,
+                'tax_query'         => false,
                 'include'           => false,
                 'exclude'           => false,
                 'populate_extras'   => true,
                 'update_meta_cache' => true,
         ), 'has_groups' );
 
+        // Filter by group tag
+        // Pass 'type' as 'tag' and 'slug' with the tag's slug
+        if ( 'tag' === $r['type'] && ! empty( $r['slug'] ) ) {
+                $r['tax_query'] = array( array(
+                        'taxonomy' => 'bp_group_tags',
+                        'terms'    => $r['slug'],
+                        'field'    => 'slug',
+                ) );
+        }
+
         // Setup the Groups template global
         $groups_template = new BP_Groups_Template( array(
                 'type'              => $r['type'],
@@ -528 +544 @@
                 'slug'              => $r['slug'],
                 'search_terms'      => $r['search_terms'],
                 'meta_query'        => $r['meta_query'],
+                'tax_query'         => $r['tax_query'],
                 'include'           => $r['include'],
                 'exclude'           => $r['exclude'],
                 'populate_extras'   => (bool) $r['populate_extras'],
@@ -4126 +4143 @@
 function bp_group_has_membership_requests( $args = '' ) {
         global $requests_template;
 
+        $tax_query = array();
+        if ( bp_is_groups_tag() ) {
+                $tax_query = array(
+                        array(
+                                'taxonomy' => 'bp_group_tags',
+                                'terms'    => $bp->groups->tag->term_id,
+                                'field'    => 'term_id',
+                        )
+                );
+        }
+
         $defaults = array(
                 'group_id' => bp_get_current_group_id(),
                 'per_page' => 10,
@@ -4768 +4796 @@
         // Filter and return
         return apply_filters( 'bp_groups_get_profile_stats', $r['output'], $r );
 }
+
+/* Group Tags *****************************************************************/
+
+/**
+ * Output the groups component tag slug
+ *
+ * @package BuddyPress
+ * @subpackage Groups Template
+ * @since BuddyPress (?)
+ *
+ * @uses bp_get_groups_tag_slug()
+ */
+function bp_groups_tag_slug() {
+        echo bp_get_groups_tag_slug();
+}
+
+        /**
+         * Return the groups component tag slug
+         *
+         * @package BuddyPress
+         * @subpackage Groups Template
+         * @since BuddyPress (?)
+         */
+        function bp_get_groups_tag_slug() {
+                return apply_filters( 'bp_get_groups_tag_slug', 'tag' );
+        }
+
+/**
+ * Output the current group tagbox
+ *
+ * @since BuddyPress (?)
+ *
+ * @uses bp_get_groups_the_tagbox()
+ */
+function bp_groups_the_tagbox() {
+        echo bp_get_groups_the_tagbox();
+}
+        /**
+         * Return the current group tagbox
+         *
+         * @since BuddyPress (?)
+         */
+        function bp_get_groups_the_tagbox() {
+                $bp = buddypress();
+
+                $group = $bp->groups->current_group;
+
+                if ( empty( $group ) ) {
+                        $group = new stdClass;
+                        $group->id = 0;
+                }
+
+                $box = array(
+                        'taxonomy' => 'bp_group_tags',
+                        'title'    => __( 'Group Tags', 'buddypress' ),
+                );
+
+                require_once( ABSPATH . 'wp-admin/includes/taxonomy.php' );
+
+                ob_start();
+                bp_tags_meta_box( $group, $box );
+                $tagbox = ob_get_contents();
+                ob_end_clean();
+
+                return apply_filters( 'bp_get_groups_the_tagbox', '<div class="inside">' . $tagbox . '</div>' );
+        }
+
+/**
+ * Output group tags
+ *
+ * @since BuddyPress (?)
+ *
+ * @uses bp_get_groups_the_tags()
+ * @param int $group_id The group ID.
+ */
+function bp_groups_the_tags( $group_id = 0 ) {
+        echo bp_get_groups_the_tags( $group_id );
+}
+add_action( 'bp_directory_groups_item',    'bp_groups_the_tags' );
+add_action( 'bp_before_group_header_meta', 'bp_groups_the_tags' );
+
+        /**
+         * Return a comma-separated list of tags for a group.
+         *
+         * @since BuddyPress (?)
+         *
+         * @todo Perhaps add parameters for HTML markup?
+         *
+         * @param int $group_id The group ID.
+         * @return string|bool HTML markup of comma-separated tags; boolean false otherwise.
+         */
+        function bp_get_groups_the_tags( $group_id = 0 ) {
+                if ( empty( $group_id ) ) {
+                        $group_id = bp_get_group_id();
+                }
+
+                if ( empty( $group_id ) ) {
+                        return false;
+                }
+
+                $tag_list = bp_core_get_the_term_list( $group_id, 'bp_group_tags', '', ', ', '' );
+
+                if ( empty( $tag_list ) ) {
+                        return false;
+                }
+
+                $html  = '<div class="group-tags">';
+                $html .= '<span>' . esc_html_x( 'Tags:', 'Group tags prefix', 'buddypress' ) . ' </span>';
+                $html .= $tag_list;
+                $html .= '</div>';
+
+                return apply_filters( 'bp_get_groups_the_tags', $html, $group_id );
+        }

src/bp-templates/bp-legacy/buddypress/groups/index.php

@@ -31 +31 @@
                         <ul>
                                 <?php do_action( 'bp_groups_directory_group_types' ); ?>
 
-                                <li id="groups-order-select" class="last filter">
+                                <?php if ( ! bp_is_groups_tag() ) : ?>
 
-                                        <label for="groups-order-by"><?php _e( 'Order By:', 'buddypress' ); ?></label>
+                                        <li id="groups-order-select" class="last filter">
 
-                                        <select id="groups-order-by">
-                                                <option value="active"><?php _e( 'Last Active', 'buddypress' ); ?></option>
-                                                <option value="popular"><?php _e( 'Most Members', 'buddypress' ); ?></option>
-                                                <option value="newest"><?php _e( 'Newly Created', 'buddypress' ); ?></option>
-                                                <option value="alphabetical"><?php _e( 'Alphabetical', 'buddypress' ); ?></option>
+                                                <label for="groups-order-by"><?php _e( 'Order By:', 'buddypress' ); ?></label>
 
-                                                <?php do_action( 'bp_groups_directory_order_options' ); ?>
-                                        </select>
-                                </li>
+                                                <select id="groups-order-by">
+                                                        <option value="active"><?php _e( 'Last Active', 'buddypress' ); ?></option>
+                                                        <option value="popular"><?php _e( 'Most Members', 'buddypress' ); ?></option>
+                                                        <option value="newest"><?php _e( 'Newly Created', 'buddypress' ); ?></option>
+                                                        <option value="alphabetical"><?php _e( 'Alphabetical', 'buddypress' ); ?></option>
+
+                                                        <?php do_action( 'bp_groups_directory_order_options' ); ?>
+                                                </select>
+                                        </li>
+
+                                <?php endif ;?>
                         </ul>
                 </div>