Ticket #5130: 5130.01b.patch

bp-activity/bp-activity-functions.php

@@ -1201 +1201 @@
         // Clear the comment cache for this activity
         wp_cache_delete( 'bp_activity_comments_' . $parent_id );
 
-        do_action( 'bp_activity_comment_posted', $comment_id, $params );
+        do_action( 'bp_activity_comment_posted', $comment_id, $params, $activity );
 
         return $comment_id;
 }
@@ -1657 +1657 @@
         do_action( 'bp_activity_mark_as_ham', $activity, $source );
 }
 
-
 /** Embeds *******************************************************************/
 
 /**

bp-blogs/bp-blogs-activity.php

@@ -128 +128 @@
                 'secondary_item_id' => $secondary_item_id
         ) );
 }
+
+/**
+ * Syncs activity comments and posts them back as blog comments.
+ *
+ * Note: This is only a one-way sync - activity comments -> blog comment.
+ *
+ * For blog post -> activity comment, see {@link bp_blogs_record_comment()}.
+ *
+ * @since BuddyPress (1.9)
+ *
+ * @param int $comment_id The activity ID for the posted activity comment.
+ * @param array $params Parameters for the activity comment.
+ * @param obj Parameters of the parent activity item (in this case, the blog post).
+ */
+function bp_blogs_sync_add_from_activity_comment( $comment_id, $params, $parent_activity ) {
+        // if parent activity isn't a blog post, stop now!
+        if ( $parent_activity->type != 'new_blog_post' ) {
+                return;
+        }
+
+        // if activity comments are disabled for blog posts, stop now!
+        if ( bp_disable_blogforum_comments() ) {
+                return;
+        }
+
+        // get userdata
+        if ( $params['user_id'] == bp_loggedin_user_id() ) {
+                $user = buddypress()->loggedin_user->userdata;
+        } else {
+                $user = bp_core_get_core_userdata( $params['user_id'] );
+        }
+
+        // see if a parent WP comment ID exists
+        if ( ! empty( $params['parent_id'] ) ) {
+                $comment_parent = bp_activity_get_meta( $params['parent_id'], 'bp_blogs_post_comment_id' );
+        } else {
+                $comment_parent = 0;
+        }
+
+        // comment args
+        $args = array(
+                'comment_post_ID'      => $parent_activity->secondary_item_id,
+
+                // should this use display name?
+                // using username for now
+                'comment_author'       => bp_core_get_username( $params['user_id'], $user->user_nicename, $user->user_login ),
+
+                'comment_author_email' => $user->user_email,
+                'comment_author_url'   => bp_core_get_user_domain( $params['user_id'], $user->user_nicename, $user->user_login ),
+                'comment_content'      => $params['content'],
+                'comment_type'         => '', // could be interesting to add 'buddypress' here...
+                'comment_parent'       => (int) $comment_parent,
+                'user_id'              => $params['user_id'],
+
+                // commenting these out for now
+                //'comment_author_IP'    => '127.0.0.1',
+                //'comment_agent'        => '',
+
+                'comment_approved'     => 1
+        );
+
+        // prevent separate activity entry being made
+        remove_action( 'comment_post', 'bp_blogs_record_comment', 10, 2 );
+
+        // handle multisite
+        switch_to_blog( $parent_activity->item_id );
+
+        // handle timestamps for the WP comment after we've switched to the blog
+        $args['comment_date']     = current_time( 'mysql' );
+        $args['comment_date_gmt'] = current_time( 'mysql', 1 );
+
+        // post the comment
+        $post_comment_id = wp_insert_comment( $args );
+
+        // add meta to comment
+        add_comment_meta( $post_comment_id, 'bp_activity_comment_id', $comment_id );
+
+        // add meta to activity comment
+        bp_activity_update_meta( $comment_id, 'bp_blogs_post_comment_id', $post_comment_id );
+
+        // resave activity comment with WP comment permalink
+        //
+        // in bp_blogs_activity_comment_permalink(), we change activity comment
+        // permalinks to use the post comment link
+        //
+        // @todo since this is done after AJAX posting, the activity comment permalink
+        //       doesn't change on the frontend until the next page refresh.
+        $resave_activity = new BP_Activity_Activity( $comment_id );
+        $resave_activity->primary_link = get_comment_link( $post_comment_id );
+        $resave_activity->save();
+
+        // multisite again!
+        restore_current_blog();
+
+        // add the comment hook back
+        add_action( 'comment_post', 'bp_blogs_record_comment', 10, 2 );
+
+        do_action( 'bp_blogs_sync_add_from_activity_comment', $comment_id, $args, $parent_activity, $user );
+}
+
+/**
+ * Deletes the blog comment when the associated activity comment is deleted.
+ *
+ * @since BuddyPress (1.9)
+ *
+ * @param int $activity_id The activity ID for the posted activity comment.
+ * @param array $params Parameters for the activity comment.
+ * @param obj Parameters of the parent activity item (in this case, the blog post).
+ */
+function bp_blogs_sync_delete_from_activity_comment( $activity_id, $comment_id ) {
+        // query args
+        $query_args = array(
+                'meta_query' => array(
+                        array(
+                                'key'   => 'bp_activity_comment_id',
+                                'value' => $comment_id
+                        )
+                )
+        );
+
+        // get comment
+        $comment_query = new WP_Comment_Query;
+        $comment = $comment_query->query( $query_args );
+
+        // no comment? stop now!
+        if ( empty( $comment[0] ) ) {
+                return;
+        } else {
+                $comment = $comment[0];
+        }
+
+        // delete the comment
+        // we force delete the comment, since activity items are deleted immediately
+        wp_delete_comment( $comment->comment_ID, true );
+}
+
+/**
+ * Disable activity commenting for blog posts based on certain criteria.
+ *
+ * If activity commenting is enabled for blog posts, we still need to disable
+ * commenting if:
+ *  - comments are disabled for the WP blog post from the admin dashboard
+ *  - the WP blog post is supposed to be automatically closed from comments
+ *    based on a certain age
+ *  - the activity entry is a 'new_blog_comment' type
+ *
+ * @since BuddyPress (1.9)
+ *
+ * @param bool $retval Is activity commenting enabled for this activity entry?
+ * @return bool
+ */
+function bp_blogs_disable_activity_commenting( $retval ) {
+        // if activity commenting is disabled, return current value
+        if ( bp_disable_blogforum_comments() ) {
+                return $retval;
+        }
+
+        // activity commenting is enabled for blog posts
+        switch ( bp_get_activity_action_name() ) {
+
+                // we still have to disable activity commenting for 'new_blog_comment' items
+                // commenting should only be done on the parent 'new_blog_post' item
+                case 'new_blog_comment' :
+                        $retval = false;
+
+                        break;
+
+                // check if commenting is disabled for the WP blog post
+                // we should extrapolate this and automate this for plugins... or not
+                case 'new_blog_post' :
+
+                        // BP's 'comments_open' filter trumps all!
+                        // so we have to remove it temporarily
+                        remove_filter( 'comments_open', 'bp_comments_open', 10, 2 );
+
+                        switch_to_blog( bp_get_activity_item_id() );
+
+                        // check if the WP post allows comments
+                        // this also checks if comments should be closed based on age if enabled
+                        $allow_comments = comments_open( bp_get_activity_secondary_item_id() );
+
+                        restore_current_blog();
+
+                        // reinstate BP's comment filter
+                        add_filter( 'comments_open', 'bp_comments_open', 10, 2 );
+
+                        // if comments are closed for the WP blog post, we should disable
+                        // activity comments for this activity entry
+                        if ( ! $allow_comments ) {
+                                $retval = false;
+                        }
+
+                        // initialize a local object so we don't have to query this again
+                        if ( empty( buddypress()->activity->new_blog_post ) ) {
+                                buddypress()->activity->new_blog_post  = new stdClass;
+                                buddypress()->activity->new_blog_post->allow_comments = array();
+                        }
+
+                        // cache comment setting in the buddypress() singleton for later reference
+                        // @see bp_blogs_disable_activity_replies()
+                        buddypress()->activity->new_blog_post->allow_comments[bp_get_activity_id()] = $allow_comments;
+
+                        break;
+        }
+
+        return $retval;
+}
+add_filter( 'bp_activity_can_comment', 'bp_blogs_disable_activity_commenting' );
+
+/**
+ * Disables replying to activity comments if the corresponding WP blog post no
+ * longer accepts comments.
+ *
+ * This check uses a locally-cached value set in {@link bp_blogs_disable_activity_commenting()}.
+ *
+ * @since BuddyPress (1.9)
+ *
+ * @param bool $retval Are replies allowed for this activity reply?
+ * @param obj $comment The activity comment object
+ * @return bool
+ */
+function bp_blogs_disable_activity_replies( $retval, $comment ) {
+        // check if we should disable activity replies based on the parent activity
+        if ( isset( buddypress()->activity->new_blog_post->allow_comments[$comment->item_id] ) ){
+                // the blog post has closed off commenting, so we should disable all activity
+                // comments under the parent 'new_blog_post' activity entry
+                if ( empty( buddypress()->activity->new_blog_post->allow_comments[$comment->item_id] ) ) {
+                        $retval = false;
+                }
+        }
+
+        return $retval;
+}
+add_filter( 'bp_activity_can_comment_reply', 'bp_blogs_disable_activity_replies', 10, 2 );
+
+/**
+ * Changes activity comment permalinks to use the blog comment permalink
+ * instead of the activity permalink.
+ *
+ * This is only done if activity commenting is allowed and whether the parent
+ * activity item is a 'new_blog_post' entry.
+ *
+ * @since BuddyPress (1.9)
+ *
+ * @param str $retval The activity comment permalink
+ * @return str
+ */
+function bp_blogs_activity_comment_permalink( $retval ) {
+        global $activities_template;
+
+        if ( isset( buddypress()->activity->new_blog_post->allow_comments[$activities_template->activity->current_comment->item_id] ) ){
+                $retval = $activities_template->activity->current_comment->primary_link;
+        }
+
+        return $retval;
+}
+add_filter( 'bp_get_activity_comment_permalink', 'bp_blogs_activity_comment_permalink' );

bp-blogs/bp-blogs-functions.php

@@ -362 +362 @@
                 $post_permalink = get_permalink( $recorded_comment->comment_post_ID );
                 $comment_link   = get_comment_link( $recorded_comment->comment_ID );
 
-                // Prepare to record in activity streams
-                if ( is_multisite() )
-                        $activity_action = sprintf( __( '%1$s commented on the post, %2$s, on the site %3$s', 'buddypress' ), bp_core_get_userlink( $user_id ), '<a href="' . $post_permalink . '">' . apply_filters( 'the_title', $recorded_comment->post->post_title ) . '</a>', '<a href="' . get_blog_option( $blog_id, 'home' ) . '">' . get_blog_option( $blog_id, 'blogname' ) . '</a>' );
-                else
-                        $activity_action = sprintf( __( '%1$s commented on the post, %2$s', 'buddypress' ), bp_core_get_userlink( $user_id ), '<a href="' . $post_permalink . '">' . apply_filters( 'the_title', $recorded_comment->post->post_title ) . '</a>' );
+                // Setup activity args
+                $args = array();
+
+                $args['user_id']       = $user_id;
+                $args['content']       = apply_filters_ref_array( 'bp_blogs_activity_new_comment_content', array( $recorded_comment->comment_content, &$recorded_comment, $comment_link ) );
+                $args['primary_link']  = apply_filters_ref_array( 'bp_blogs_activity_new_comment_primary_link', array( $comment_link,     &$recorded_comment ) );
+                $args['recorded_time'] = $recorded_comment->comment_date_gmt;
+
+                if ( is_multisite() ) {
+                        $args['action'] = sprintf( __( '%1$s commented on the post, %2$s, on the site %3$s', 'buddypress' ), bp_core_get_userlink( $user_id ), '<a href="' . $post_permalink . '">' . apply_filters( 'the_title', $recorded_comment->post->post_title ) . '</a>', '<a href="' . get_blog_option( $blog_id, 'home' ) . '">' . get_blog_option( $blog_id, 'blogname' ) . '</a>' );
+                } else {
+                        $args['action'] = sprintf( __( '%1$s commented on the post, %2$s', 'buddypress' ), bp_core_get_userlink( $user_id ), '<a href="' . $post_permalink . '">' . apply_filters( 'the_title', $recorded_comment->post->post_title ) . '</a>' );
+                }
 
-                $activity_content       = $recorded_comment->comment_content;
+                // Setup some different activity args depending if activity commenting is
+                // enabled or not
+
+                // if cannot comment, record separate activity entry
+                // this is the old way of doing things
+                if ( bp_disable_blogforum_comments() ) {
+                        $args['type']              = 'new_blog_comment';
+                        $args['item_id']           = $blog_id;
+                        $args['secondary_item_id'] = $comment_id;
+
+                        // record the activity entry
+                        bp_blogs_record_activity( $args );
+
+                // record comment as BP activity comment under the parent 'new_blog_post'
+                // activity item
+                } else {
+                        // find the parent 'new_blog_post' activity entry
+                        $parent_activity_id = bp_activity_get_activity_id( array(
+                                'user_id'           => $user_id,
+                                'component'         => 'blogs',
+                                'type'              => 'new_blog_post',
+                                'item_id'           => $blog_id,
+                                'secondary_item_id' => $recorded_comment->comment_post_ID
+                        ) );
+
+                        // we found the parent activity entry
+                        // so let's go ahead and reconfigure some activity args
+                        if ( ! empty( $parent_activity_id ) ) {
+                                // set the 'item_id' with the parent activity entry ID
+                                $args['item_id'] = $parent_activity_id;
+
+                                // now see if the WP parent comment has a BP activity ID
+                                $comment_parent = 0;
+                                if ( ! empty( $recorded_comment->comment_parent ) ) {
+                                        $comment_parent = get_comment_meta( $recorded_comment->comment_parent, 'bp_activity_comment_id', true );
+                                }
 
-                // Record in activity streams
-                bp_blogs_record_activity( array(
-                        'user_id'           => $user_id,
-                        'action'            => apply_filters_ref_array( 'bp_blogs_activity_new_comment_action',       array( $activity_action,  &$recorded_comment, $comment_link ) ),
-                        'content'           => apply_filters_ref_array( 'bp_blogs_activity_new_comment_content',      array( $activity_content, &$recorded_comment, $comment_link ) ),
-                        'primary_link'      => apply_filters_ref_array( 'bp_blogs_activity_new_comment_primary_link', array( $comment_link,     &$recorded_comment                ) ),
-                        'type'              => 'new_blog_comment',
-                        'item_id'           => $blog_id,
-                        'secondary_item_id' => $comment_id,
-                        'recorded_time'     => $recorded_comment->comment_date_gmt
-                ) );
+                                // WP parent comment does not have a BP activity ID
+                                // so set to 'new_blog_post' activity ID
+                                if ( empty( $comment_parent ) ) {
+                                        $comment_parent = $parent_activity_id;
+                                }
+
+                                $args['secondary_item_id'] = $comment_parent;
+                                $args['component']         = 'activity';
+                                $args['type']              = 'activity_comment';
+
+                        // could not find corresponding parent activity entry
+                        // so wipe out $args array
+                        } else {
+                                $args = array();
+                        }
+
+                        // Record in activity streams
+                        if ( ! empty( $args ) ) {
+                                // @todo should we use bp_activity_new_comment()? that function will also send
+                                // an email to people in the activity comment thread
+                                //
+                                // what if a site already has some comment email notification plugin setup?
+                                // this is why I decided to go with bp_activity_add() to avoid any conflict
+                                // with existing comment email notification plugins
+                                $comment_activity_id = bp_activity_add( $args );
+
+                                // add meta to activity comment
+                                bp_activity_update_meta( $comment_activity_id, 'bp_blogs_post_comment_id', $comment_id );
+
+                                // add meta to comment
+                                add_comment_meta( $comment_id, 'bp_activity_comment_id', $comment_activity_id );
+                        }
+                }
 
                 // Update the blogs last active date
                 bp_blogs_update_blogmeta( $blog_id, 'last_activity', bp_core_current_time() );
@@ -504 +569 @@
 add_action( 'delete_post', 'bp_blogs_remove_post' );
 
 function bp_blogs_remove_comment( $comment_id ) {
-        global $wpdb;
 
-        // Delete activity stream item
-        bp_blogs_delete_activity( array( 'item_id' => $wpdb->blogid, 'secondary_item_id' => $comment_id, 'type' => 'new_blog_comment' ) );
+        // activity comments are disabled for blog posts
+        // which means that individual activity items exist for blog comments
+        if ( bp_disable_blogforum_comments() ) {
+                global $wpdb;
+
+                // Delete the individual activity stream item
+                bp_blogs_delete_activity( array(
+                        'item_id'           => $wpdb->blogid,
+                        'secondary_item_id' => $comment_id,
+                        'type'              => 'new_blog_comment'
+                ) );
+
+        // activity comments are enabled for blog posts
+        // remove the associated activity item
+        } else {
+                // get associated activity ID from comment meta
+                $activity_id = get_comment_meta( $comment_id, 'bp_activity_comment_id', true );
+
+                // delete the associated activity comment
+                //
+                // @todo WP moves nested comments up a level when a comment is deleted,
+                //       while BP deletes all nested activity comments...
+                //
+                //       right now, we're simply deleting the singular activity comment
+                //       with bp_activity_delete() and not using bp_activity_delete_comment()
+                //       b/c that deletes activity comment children
+                //
+                //       this needs further research:
+                //       - how hard would it be to emulate WP's model?
+                //       - what would happen if BP_Activity_Activity::rebuild_activity_comment_tree()
+                //         is used when the main activity comment is not deleted?
+                if ( ! empty( $activity_id )) {
+                        bp_activity_delete( array(
+                                'id' => $activity_id
+                        ) );
+
+                        /* WORK IN PROGRESS
+                        // bp_activity_delete() needs to support multiple IDs for mass deletion
+                        // and a "exclude_comments" from deletion parameter
+                        //
+                        // get WP comment children IDs
+                        $comment_child_ids = bp_blogs_get_comment_children_ids( $comment_id );
+
+                        // delete all WP child comments
+                        if ( ! empty( $comment_child_ids ) ) {
+                                foreach( $comment_child_ids as $comment_child_id ) {
+                                        wp_delete_comment( $comment_child_id, true );
+                                }
+                        }
+                        */
+
+                }
+        }
 
         do_action( 'bp_blogs_remove_comment', $wpdb->blogid, $comment_id, bp_loggedin_user_id() );
 }
 add_action( 'delete_comment', 'bp_blogs_remove_comment' );
 
 /**
+ * Utility function to get all WP comment children IDs.
+ *
+ * Pass the WP comment ID and this function will try to grab all other comment
+ * children IDs.
+ *
+ * @since BuddyPress (1.9)
+ *
+ * @param int $comment_id The WP comment ID to check for.
+ * @param array $comment_ids Mainly used for recursion purposes.
+ * @return array
+ */
+function bp_blogs_get_comment_children_ids( $comment_id, $comment_ids = array() ) {
+        global $wpdb;
+
+        // search for any comments that are a direct child of our comment
+        $search = $wpdb->get_results(
+                $wpdb->prepare(
+                        "SELECT comment_id FROM {$wpdb->comments} WHERE comment_parent = %d",
+                        $comment_id
+                )
+        );
+
+        // grab the comment IDs from our search
+        $new_comment_ids = wp_list_pluck( (array) $search, 'comment_id' );
+
+        // merge comments with existing comment IDs
+        if ( ! empty( $new_comment_ids ) ) {
+                $comment_ids = $comment_ids + $new_comment_ids;
+        }
+
+        // okay, we have additional comments from our search
+        // now, we have to use recursion to get every other child
+        if ( ! empty( $new_comment_ids ) ) {
+                foreach( $new_comment_ids as $new_comment_id ) {
+                        $comment_ids = bp_blogs_get_comment_children_ids( $new_comment_id, $comment_ids );
+                }
+        }
+
+        return $comment_ids;
+}
+
+/**
  * When a blog comment status transition occurs, update the relevant activity's status.
  *
  * @global object $bp BuddyPress global settings

bp-blogs/bp-blogs-loader.php

@@ -61 +61 @@
 
                 // Setup the globals
                 parent::setup_globals( $args );
+
+                // Activity comment post callback
+                $this->activity_comment_post_callback = apply_filters( 'bp_blogs_activity_comment_post_callback', array(
+                        'add'    => 'bp_blogs_sync_add_from_activity_comment',
+                        'delete' => 'bp_blogs_sync_delete_from_activity_comment'
+                ) );
         }
 
         /**

bp-core/bp-core-component.php

@@ -247 +247 @@
         public function setup_actions() {
 
                 // Setup globals
-                add_action( 'bp_setup_globals',          array( $this, 'setup_globals'          ), 10 );
+                add_action( 'bp_setup_globals',          array( $this, 'setup_globals'                  ), 10 );
 
                 // Include required files. Called early to ensure that BP core
                 // components are loaded before plugins that hook their loader functions
                 // to bp_include with the default priority of 10. This is for backwards
                 // compatibility; henceforth, plugins should register themselves by
                 // extending this base class.
-                add_action( 'bp_include',                array( $this, 'includes'               ), 8 );
+                add_action( 'bp_include',                array( $this, 'includes'                       ), 10 );
 
                 // Setup navigation
-                add_action( 'bp_setup_nav',              array( $this, 'setup_nav'              ), 10 );
+                add_action( 'bp_setup_nav',              array( $this, 'setup_nav'                      ), 10 );
 
                 // Setup WP Toolbar menus
-                add_action( 'bp_setup_admin_bar',        array( $this, 'setup_admin_bar'        ), 10 );
+                add_action( 'bp_setup_admin_bar',        array( $this, 'setup_admin_bar'                ), 10 );
 
                 // Setup component title
-                add_action( 'bp_setup_title',            array( $this, 'setup_title'            ), 10 );
+                add_action( 'bp_setup_title',            array( $this, 'setup_title'                    ), 10 );
 
                 // Register post types
-                add_action( 'bp_register_post_types',    array( $this, 'register_post_types'    ), 10 );
+                add_action( 'bp_register_post_types',    array( $this, 'register_post_types'            ), 10 );
 
                 // Register taxonomies
-                add_action( 'bp_register_taxonomies',    array( $this, 'register_taxonomies'    ), 10 );
+                add_action( 'bp_register_taxonomies',    array( $this, 'register_taxonomies'            ), 10 );
 
                 // Add the rewrite tags
-                add_action( 'bp_add_rewrite_tags',       array( $this, 'add_rewrite_tags'       ), 10 );
+                add_action( 'bp_add_rewrite_tags',       array( $this, 'add_rewrite_tags'               ), 10 );
 
                 // Generate rewrite rules
-                add_action( 'bp_generate_rewrite_rules', array( $this, 'generate_rewrite_rules' ), 10 );
+                add_action( 'bp_generate_rewrite_rules', array( $this, 'generate_rewrite_rules'         ), 10 );
+
+                // Activity comment callback setup
+                add_action( 'bp_setup_globals',          array( $this, 'activity_comment_post_callback' ), 10 );
 
                 // Additional actions can be attached here
                 do_action( 'bp_' . $this->id . '_setup_actions' );
@@ -394 +397 @@
         public function generate_rewrite_rules() {
                 do_action( 'bp_' . $this->id . '_generate_rewrite_rules' );
         }
+
+        /**
+         * Setup activity comment post callback.
+         *
+         * If a component has the 'activity_comment_post_callback' property set,
+         * automatically setup the hooks to be used.
+         *
+         * @since BuddyPress (1.9)
+         */
+        public function activity_comment_post_callback() {
+                // if activity component is not active or callback is not an array, stop now!
+                if ( ! bp_is_active( 'activity' ) || ! is_array( $this->activity_comment_post_callback ) ) {
+                        return;
+                }
+
+                $callback = $this->activity_comment_post_callback;
+
+                // Activity comment addition callback
+                if ( ! empty( $callback['add'] ) && is_callable( $callback['add'] ) ) {
+                        add_action( 'bp_activity_comment_posted', $callback['add'],    10, 3 );
+                }
+
+                // Activity comment deletion callback
+                if ( ! empty( $callback['delete'] ) && is_callable( $callback['delete'] ) ) {
+                        add_action( 'bp_activity_delete_comment', $callback['delete'], 10, 2 );
+                }
+
+        }
 }
 endif; // BP_Component

bp-core/bp-core-options.php

@@ -202 +202 @@
  * @return mixed The value for the option
  */
 function bp_get_option( $option_name, $default = '' ) {
-        $value = get_blog_option( bp_get_root_blog_id(), $option_name, $default );
+        // check buddypress()->site_options array first
+        if ( isset( buddypress()->site_options[$option_name] ) ) {
+                $value = buddypress()->site_options[$option_name];
+
+        // query for the option if not available
+        } else {
+                $value = get_blog_option( bp_get_root_blog_id(), $option_name, $default );
+        }
 
         return apply_filters( 'bp_get_option', $value );
 }