", $pee); // no pee inside object/embed
$pee = preg_replace('|\s*\s*|', '', $pee);
}
$pee = preg_replace("/\n\n+/", "\n\n", $pee); // take care of duplicates
// make paragraphs, including one at the end
$pees = preg_split('/\n\s*\n/', $pee, -1, PREG_SPLIT_NO_EMPTY);
$pee = '';
foreach ( $pees as $tinkle )
$pee .= '' . trim($tinkle, "\n") . "
\n";
$pee = preg_replace('|\s*?
|', '', $pee); // under certain strange conditions it could create a P of entirely whitespace
$pee = preg_replace('!([^<]+)\s*?(]*>)!', "
$1
$2", $pee);
$pee = preg_replace( '||', "$1
", $pee );
$pee = preg_replace('!
\s*(]*>)\s*
!', "$1", $pee); // don't pee all over a tag
$pee = preg_replace("|(|", "$1", $pee); // problem with nested lists
$pee = preg_replace('|]*)>|i', "", $pee);
$pee = str_replace('
', '
', $pee);
$pee = preg_replace('!\s*(]*>)!', "$1", $pee);
$pee = preg_replace('!(]*>)\s*
!', "$1", $pee);
if ($br) {
$pee = preg_replace_callback('/<(script|style).*?<\/\\1>/s', create_function('$matches', 'return str_replace("\n", ")(.*?)!is', 'clean_pre', $pee );
$pee = preg_replace( "|\n
$|", '', $pee );
$pee = preg_replace('/\s*?(' . get_shortcode_regex() . ')\s*<\/p>/s', '$1', $pee); // don't auto-p wrap shortcodes that stand alone
return $pee;
}
/**
* Checks to see if a string is utf8 encoded.
*
* @author bmorel at ssi dot fr
*
* @since 1.2.1
*
* @param string $Str The string to be checked
* @return bool True if $Str fits a UTF-8 model, false otherwise.
*/
function seems_utf8($Str) { # by bmorel at ssi dot fr
$length = strlen($Str);
for ($i=0; $i < $length; $i++) {
if (ord($Str[$i]) < 0x80) continue; # 0bbbbbbb
elseif ((ord($Str[$i]) & 0xE0) == 0xC0) $n=1; # 110bbbbb
elseif ((ord($Str[$i]) & 0xF0) == 0xE0) $n=2; # 1110bbbb
elseif ((ord($Str[$i]) & 0xF8) == 0xF0) $n=3; # 11110bbb
elseif ((ord($Str[$i]) & 0xFC) == 0xF8) $n=4; # 111110bb
elseif ((ord($Str[$i]) & 0xFE) == 0xFC) $n=5; # 1111110b
else return false; # Does not match any model
for ($j=0; $j<$n; $j++) { # n bytes matching 10bbbbbb follow ?
if ((++$i == $length) || ((ord($Str[$i]) & 0xC0) != 0x80))
return false;
}
}
return true;
}
/**
* Converts a number of special characters into their HTML entities.
*
* Specifically deals with: &, <, >, ", and '.
*
* $quote_style can be set to ENT_COMPAT to encode " to
* ", or ENT_QUOTES to do both. Default is ENT_NOQUOTES where no quotes are encoded.
*
* @since 1.2.2
*
* @param string $string The text which is to be encoded.
* @param mixed $quote_style Optional. Converts double quotes if set to ENT_COMPAT, both single and double if set to ENT_QUOTES or none if set to ENT_NOQUOTES. Also compatible with old values; converting single quotes if set to 'single', double if set to 'double' or both if otherwise set. Default is ENT_NOQUOTES.
* @param string $charset Optional. The character encoding of the string. Default is false.
* @param boolean $double_encode Optional. Whether or not to encode existing html entities. Default is false.
* @return string The encoded text with HTML entities.
*/
function wp_specialchars( $string, $quote_style = ENT_NOQUOTES, $charset = false, $double_encode = false )
{
$string = (string) $string;
if ( 0 === strlen( $string ) ) {
return '';
}
// Don't bother if there are no specialchars - saves some processing
if ( !preg_match( '/[&<>"\']/', $string ) ) {
return $string;
}
// Account for the previous behaviour of the function when the $quote_style is not an accepted value
if ( empty( $quote_style ) ) {
$quote_style = ENT_NOQUOTES;
} elseif ( !in_array( $quote_style, array( 0, 2, 3, 'single', 'double' ), true ) ) {
$quote_style = ENT_QUOTES;
}
// Store the site charset as a static to avoid multiple calls to wp_load_alloptions()
if ( !$charset ) {
static $_charset;
if ( !isset( $_charset ) ) {
$alloptions = wp_load_alloptions();
$_charset = isset( $alloptions['blog_charset'] ) ? $alloptions['blog_charset'] : '';
}
$charset = $_charset;
}
if ( in_array( $charset, array( 'utf8', 'utf-8', 'UTF8' ) ) ) {
$charset = 'UTF-8';
}
$_quote_style = $quote_style;
if ( $quote_style === 'double' ) {
$quote_style = ENT_COMPAT;
$_quote_style = ENT_COMPAT;
} elseif ( $quote_style === 'single' ) {
$quote_style = ENT_NOQUOTES;
}
// Handle double encoding ourselves
if ( !$double_encode ) {
$string = wp_specialchars_decode( $string, $_quote_style );
$string = preg_replace( '/&(#?x?[0-9]+|[a-z]+);/i', '|wp_entity|$1|/wp_entity|', $string );
}
$string = @htmlspecialchars( $string, $quote_style, $charset );
// Handle double encoding ourselves
if ( !$double_encode ) {
$string = str_replace( array( '|wp_entity|', '|/wp_entity|' ), array( '&', ';' ), $string );
}
// Backwards compatibility
if ( 'single' === $_quote_style ) {
$string = str_replace( "'", ''', $string );
}
return $string;
}
/**
* Converts a number of HTML entities into their special characters.
*
* Specifically deals with: &, <, >, ", and '.
*
* $quote_style can be set to ENT_COMPAT to decode " entities,
* or ENT_QUOTES to do both " and '. Default is ENT_NOQUOTES where no quotes are decoded.
*
* @since 2.8
*
* @param string $string The text which is to be decoded.
* @param mixed $quote_style Optional. Converts double quotes if set to ENT_COMPAT, both single and double if set to ENT_QUOTES or none if set to ENT_NOQUOTES. Also compatible with old wp_specialchars() values; converting single quotes if set to 'single', double if set to 'double' or both if otherwise set. Default is ENT_NOQUOTES.
* @return string The decoded text without HTML entities.
*/
function wp_specialchars_decode( $string, $quote_style = ENT_NOQUOTES )
{
$string = (string) $string;
if ( 0 === strlen( $string ) ) {
return '';
}
// Don't bother if there are no entities - saves a lot of processing
if ( strpos( $string, '&' ) === false ) {
return $string;
}
// Match the previous behaviour of wp_specialchars() when the $quote_style is not an accepted value
if ( empty( $quote_style ) ) {
$quote_style = ENT_NOQUOTES;
} elseif ( !in_array( $quote_style, array( 0, 2, 3, 'single', 'double' ), true ) ) {
$quote_style = ENT_QUOTES;
}
// More complete than get_html_translation_table( HTML_SPECIALCHARS )
$single = array( ''' => '\'', ''' => '\'' );
$single_preg = array( '/�*39;/' => ''', '/�*27;/i' => ''' );
$double = array( '"' => '"', '"' => '"', '"' => '"' );
$double_preg = array( '/�*34;/' => '"', '/�*22;/i' => '"' );
$others = array( '<' => '<', '<' => '<', '>' => '>', '>' => '>', '&' => '&', '&' => '&', '&' => '&' );
$others_preg = array( '/�*60;/' => '<', '/�*62;/' => '>', '/�*38;/' => '&', '/�*26;/i' => '&' );
if ( $quote_style === ENT_QUOTES ) {
$translation = array_merge( $single, $double, $others );
$translation_preg = array_merge( $single_preg, $double_preg, $others_preg );
} elseif ( $quote_style === ENT_COMPAT || $quote_style === 'double' ) {
$translation = array_merge( $double, $others );
$translation_preg = array_merge( $double_preg, $others_preg );
} elseif ( $quote_style === 'single' ) {
$translation = array_merge( $single, $others );
$translation_preg = array_merge( $single_preg, $others_preg );
} elseif ( $quote_style === ENT_NOQUOTES ) {
$translation = $others;
$translation_preg = $others_preg;
}
// Remove zero padding on numeric entities
$string = preg_replace( array_keys( $translation_preg ), array_values( $translation_preg ), $string );
// Replace characters according to translation table
return strtr( $string, $translation );
}
/**
* Checks for invalid UTF8 in a string.
*
* @since 2.8
*
* @param string $string The text which is to be checked.
* @param boolean $strip Optional. Whether to attempt to strip out invalid UTF8. Default is false.
* @return string The checked text.
*/
function wp_check_invalid_utf8( $string, $strip = false )
{
$string = (string) $string;
if ( 0 === strlen( $string ) ) {
return '';
}
// Store the site charset as a static to avoid multiple calls to get_option()
static $is_utf8;
if ( !isset( $is_utf8 ) ) {
$is_utf8 = in_array( get_option( 'blog_charset' ), array( 'utf8', 'utf-8', 'UTF8', 'UTF-8' ) );
}
if ( !$is_utf8 ) {
return $string;
}
// Check for support for utf8 in the installed PCRE library once and store the result in a static
static $utf8_pcre;
if ( !isset( $utf8_pcre ) ) {
$utf8_pcre = @preg_match( '/^./u', 'a' );
}
// We can't demand utf8 in the PCRE installation, so just return the string in those cases
if ( !$utf8_pcre ) {
return $string;
}
// preg_match fails when it encounters invalid UTF8 in $string
if ( 1 === @preg_match( '/^./us', $string ) ) {
return $string;
}
// Attempt to strip the bad chars if requested (not recommended)
if ( $strip && function_exists( 'iconv' ) ) {
return iconv( 'utf-8', 'utf-8', $string );
}
return '';
}
/**
* Encode the Unicode values to be used in the URI.
*
* @since 1.5.0
*
* @param string $utf8_string
* @param int $length Max length of the string
* @return string String with Unicode encoded for URI.
*/
function utf8_uri_encode( $utf8_string, $length = 0 ) {
$unicode = '';
$values = array();
$num_octets = 1;
$unicode_length = 0;
$string_length = strlen( $utf8_string );
for ($i = 0; $i < $string_length; $i++ ) {
$value = ord( $utf8_string[ $i ] );
if ( $value < 128 ) {
if ( $length && ( $unicode_length >= $length ) )
break;
$unicode .= chr($value);
$unicode_length++;
} else {
if ( count( $values ) == 0 ) $num_octets = ( $value < 224 ) ? 2 : 3;
$values[] = $value;
if ( $length && ( $unicode_length + ($num_octets * 3) ) > $length )
break;
if ( count( $values ) == $num_octets ) {
if ($num_octets == 3) {
$unicode .= '%' . dechex($values[0]) . '%' . dechex($values[1]) . '%' . dechex($values[2]);
$unicode_length += 9;
} else {
$unicode .= '%' . dechex($values[0]) . '%' . dechex($values[1]);
$unicode_length += 6;
}
$values = array();
$num_octets = 1;
}
}
}
return $unicode;
}
/**
* Converts all accent characters to ASCII characters.
*
* If there are no accent characters, then the string given is just returned.
*
* @since 1.2.1
*
* @param string $string Text that might have accent characters
* @return string Filtered string with replaced "nice" characters.
*/
function remove_accents($string) {
if ( !preg_match('/[\x80-\xff]/', $string) )
return $string;
if (seems_utf8($string)) {
$chars = array(
// Decompositions for Latin-1 Supplement
chr(195).chr(128) => 'A', chr(195).chr(129) => 'A',
chr(195).chr(130) => 'A', chr(195).chr(131) => 'A',
chr(195).chr(132) => 'A', chr(195).chr(133) => 'A',
chr(195).chr(135) => 'C', chr(195).chr(136) => 'E',
chr(195).chr(137) => 'E', chr(195).chr(138) => 'E',
chr(195).chr(139) => 'E', chr(195).chr(140) => 'I',
chr(195).chr(141) => 'I', chr(195).chr(142) => 'I',
chr(195).chr(143) => 'I', chr(195).chr(145) => 'N',
chr(195).chr(146) => 'O', chr(195).chr(147) => 'O',
chr(195).chr(148) => 'O', chr(195).chr(149) => 'O',
chr(195).chr(150) => 'O', chr(195).chr(153) => 'U',
chr(195).chr(154) => 'U', chr(195).chr(155) => 'U',
chr(195).chr(156) => 'U', chr(195).chr(157) => 'Y',
chr(195).chr(159) => 's', chr(195).chr(160) => 'a',
chr(195).chr(161) => 'a', chr(195).chr(162) => 'a',
chr(195).chr(163) => 'a', chr(195).chr(164) => 'a',
chr(195).chr(165) => 'a', chr(195).chr(167) => 'c',
chr(195).chr(168) => 'e', chr(195).chr(169) => 'e',
chr(195).chr(170) => 'e', chr(195).chr(171) => 'e',
chr(195).chr(172) => 'i', chr(195).chr(173) => 'i',
chr(195).chr(174) => 'i', chr(195).chr(175) => 'i',
chr(195).chr(177) => 'n', chr(195).chr(178) => 'o',
chr(195).chr(179) => 'o', chr(195).chr(180) => 'o',
chr(195).chr(181) => 'o', chr(195).chr(182) => 'o',
chr(195).chr(182) => 'o', chr(195).chr(185) => 'u',
chr(195).chr(186) => 'u', chr(195).chr(187) => 'u',
chr(195).chr(188) => 'u', chr(195).chr(189) => 'y',
chr(195).chr(191) => 'y',
// Decompositions for Latin Extended-A
chr(196).chr(128) => 'A', chr(196).chr(129) => 'a',
chr(196).chr(130) => 'A', chr(196).chr(131) => 'a',
chr(196).chr(132) => 'A', chr(196).chr(133) => 'a',
chr(196).chr(134) => 'C', chr(196).chr(135) => 'c',
chr(196).chr(136) => 'C', chr(196).chr(137) => 'c',
chr(196).chr(138) => 'C', chr(196).chr(139) => 'c',
chr(196).chr(140) => 'C', chr(196).chr(141) => 'c',
chr(196).chr(142) => 'D', chr(196).chr(143) => 'd',
chr(196).chr(144) => 'D', chr(196).chr(145) => 'd',
chr(196).chr(146) => 'E', chr(196).chr(147) => 'e',
chr(196).chr(148) => 'E', chr(196).chr(149) => 'e',
chr(196).chr(150) => 'E', chr(196).chr(151) => 'e',
chr(196).chr(152) => 'E', chr(196).chr(153) => 'e',
chr(196).chr(154) => 'E', chr(196).chr(155) => 'e',
chr(196).chr(156) => 'G', chr(196).chr(157) => 'g',
chr(196).chr(158) => 'G', chr(196).chr(159) => 'g',
chr(196).chr(160) => 'G', chr(196).chr(161) => 'g',
chr(196).chr(162) => 'G', chr(196).chr(163) => 'g',
chr(196).chr(164) => 'H', chr(196).chr(165) => 'h',
chr(196).chr(166) => 'H', chr(196).chr(167) => 'h',
chr(196).chr(168) => 'I', chr(196).chr(169) => 'i',
chr(196).chr(170) => 'I', chr(196).chr(171) => 'i',
chr(196).chr(172) => 'I', chr(196).chr(173) => 'i',
chr(196).chr(174) => 'I', chr(196).chr(175) => 'i',
chr(196).chr(176) => 'I', chr(196).chr(177) => 'i',
chr(196).chr(178) => 'IJ',chr(196).chr(179) => 'ij',
chr(196).chr(180) => 'J', chr(196).chr(181) => 'j',
chr(196).chr(182) => 'K', chr(196).chr(183) => 'k',
chr(196).chr(184) => 'k', chr(196).chr(185) => 'L',
chr(196).chr(186) => 'l', chr(196).chr(187) => 'L',
chr(196).chr(188) => 'l', chr(196).chr(189) => 'L',
chr(196).chr(190) => 'l', chr(196).chr(191) => 'L',
chr(197).chr(128) => 'l', chr(197).chr(129) => 'L',
chr(197).chr(130) => 'l', chr(197).chr(131) => 'N',
chr(197).chr(132) => 'n', chr(197).chr(133) => 'N',
chr(197).chr(134) => 'n', chr(197).chr(135) => 'N',
chr(197).chr(136) => 'n', chr(197).chr(137) => 'N',
chr(197).chr(138) => 'n', chr(197).chr(139) => 'N',
chr(197).chr(140) => 'O', chr(197).chr(141) => 'o',
chr(197).chr(142) => 'O', chr(197).chr(143) => 'o',
chr(197).chr(144) => 'O', chr(197).chr(145) => 'o',
chr(197).chr(146) => 'OE',chr(197).chr(147) => 'oe',
chr(197).chr(148) => 'R',chr(197).chr(149) => 'r',
chr(197).chr(150) => 'R',chr(197).chr(151) => 'r',
chr(197).chr(152) => 'R',chr(197).chr(153) => 'r',
chr(197).chr(154) => 'S',chr(197).chr(155) => 's',
chr(197).chr(156) => 'S',chr(197).chr(157) => 's',
chr(197).chr(158) => 'S',chr(197).chr(159) => 's',
chr(197).chr(160) => 'S', chr(197).chr(161) => 's',
chr(197).chr(162) => 'T', chr(197).chr(163) => 't',
chr(197).chr(164) => 'T', chr(197).chr(165) => 't',
chr(197).chr(166) => 'T', chr(197).chr(167) => 't',
chr(197).chr(168) => 'U', chr(197).chr(169) => 'u',
chr(197).chr(170) => 'U', chr(197).chr(171) => 'u',
chr(197).chr(172) => 'U', chr(197).chr(173) => 'u',
chr(197).chr(174) => 'U', chr(197).chr(175) => 'u',
chr(197).chr(176) => 'U', chr(197).chr(177) => 'u',
chr(197).chr(178) => 'U', chr(197).chr(179) => 'u',
chr(197).chr(180) => 'W', chr(197).chr(181) => 'w',
chr(197).chr(182) => 'Y', chr(197).chr(183) => 'y',
chr(197).chr(184) => 'Y', chr(197).chr(185) => 'Z',
chr(197).chr(186) => 'z', chr(197).chr(187) => 'Z',
chr(197).chr(188) => 'z', chr(197).chr(189) => 'Z',
chr(197).chr(190) => 'z', chr(197).chr(191) => 's',
// Euro Sign
chr(226).chr(130).chr(172) => 'E',
// GBP (Pound) Sign
chr(194).chr(163) => '');
$string = strtr($string, $chars);
} else {
// Assume ISO-8859-1 if not UTF-8
$chars['in'] = chr(128).chr(131).chr(138).chr(142).chr(154).chr(158)
.chr(159).chr(162).chr(165).chr(181).chr(192).chr(193).chr(194)
.chr(195).chr(196).chr(197).chr(199).chr(200).chr(201).chr(202)
.chr(203).chr(204).chr(205).chr(206).chr(207).chr(209).chr(210)
.chr(211).chr(212).chr(213).chr(214).chr(216).chr(217).chr(218)
.chr(219).chr(220).chr(221).chr(224).chr(225).chr(226).chr(227)
.chr(228).chr(229).chr(231).chr(232).chr(233).chr(234).chr(235)
.chr(236).chr(237).chr(238).chr(239).chr(241).chr(242).chr(243)
.chr(244).chr(245).chr(246).chr(248).chr(249).chr(250).chr(251)
.chr(252).chr(253).chr(255);
$chars['out'] = "EfSZszYcYuAAAAAACEEEEIIIINOOOOOOUUUUYaaaaaaceeeeiiiinoooooouuuuyy";
$string = strtr($string, $chars['in'], $chars['out']);
$double_chars['in'] = array(chr(140), chr(156), chr(198), chr(208), chr(222), chr(223), chr(230), chr(240), chr(254));
$double_chars['out'] = array('OE', 'oe', 'AE', 'DH', 'TH', 'ss', 'ae', 'dh', 'th');
$string = str_replace($double_chars['in'], $double_chars['out'], $string);
}
return $string;
}
/**
* Filters certain characters from the file name.
*
* Turns all strings to lowercase removing most characters except alphanumeric
* with spaces, dashes and periods. All spaces and underscores are converted to
* dashes. Multiple dashes are converted to a single dash. Finally, if the file
* name ends with a dash, it is removed.
*
* @since 2.1.0
*
* @param string $name The file name
* @return string Sanitized file name
*/
function sanitize_file_name( $name ) { // Like sanitize_title, but with periods
$name = strtolower( $name );
$name = preg_replace('/&.+?;/', '', $name); // kill entities
$name = str_replace( '_', '-', $name );
$name = preg_replace('/[^a-z0-9\s-.]/', '', $name);
$name = preg_replace('/\s+/', '-', $name);
$name = preg_replace('|-+|', '-', $name);
$name = trim($name, '-');
return $name;
}
/**
* Sanitize username stripping out unsafe characters.
*
* If $strict is true, only alphanumeric characters (as well as _, space, ., -,
* @) are returned.
* Removes tags, octets, entities, and if strict is enabled, will remove all
* non-ASCII characters. After sanitizing, it passes the username, raw username
* (the username in the parameter), and the strict parameter as parameters for
* the filter.
*
* @since 2.0.0
* @uses apply_filters() Calls 'sanitize_user' hook on username, raw username,
* and $strict parameter.
*
* @param string $username The username to be sanitized.
* @param bool $strict If set limits $username to specific characters. Default false.
* @return string The sanitized username, after passing through filters.
*/
function sanitize_user( $username, $strict = false ) {
$raw_username = $username;
$username = strip_tags($username);
// Kill octets
$username = preg_replace('|%([a-fA-F0-9][a-fA-F0-9])|', '', $username);
$username = preg_replace('/&.+?;/', '', $username); // Kill entities
// If strict, reduce to ASCII for max portability.
if ( $strict )
$username = preg_replace('|[^a-z0-9 _.\-@]|i', '', $username);
// Consolidate contiguous whitespace
$username = preg_replace('|\s+|', ' ', $username);
return apply_filters('sanitize_user', $username, $raw_username, $strict);
}
/**
* Sanitizes title or use fallback title.
*
* Specifically, HTML and PHP tags are stripped. Further actions can be added
* via the plugin API. If $title is empty and $fallback_title is set, the latter
* will be used.
*
* @since 1.0.0
*
* @param string $title The string to be sanitized.
* @param string $fallback_title Optional. A title to use if $title is empty.
* @return string The sanitized string.
*/
function sanitize_title($title, $fallback_title = '') {
$title = strip_tags($title);
$title = apply_filters('sanitize_title', $title);
if ( '' === $title || false === $title )
$title = $fallback_title;
return $title;
}
/**
* Sanitizes title, replacing whitespace with dashes.
*
* Limits the output to alphanumeric characters, underscore (_) and dash (-).
* Whitespace becomes a dash.
*
* @since 1.2.0
*
* @param string $title The title to be sanitized.
* @return string The sanitized title.
*/
function sanitize_title_with_dashes($title) {
$title = strip_tags($title);
// Preserve escaped octets.
$title = preg_replace('|%([a-fA-F0-9][a-fA-F0-9])|', '---$1---', $title);
// Remove percent signs that are not part of an octet.
$title = str_replace('%', '', $title);
// Restore octets.
$title = preg_replace('|---([a-fA-F0-9][a-fA-F0-9])---|', '%$1', $title);
$title = remove_accents($title);
if (seems_utf8($title)) {
if (function_exists('mb_strtolower')) {
$title = mb_strtolower($title, 'UTF-8');
}
$title = utf8_uri_encode($title, 200);
}
$title = strtolower($title);
$title = preg_replace('/&.+?;/', '', $title); // kill entities
$title = preg_replace('/[^%a-z0-9 _-]/', '', $title);
$title = preg_replace('/\s+/', '-', $title);
$title = preg_replace('|-+|', '-', $title);
$title = trim($title, '-');
return $title;
}
/**
* Ensures a string is a valid SQL order by clause.
*
* Accepts one or more columns, with or without ASC/DESC, and also accepts
* RAND().
*
* @since 2.5.1
*
* @param string $orderby Order by string to be checked.
* @return string|false Returns the order by clause if it is a match, false otherwise.
*/
function sanitize_sql_orderby( $orderby ){
preg_match('/^\s*([a-z0-9_]+(\s+(ASC|DESC))?(\s*,\s*|\s*$))+|^\s*RAND\(\s*\)\s*$/i', $orderby, $obmatches);
if ( !$obmatches )
return false;
return $orderby;
}
/**
* Converts a number of characters from a string.
*
* Metadata tags <
> and <<category>> are removed, <<br>> and <<hr>> are
* converted into correct XHTML and Unicode characters are converted to the
* valid range.
*
* @since 0.71
*
* @param string $content String of characters to be converted.
* @param string $deprecated Not used.
* @return string Converted string.
*/
function convert_chars($content, $deprecated = '') {
// Translation of invalid Unicode references range to valid range
$wp_htmltranswinuni = array(
'€' => '€', // the Euro sign
'' => '',
'‚' => '‚', // these are Windows CP1252 specific characters
'ƒ' => 'ƒ', // they would look weird on non-Windows browsers
'„' => '„',
'…' => '…',
'†' => '†',
'‡' => '‡',
'ˆ' => 'ˆ',
'‰' => '‰',
'Š' => 'Š',
'‹' => '‹',
'Œ' => 'Œ',
'' => '',
'Ž' => 'ž',
'' => '',
'' => '',
'‘' => '‘',
'’' => '’',
'“' => '“',
'”' => '”',
'•' => '•',
'–' => '–',
'—' => '—',
'˜' => '˜',
'™' => '™',
'š' => 'š',
'›' => '›',
'œ' => 'œ',
'' => '',
'ž' => '',
'Ÿ' => 'Ÿ'
);
// Remove metadata tags
$content = preg_replace('/<title>(.+?)<\/title>/','',$content);
$content = preg_replace('/<category>(.+?)<\/category>/','',$content);
// Converts lone & characters into & (a.k.a. &)
$content = preg_replace('/&([^#])(?![a-z1-4]{1,8};)/i', '&$1', $content);
// Fix Word pasting
$content = strtr($content, $wp_htmltranswinuni);
// Just a little XHTML help
$content = str_replace('<br>', '<br />', $content);
$content = str_replace('<hr>', '<hr />', $content);
return $content;
}
/**
* Fixes javascript bugs in browsers.
*
* Converts unicode characters to HTML numbered entities.
*
* @since 1.5.0
* @uses $is_macIE
* @uses $is_winIE
*
* @param string $text Text to be made safe.
* @return string Fixed text.
*/
function funky_javascript_fix($text) {
// Fixes for browsers' javascript bugs
global $is_macIE, $is_winIE;
/** @todo use preg_replace_callback() instead */
if ( $is_winIE || $is_macIE )
$text = preg_replace("/\%u([0-9A-F]{4,4})/e", "'&#'.base_convert('\\1',16,10).';'", $text);
return $text;
}
/**
* Will only balance the tags if forced to and the option is set to balance tags.
*
* The option 'use_balanceTags' is used for whether the tags will be balanced.
* Both the $force parameter and 'use_balanceTags' option will have to be true
* before the tags will be balanced.
*
* @since 0.71
*
* @param string $text Text to be balanced
* @param bool $force Forces balancing, ignoring the value of the option. Default false.
* @return string Balanced text
*/
function balanceTags( $text, $force = false ) {
if ( !$force && get_option('use_balanceTags') == 0 )
return $text;
return force_balance_tags( $text );
}
/**
* Balances tags of string using a modified stack.
*
* @since 2.0.4
*
* @author Leonard Lin <leonard@acm.org>
* @license GPL v2.0
* @copyright November 4, 2001
* @version 1.1
* @todo Make better - change loop condition to $text in 1.2
* @internal Modified by Scott Reilly (coffee2code) 02 Aug 2004
* 1.1 Fixed handling of append/stack pop order of end text
* Added Cleaning Hooks
* 1.0 First Version
*
* @param string $text Text to be balanced.
* @return string Balanced text.
*/
function force_balance_tags( $text ) {
$tagstack = array(); $stacksize = 0; $tagqueue = ''; $newtext = '';
$single_tags = array('br', 'hr', 'img', 'input'); //Known single-entity/self-closing tags
$nestable_tags = array('blockquote', 'div', 'span'); //Tags that can be immediately nested within themselves
# WP bug fix for comments - in case you REALLY meant to type '< !--'
$text = str_replace('< !--', '< !--', $text);
# WP bug fix for LOVE <3 (and other situations with '<' before a number)
$text = preg_replace('#<([0-9]{1})#', '<$1', $text);
while (preg_match("/<(\/?\w*)\s*([^>]*)>/",$text,$regex)) {
$newtext .= $tagqueue;
$i = strpos($text,$regex[0]);
$l = strlen($regex[0]);
// clear the shifter
$tagqueue = '';
// Pop or Push
if ($regex[1][0] == "/") { // End Tag
$tag = strtolower(substr($regex[1],1));
// if too many closing tags
if($stacksize <= 0) {
$tag = '';
//or close to be safe $tag = '/' . $tag;
}
// if stacktop value = tag close value then pop
else if ($tagstack[$stacksize - 1] == $tag) { // found closing tag
$tag = '</' . $tag . '>'; // Close Tag
// Pop
array_pop ($tagstack);
$stacksize--;
} else { // closing tag not at top, search for it
for ($j=$stacksize-1;$j>=0;$j--) {
if ($tagstack[$j] == $tag) {
// add tag to tagqueue
for ($k=$stacksize-1;$k>=$j;$k--){
$tagqueue .= '</' . array_pop ($tagstack) . '>';
$stacksize--;
}
break;
}
}
$tag = '';
}
} else { // Begin Tag
$tag = strtolower($regex[1]);
// Tag Cleaning
// If self-closing or '', don't do anything.
if((substr($regex[2],-1) == '/') || ($tag == '')) {
}
// ElseIf it's a known single-entity tag but it doesn't close itself, do so
elseif ( in_array($tag, $single_tags) ) {
$regex[2] .= '/';
} else { // Push the tag onto the stack
// If the top of the stack is the same as the tag we want to push, close previous tag
if (($stacksize > 0) && !in_array($tag, $nestable_tags) && ($tagstack[$stacksize - 1] == $tag)) {
$tagqueue = '</' . array_pop ($tagstack) . '>';
$stacksize--;
}
$stacksize = array_push ($tagstack, $tag);
}
// Attributes
$attributes = $regex[2];
if($attributes) {
$attributes = ' '.$attributes;
}
$tag = '<'.$tag.$attributes.'>';
//If already queuing a close tag, then put this tag on, too
if ($tagqueue) {
$tagqueue .= $tag;
$tag = '';
}
}
$newtext .= substr($text,0,$i) . $tag;
$text = substr($text,$i+$l);
}
// Clear Tag Queue
$newtext .= $tagqueue;
// Add Remaining text
$newtext .= $text;
// Empty Stack
while($x = array_pop($tagstack)) {
$newtext .= '</' . $x . '>'; // Add remaining tags to close
}
// WP fix for the bug with HTML comments
$newtext = str_replace("< !--","<!--",$newtext);
$newtext = str_replace("< !--","< !--",$newtext);
return $newtext;
}
/**
* Acts on text which is about to be edited.
*
* Unless $richedit is set, it is simply a holder for the 'format_to_edit'
* filter. If $richedit is set true htmlspecialchars() will be run on the
* content, converting special characters to HTMl entities.
*
* @since 0.71
*
* @param string $content The text about to be edited.
* @param bool $richedit Whether or not the $content should pass through htmlspecialchars(). Default false.
* @return string The text after the filter (and possibly htmlspecialchars()) has been run.
*/
function format_to_edit($content, $richedit = false) {
$content = apply_filters('format_to_edit', $content);
if (! $richedit )
$content = htmlspecialchars($content);
return $content;
}
/**
* Holder for the 'format_to_post' filter.
*
* @since 0.71
*
* @param string $content The text to pass through the filter.
* @return string Text returned from the 'format_to_post' filter.
*/
function format_to_post($content) {
$content = apply_filters('format_to_post', $content);
return $content;
}
/**
* Add leading zeros when necessary.
*
* If you set the threshold to '4' and the number is '10', then you will get
* back '0010'. If you set the number to '4' and the number is '5000', then you
* will get back '5000'.
*
* Uses sprintf to append the amount of zeros based on the $threshold parameter
* and the size of the number. If the number is large enough, then no zeros will
* be appended.
*
* @since 0.71
*
* @param mixed $number Number to append zeros to if not greater than threshold.
* @param int $threshold Digit places number needs to be to not have zeros added.
* @return string Adds leading zeros to number if needed.
*/
function zeroise($number, $threshold) {
return sprintf('%0'.$threshold.'s', $number);
}
/**
* Adds backslashes before letters and before a number at the start of a string.
*
* @since 0.71
*
* @param string $string Value to which backslashes will be added.
* @return string String with backslashes inserted.
*/
function backslashit($string) {
$string = preg_replace('/^([0-9])/', '\\\\\\\\\1', $string);
$string = preg_replace('/([a-z])/i', '\\\\\1', $string);
return $string;
}
/**
* Appends a trailing slash.
*
* Will remove trailing slash if it exists already before adding a trailing
* slash. This prevents double slashing a string or path.
*
* The primary use of this is for paths and thus should be used for paths. It is
* not restricted to paths and offers no specific path support.
*
* @since 1.2.0
* @uses untrailingslashit() Unslashes string if it was slashed already.
*
* @param string $string What to add the trailing slash to.
* @return string String with trailing slash added.
*/
function trailingslashit($string) {
return untrailingslashit($string) . '/';
}
/**
* Removes trailing slash if it exists.
*
* The primary use of this is for paths and thus should be used for paths. It is
* not restricted to paths and offers no specific path support.
*
* @since 2.2.0
*
* @param string $string What to remove the trailing slash from.
* @return string String without the trailing slash.
*/
function untrailingslashit($string) {
return rtrim($string, '/');
}
/**
* Adds slashes to escape strings.
*
* Slashes will first be removed if magic_quotes_gpc is set, see {@link
* http://www.php.net/magic_quotes} for more details.
*
* @since 0.71
*
* @param string $gpc The string returned from HTTP request data.
* @return string Returns a string escaped with slashes.
*/
function addslashes_gpc($gpc) {
global $wpdb;
if (get_magic_quotes_gpc()) {
$gpc = stripslashes($gpc);
}
return $wpdb->escape($gpc);
}
/**
* Navigates through an array and removes slashes from the values.
*
* If an array is passed, the array_map() function causes a callback to pass the
* value back to the function. The slashes from this value will removed.
*
* @since 2.0.0
*
* @param array|string $value The array or string to be striped.
* @return array|string Stripped array (or string in the callback).
*/
function stripslashes_deep($value) {
$value = is_array($value) ? array_map('stripslashes_deep', $value) : stripslashes($value);
return $value;
}
/**
* Navigates through an array and encodes the values to be used in a URL.
*
* Uses a callback to pass the value of the array back to the function as a
* string.
*
* @since 2.2.0
*
* @param array|string $value The array or string to be encoded.
* @return array|string $value The encoded array (or string from the callback).
*/
function urlencode_deep($value) {
$value = is_array($value) ? array_map('urlencode_deep', $value) : urlencode($value);
return $value;
}
/**
* Converts email addresses characters to HTML entities to block spam bots.
*
* @since 0.71
*
* @param string $emailaddy Email address.
* @param int $mailto Optional. Range from 0 to 1. Used for encoding.
* @return string Converted email address.
*/
function antispambot($emailaddy, $mailto=0) {
$emailNOSPAMaddy = '';
srand ((float) microtime() * 1000000);
for ($i = 0; $i < strlen($emailaddy); $i = $i + 1) {
$j = floor(rand(0, 1+$mailto));
if ($j==0) {
$emailNOSPAMaddy .= '&#'.ord(substr($emailaddy,$i,1)).';';
} elseif ($j==1) {
$emailNOSPAMaddy .= substr($emailaddy,$i,1);
} elseif ($j==2) {
$emailNOSPAMaddy .= '%'.zeroise(dechex(ord(substr($emailaddy, $i, 1))), 2);
}
}
$emailNOSPAMaddy = str_replace('@','@',$emailNOSPAMaddy);
return $emailNOSPAMaddy;
}
/**
* Callback to convert URI match to HTML A element.
*
* This function was backported from 2.5.0 to 2.3.2. Regex callback for {@link
* make_clickable()}.
*
* @since 2.3.2
* @access private
*
* @param array $matches Single Regex Match.
* @return string HTML A element with URI address.
*/
function _make_url_clickable_cb($matches) {
$ret = '';
$url = $matches[2];
$url = clean_url($url);
if ( empty($url) )
return $matches[0];
// removed trailing [.,;:] from URL
if ( in_array(substr($url, -1), array('.', ',', ';', ':')) === true ) {
$ret = substr($url, -1);
$url = substr($url, 0, strlen($url)-1);
}
return $matches[1] . "<a href=\"$url\" rel=\"nofollow\">$url</a>" . $ret;
}
/**
* Callback to convert URL match to HTML A element.
*
* This function was backported from 2.5.0 to 2.3.2. Regex callback for {@link
* make_clickable()}.
*
* @since 2.3.2
* @access private
*
* @param array $matches Single Regex Match.
* @return string HTML A element with URL address.
*/
function _make_web_ftp_clickable_cb($matches) {
$ret = '';
$dest = $matches[2];
$dest = 'http://' . $dest;
$dest = clean_url($dest);
if ( empty($dest) )
return $matches[0];
// removed trailing [,;:] from URL
if ( in_array(substr($dest, -1), array('.', ',', ';', ':')) === true ) {
$ret = substr($dest, -1);
$dest = substr($dest, 0, strlen($dest)-1);
}
return $matches[1] . "<a href=\"$dest\" rel=\"nofollow\">$dest</a>" . $ret;
}
/**
* Callback to convert email address match to HTML A element.
*
* This function was backported from 2.5.0 to 2.3.2. Regex callback for {@link
* make_clickable()}.
*
* @since 2.3.2
* @access private
*
* @param array $matches Single Regex Match.
* @return string HTML A element with email address.
*/
function _make_email_clickable_cb($matches) {
$email = $matches[2] . '@' . $matches[3];
return $matches[1] . "<a href=\"mailto:$email\">$email</a>";
}
/**
* Convert plaintext URI to HTML links.
*
* Converts URI, www and ftp, and email addresses. Finishes by fixing links
* within links.
*
* @since 0.71
*
* @param string $ret Content to convert URIs.
* @return string Content with converted URIs.
*/
function make_clickable($ret) {
$ret = ' ' . $ret;
// in testing, using arrays here was found to be faster
$ret = preg_replace_callback('#([\s>])([\w]+?://[\w\\x80-\\xff\#$%&~/.\-;:=,?@\[\]+]*)#is', '_make_url_clickable_cb', $ret);
$ret = preg_replace_callback('#([\s>])((www|ftp)\.[\w\\x80-\\xff\#$%&~/.\-;:=,?@\[\]+]*)#is', '_make_web_ftp_clickable_cb', $ret);
$ret = preg_replace_callback('#([\s>])([.0-9a-z_+-]+)@(([0-9a-z-]+\.)+[0-9a-z]{2,})#i', '_make_email_clickable_cb', $ret);
// this one is not in an array because we need it to run last, for cleanup of accidental links within links
$ret = preg_replace("#(<a( [^>]+?>|>))<a [^>]+?>([^>]+?)</a></a>#i", "$1$3</a>", $ret);
$ret = trim($ret);
return $ret;
}
/**
* Adds rel nofollow string to all HTML A elements in content.
*
* @since 1.5.0
*
* @param string $text Content that may contain HTML A elements.
* @return string Converted content.
*/
function wp_rel_nofollow( $text ) {
global $wpdb;
// This is a pre save filter, so text is already escaped.
$text = stripslashes($text);
$text = preg_replace_callback('|<a (.+?)>|i', 'wp_rel_nofollow_callback', $text);
$text = $wpdb->escape($text);
return $text;
}
/**
* Callback to used to add rel=nofollow string to HTML A element.
*
* Will remove already existing rel="nofollow" and rel='nofollow' from the
* string to prevent from invalidating (X)HTML.
*
* @since 2.3.0
*
* @param array $matches Single Match
* @return string HTML A Element with rel nofollow.
*/
function wp_rel_nofollow_callback( $matches ) {
$text = $matches[1];
$text = str_replace(array(' rel="nofollow"', " rel='nofollow'"), '', $text);
return "<a $text rel=\"nofollow\">";
}
/**
* Convert text equivalent of smilies to images.
*
* Will only convert smilies if the option 'use_smilies' is true and the globals
* used in the function aren't empty.
*
* @since 0.71
* @uses $wp_smiliessearch, $wp_smiliesreplace Smiley replacement arrays.
*
* @param string $text Content to convert smilies from text.
* @return string Converted content with text smilies replaced with images.
*/
function convert_smilies($text) {
global $wp_smiliessearch, $wp_smiliesreplace;
$output = '';
if ( get_option('use_smilies') && !empty($wp_smiliessearch) && !empty($wp_smiliesreplace) ) {
// HTML loop taken from texturize function, could possible be consolidated
$textarr = preg_split("/(<.*>)/U", $text, -1, PREG_SPLIT_DELIM_CAPTURE); // capture the tags as well as in between
$stop = count($textarr);// loop stuff
for ($i = 0; $i < $stop; $i++) {
$content = $textarr[$i];
if ((strlen($content) > 0) && ('<' != $content{0})) { // If it's not a tag
$content = preg_replace($wp_smiliessearch, $wp_smiliesreplace, $content);
}
$output .= $content;
}
} else {
// return default text.
$output = $text;
}
return $output;
}
/**
* Checks to see if the text is a valid email address.
*
* @since 0.71
*
* @param string $user_email The email address to be checked.
* @return bool Returns true if valid, otherwise false.
*/
function is_email($user_email) {
$chars = "/^([a-z0-9+_]|\\-|\\.)+@(([a-z0-9_]|\\-)+\\.)+[a-z]{2,6}\$/i";
if (strpos($user_email, '@') !== false && strpos($user_email, '.') !== false) {
if (preg_match($chars, $user_email)) {
return true;
} else {
return false;
}
} else {
return false;
}
}
/**
* Convert to ASCII from email subjects.
*
* @since 1.2.0
* @usedby wp_mail() handles charsets in email subjects
*
* @param string $string Subject line
* @return string Converted string to ASCII
*/
function wp_iso_descrambler($string) {
/* this may only work with iso-8859-1, I'm afraid */
if (!preg_match('#\=\?(.+)\?Q\?(.+)\?\=#i', $string, $matches)) {
return $string;
} else {
$subject = str_replace('_', ' ', $matches[2]);
$subject = preg_replace_callback('#\=([0-9a-f]{2})#i', create_function('$match', 'return chr(hexdec(strtolower($match[1])));'), $subject);
return $subject;
}
}
/**
* Returns a date in the GMT equivalent.
*
* Requires and returns a date in the Y-m-d H:i:s format. Simply subtracts the
* value of the 'gmt_offset' option.
*
* @since 1.2.0
*
* @uses get_option() to retrieve the the value of 'gmt_offset'.
* @param string $string The date to be converted.
* @return string GMT version of the date provided.
*/
function get_gmt_from_date($string) {
preg_match('#([0-9]{1,4})-([0-9]{1,2})-([0-9]{1,2}) ([0-9]{1,2}):([0-9]{1,2}):([0-9]{1,2})#', $string, $matches);
$string_time = gmmktime($matches[4], $matches[5], $matches[6], $matches[2], $matches[3], $matches[1]);
$string_gmt = gmdate('Y-m-d H:i:s', $string_time - get_option('gmt_offset') * 3600);
return $string_gmt;
}
/**
* Converts a GMT date into the correct format for the blog.
*
* Requires and returns in the Y-m-d H:i:s format. Simply adds the value of
* gmt_offset.
*
* @since 1.2.0
*
* @param string $string The date to be converted.
* @return string Formatted date relative to the GMT offset.
*/
function get_date_from_gmt($string) {
preg_match('#([0-9]{1,4})-([0-9]{1,2})-([0-9]{1,2}) ([0-9]{1,2}):([0-9]{1,2}):([0-9]{1,2})#', $string, $matches);
$string_time = gmmktime($matches[4], $matches[5], $matches[6], $matches[2], $matches[3], $matches[1]);
$string_localtime = gmdate('Y-m-d H:i:s', $string_time + get_option('gmt_offset')*3600);
return $string_localtime;
}
/**
* Computes an offset in seconds from an iso8601 timezone.
*
* @since 1.5.0
*
* @param string $timezone Either 'Z' for 0 offset or '±hhmm'.
* @return int|float The offset in seconds.
*/
function iso8601_timezone_to_offset($timezone) {
// $timezone is either 'Z' or '[+|-]hhmm'
if ($timezone == 'Z') {
$offset = 0;
} else {
$sign = (substr($timezone, 0, 1) == '+') ? 1 : -1;
$hours = intval(substr($timezone, 1, 2));
$minutes = intval(substr($timezone, 3, 4)) / 60;
$offset = $sign * 3600 * ($hours + $minutes);
}
return $offset;
}
/**
* Converts an iso8601 date to MySQL DateTime format used by post_date[_gmt].
*
* @since 1.5.0
*
* @param string $date_string Date and time in ISO 8601 format {@link http://en.wikipedia.org/wiki/ISO_8601}.
* @param string $timezone Optional. If set to GMT returns the time minus gmt_offset. Default is 'user'.
* @return string The date and time in MySQL DateTime format - Y-m-d H:i:s.
*/
function iso8601_to_datetime($date_string, $timezone = 'user') {
$timezone = strtolower($timezone);
if ($timezone == 'gmt') {
preg_match('#([0-9]{4})([0-9]{2})([0-9]{2})T([0-9]{2}):([0-9]{2}):([0-9]{2})(Z|[\+|\-][0-9]{2,4}){0,1}#', $date_string, $date_bits);
if (!empty($date_bits[7])) { // we have a timezone, so let's compute an offset
$offset = iso8601_timezone_to_offset($date_bits[7]);
} else { // we don't have a timezone, so we assume user local timezone (not server's!)
$offset = 3600 * get_option('gmt_offset');
}
$timestamp = gmmktime($date_bits[4], $date_bits[5], $date_bits[6], $date_bits[2], $date_bits[3], $date_bits[1]);
$timestamp -= $offset;
return gmdate('Y-m-d H:i:s', $timestamp);
} else if ($timezone == 'user') {
return preg_replace('#([0-9]{4})([0-9]{2})([0-9]{2})T([0-9]{2}):([0-9]{2}):([0-9]{2})(Z|[\+|\-][0-9]{2,4}){0,1}#', '$1-$2-$3 $4:$5:$6', $date_string);
}
}
/**
* Adds a element attributes to open links in new windows.
*
* Comment text in popup windows should be filtered through this. Right now it's
* a moderately dumb function, ideally it would detect whether a target or rel
* attribute was already there and adjust its actions accordingly.
*
* @since 0.71
*
* @param string $text Content to replace links to open in a new window.
* @return string Content that has filtered links.
*/
function popuplinks($text) {
$text = preg_replace('/<a (.+?)>/i', "<a $1 target='_blank' rel='external'>", $text);
return $text;
}
/**
* Strips out all characters that are not allowable in an email.
*
* @since 1.5.0
*
* @param string $email Email address to filter.
* @return string Filtered email address.
*/
function sanitize_email($email) {
return preg_replace('/[^a-z0-9+_.@-]/i', '', $email);
}
/**
* Determines the difference between two timestamps.
*
* The difference is returned in a human readable format such as "1 hour",
* "5 mins", "2 days".
*
* @since 1.5.0
*
* @param int $from Unix timestamp from which the difference begins.
* @param int $to Optional. Unix timestamp to end the time difference. Default becomes time() if not set.
* @return string Human readable time difference.
*/
function human_time_diff( $from, $to = '' ) {
if ( empty($to) )
$to = time();
$diff = (int) abs($to - $from);
if ($diff <= 3600) {
$mins = round($diff / 60);
if ($mins <= 1) {
$mins = 1;
}
$since = sprintf(__ngettext('%s min', '%s mins', $mins), $mins);
} else if (($diff <= 86400) && ($diff > 3600)) {
$hours = round($diff / 3600);
if ($hours <= 1) {
$hours = 1;
}
$since = sprintf(__ngettext('%s hour', '%s hours', $hours), $hours);
} elseif ($diff >= 86400) {
$days = round($diff / 86400);
if ($days <= 1) {
$days = 1;
}
$since = sprintf(__ngettext('%s day', '%s days', $days), $days);
}
return $since;
}
/**
* Generates an excerpt from the content, if needed.
*
* The excerpt word amount will be 55 words and if the amount is greater than
* that, then the string '[...]' will be appended to the excerpt. If the string
* is less than 55 words, then the content will be returned as is.
*
* @since 1.5.0
*
* @param string $text The exerpt. If set to empty an excerpt is generated.
* @return string The excerpt.
*/
function wp_trim_excerpt($text) {
if ( '' == $text ) {
$text = get_the_content('');
$text = strip_shortcodes( $text );
$text = apply_filters('the_content', $text);
$text = str_replace(']]>', ']]>', $text);
$text = strip_tags($text);
$excerpt_length = apply_filters('excerpt_length', 55);
$words = explode(' ', $text, $excerpt_length + 1);
if (count($words) > $excerpt_length) {
array_pop($words);
array_push($words, '[...]');
$text = implode(' ', $words);
}
}
return $text;
}
/**
* Converts named entities into numbered entities.
*
* @since 1.5.1
*
* @param string $text The text within which entities will be converted.
* @return string Text with converted entities.
*/
function ent2ncr($text) {
$to_ncr = array(
'"' => '"',
'&' => '&',
'⁄' => '/',
'<' => '<',
'>' => '>',
'|' => '|',
' ' => ' ',
'¡' => '¡',
'¢' => '¢',
'£' => '£',
'¤' => '¤',
'¥' => '¥',
'¦' => '¦',
'&brkbar;' => '¦',
'§' => '§',
'¨' => '¨',
'¨' => '¨',
'©' => '©',
'ª' => 'ª',
'«' => '«',
'¬' => '¬',
'' => '',
'®' => '®',
'¯' => '¯',
'&hibar;' => '¯',
'°' => '°',
'±' => '±',
'²' => '²',
'³' => '³',
'´' => '´',
'µ' => 'µ',
'¶' => '¶',
'·' => '·',
'¸' => '¸',
'¹' => '¹',
'º' => 'º',
'»' => '»',
'¼' => '¼',
'½' => '½',
'¾' => '¾',
'¿' => '¿',
'À' => 'À',
'Á' => 'Á',
'Â' => 'Â',
'Ã' => 'Ã',
'Ä' => 'Ä',
'Å' => 'Å',
'Æ' => 'Æ',
'Ç' => 'Ç',
'È' => 'È',
'É' => 'É',
'Ê' => 'Ê',
'Ë' => 'Ë',
'Ì' => 'Ì',
'Í' => 'Í',
'Î' => 'Î',
'Ï' => 'Ï',
'Ð' => 'Ð',
'Ñ' => 'Ñ',
'Ò' => 'Ò',
'Ó' => 'Ó',
'Ô' => 'Ô',
'Õ' => 'Õ',
'Ö' => 'Ö',
'×' => '×',
'Ø' => 'Ø',
'Ù' => 'Ù',
'Ú' => 'Ú',
'Û' => 'Û',
'Ü' => 'Ü',
'Ý' => 'Ý',
'Þ' => 'Þ',
'ß' => 'ß',
'à' => 'à',
'á' => 'á',
'â' => 'â',
'ã' => 'ã',
'ä' => 'ä',
'å' => 'å',
'æ' => 'æ',
'ç' => 'ç',
'è' => 'è',
'é' => 'é',
'ê' => 'ê',
'ë' => 'ë',
'ì' => 'ì',
'í' => 'í',
'î' => 'î',
'ï' => 'ï',
'ð' => 'ð',
'ñ' => 'ñ',
'ò' => 'ò',
'ó' => 'ó',
'ô' => 'ô',
'õ' => 'õ',
'ö' => 'ö',
'÷' => '÷',
'ø' => 'ø',
'ù' => 'ù',
'ú' => 'ú',
'û' => 'û',
'ü' => 'ü',
'ý' => 'ý',
'þ' => 'þ',
'ÿ' => 'ÿ',
'Œ' => 'Œ',
'œ' => 'œ',
'Š' => 'Š',
'š' => 'š',
'Ÿ' => 'Ÿ',
'ƒ' => 'ƒ',
'ˆ' => 'ˆ',
'˜' => '˜',
'Α' => 'Α',
'Β' => 'Β',
'Γ' => 'Γ',
'Δ' => 'Δ',
'Ε' => 'Ε',
'Ζ' => 'Ζ',
'Η' => 'Η',
'Θ' => 'Θ',
'Ι' => 'Ι',
'Κ' => 'Κ',
'Λ' => 'Λ',
'Μ' => 'Μ',
'Ν' => 'Ν',
'Ξ' => 'Ξ',
'Ο' => 'Ο',
'Π' => 'Π',
'Ρ' => 'Ρ',
'Σ' => 'Σ',
'Τ' => 'Τ',
'Υ' => 'Υ',
'Φ' => 'Φ',
'Χ' => 'Χ',
'Ψ' => 'Ψ',
'Ω' => 'Ω',
'α' => 'α',
'β' => 'β',
'γ' => 'γ',
'δ' => 'δ',
'ε' => 'ε',
'ζ' => 'ζ',
'η' => 'η',
'θ' => 'θ',
'ι' => 'ι',
'κ' => 'κ',
'λ' => 'λ',
'μ' => 'μ',
'ν' => 'ν',
'ξ' => 'ξ',
'ο' => 'ο',
'π' => 'π',
'ρ' => 'ρ',
'ς' => 'ς',
'σ' => 'σ',
'τ' => 'τ',
'υ' => 'υ',
'φ' => 'φ',
'χ' => 'χ',
'ψ' => 'ψ',
'ω' => 'ω',
'ϑ' => 'ϑ',
'ϒ' => 'ϒ',
'ϖ' => 'ϖ',
' ' => ' ',
' ' => ' ',
' ' => ' ',
'' => '',
'' => '',
'' => '',
'' => '',
'–' => '–',
'—' => '—',
'‘' => '‘',
'’' => '’',
'‚' => '‚',
'“' => '“',
'”' => '”',
'„' => '„',
'†' => '†',
'‡' => '‡',
'•' => '•',
'…' => '…',
'‰' => '‰',
'′' => '′',
'″' => '″',
'‹' => '‹',
'›' => '›',
'‾' => '‾',
'⁄' => '⁄',
'€' => '€',
'ℑ' => 'ℑ',
'℘' => '℘',
'ℜ' => 'ℜ',
'™' => '™',
'ℵ' => 'ℵ',
'↵' => '↵',
'⇐' => '⇐',
'⇑' => '⇑',
'⇒' => '⇒',
'⇓' => '⇓',
'⇔' => '⇔',
'∀' => '∀',
'∂' => '∂',
'∃' => '∃',
'∅' => '∅',
'∇' => '∇',
'∈' => '∈',
'∉' => '∉',
'∋' => '∋',
'∏' => '∏',
'∑' => '∑',
'−' => '−',
'∗' => '∗',
'√' => '√',
'∝' => '∝',
'∞' => '∞',
'∠' => '∠',
'∧' => '∧',
'∨' => '∨',
'∩' => '∩',
'∪' => '∪',
'∫' => '∫',
'∴' => '∴',
'∼' => '∼',
'≅' => '≅',
'≈' => '≈',
'≠' => '≠',
'≡' => '≡',
'≤' => '≤',
'≥' => '≥',
'⊂' => '⊂',
'⊃' => '⊃',
'⊄' => '⊄',
'⊆' => '⊆',
'⊇' => '⊇',
'⊕' => '⊕',
'⊗' => '⊗',
'⊥' => '⊥',
'⋅' => '⋅',
'⌈' => '⌈',
'⌉' => '⌉',
'⌊' => '⌊',
'⌋' => '⌋',
'⟨' => '〈',
'⟩' => '〉',
'←' => '←',
'↑' => '↑',
'→' => '→',
'↓' => '↓',
'↔' => '↔',
'◊' => '◊',
'♠' => '♠',
'♣' => '♣',
'♥' => '♥',
'♦' => '♦'
);
return str_replace( array_keys($to_ncr), array_values($to_ncr), $text );
}
/**
* Formats text for the rich text editor.
*
* The filter 'richedit_pre' is applied here. If $text is empty the filter will
* be applied to an empty string.
*
* @since 2.0.0
*
* @param string $text The text to be formatted.
* @return string The formatted text after filter is applied.
*/
function wp_richedit_pre($text) {
// Filtering a blank results in an annoying <br />\n
if ( empty($text) ) return apply_filters('richedit_pre', '');
$output = convert_chars($text);
$output = wpautop($output);
$output = htmlspecialchars($output, ENT_NOQUOTES);
return apply_filters('richedit_pre', $output);
}
/**
* Formats text for the HTML editor.
*
* Unless $output is empty it will pass through htmlspecialchars before the
* 'htmledit_pre' filter is applied.
*
* @since 2.5.0
*
* @param string $output The text to be formatted.
* @return string Formatted text after filter applied.
*/
function wp_htmledit_pre($output) {
if ( !empty($output) )
$output = htmlspecialchars($output, ENT_NOQUOTES); // convert only < > &
return apply_filters('htmledit_pre', $output);
}
/**
* Checks and cleans a URL.
*
* A number of characters are removed from the URL. If the URL is for displaying
* (the default behaviour) amperstands are also replaced. The 'clean_url' filter
* is applied to the returned cleaned URL.
*
* @since 1.2.0
* @uses wp_kses_bad_protocol() To only permit protocols in the URL set
* via $protocols or the common ones set in the function.
*
* @param string $url The URL to be cleaned.
* @param array $protocols Optional. An array of acceptable protocols.
* Defaults to 'http', 'https', 'ftp', 'ftps', 'mailto', 'news', 'irc', 'gopher', 'nntp', 'feed', 'telnet' if not set.
* @param string $context Optional. How the URL will be used. Default is 'display'.
* @return string The cleaned $url after the 'cleaned_url' filter is applied.
*/
function clean_url( $url, $protocols = null, $context = 'display' ) {
$original_url = $url;
if ('' == $url) return $url;
$url = preg_replace('|[^a-z0-9-~+_.?#=!&;,/:%@$*\'()\\x80-\\xff]|i', '', $url);
$strip = array('%0d', '%0a');
$url = str_replace($strip, '', $url);
$url = str_replace(';//', '://', $url);
/* If the URL doesn't appear to contain a scheme, we
* presume it needs http:// appended (unless a relative
* link starting with / or a php file).
*/
if ( strpos($url, ':') === false &&
substr( $url, 0, 1 ) != '/' && !preg_match('/^[a-z0-9-]+?\.php/i', $url) )
$url = 'http://' . $url;
// Replace ampersands and single quotes only when displaying.
if ( 'display' == $context ) {
$url = preg_replace('/&([^#])(?![a-z]{2,8};)/', '&$1', $url);
$url = str_replace( "'", ''', $url );
}
if ( !is_array($protocols) )
$protocols = array('http', 'https', 'ftp', 'ftps', 'mailto', 'news', 'irc', 'gopher', 'nntp', 'feed', 'telnet');
if ( wp_kses_bad_protocol( $url, $protocols ) != $url )
return '';
return apply_filters('clean_url', $url, $original_url, $context);
}
/**
* Performs clean_url() for database usage.
*
* @see clean_url()
*
* @since 2.3.1
*
* @param string $url The URL to be cleaned.
* @param array $protocols An array of acceptable protocols.
* @return string The cleaned URL.
*/
function sanitize_url( $url, $protocols = null ) {
return clean_url( $url, $protocols, 'db' );
}
/**
* Convert entities, while preserving already-encoded entities.
*
* @link http://www.php.net/htmlentities Borrowed from the PHP Manual user notes.
*
* @since 1.2.2
*
* @param string $myHTML The text to be converted.
* @return string Converted text.
*/
function htmlentities2($myHTML) {
$translation_table = get_html_translation_table( HTML_ENTITIES, ENT_QUOTES );
$translation_table[chr(38)] = '&';
return preg_replace( "/&(?![A-Za-z]{0,4}\w{2,3};|#[0-9]{2,3};)/", "&", strtr($myHTML, $translation_table) );
}
/**
* Escape single quotes, specialchar double quotes, and fix line endings.
*
* The filter 'js_escape' is also applied here.
*
* @since 2.0.4
*
* @param string $text The text to be escaped.
* @return string Escaped text.
*/
function js_escape($text) {
$safe_text = wp_check_invalid_utf8( $text );
$safe_text = wp_specialchars( $safe_text, ENT_COMPAT );
$safe_text = preg_replace( '/&#(x)?0*(?(1)27|39);?/i', "'", stripslashes( $safe_text ) );
$safe_text = preg_replace( "/\r?\n/", "\\n", addslashes( $safe_text ) );
return apply_filters( 'js_escape', $safe_text, $text );
}
/**
* Escaping for HTML attributes.
*
* @since 2.0.6
*
* @param string $text
* @return string
*/
function attribute_escape( $text ) {
$safe_text = wp_check_invalid_utf8( $text );
$safe_text = wp_specialchars( $safe_text, ENT_QUOTES );
return apply_filters( 'attribute_escape', $safe_text, $text );
}
/**
* Escape a HTML tag name.
*
* @since 2.5.0
*
* @param string $tag_name
* @return string
*/
function tag_escape($tag_name) {
$safe_tag = strtolower( preg_replace('/[^a-zA-Z_:]/', '', $tag_name) );
return apply_filters('tag_escape', $safe_tag, $tag_name);
}
/**
* Escapes text for SQL LIKE special characters % and _.
*
* @since 2.5.0
*
* @param string $text The text to be escaped.
* @return string text, safe for inclusion in LIKE query.
*/
function like_escape($text) {
return str_replace(array("%", "_"), array("\\%", "\\_"), $text);
}
/**
* Convert full URL paths to absolute paths.
*
* Removes the http or https protocols and the domain. Keeps the path '/' at the
* beginning, so it isn't a true relative link, but from the web root base.
*
* @since 2.1.0
*
* @param string $link Full URL path.
* @return string Absolute path.
*/
function wp_make_link_relative( $link ) {
return preg_replace( '|https?://[^/]+(/.*)|i', '$1', $link );
}
/**
* Sanitises various option values based on the nature of the option.
*
* This is basically a switch statement which will pass $value through a number
* of functions depending on the $option.
*
* @since 2.0.5
*
* @param string $option The name of the option.
* @param string $value The unsanitised value.
* @return string Sanitized value.
*/
function sanitize_option($option, $value) {
switch ($option) {
case 'admin_email':
$value = sanitize_email($value);
break;
case 'thumbnail_size_w':
case 'thumbnail_size_h':
case 'medium_size_w':
case 'medium_size_h':
case 'large_size_w':
case 'large_size_h':
case 'default_post_edit_rows':
case 'mailserver_port':
case 'comment_max_links':
case 'page_on_front':
case 'rss_excerpt_length':
case 'default_category':
case 'default_email_category':
case 'default_link_category':
case 'close_comments_days_old':
case 'comments_per_page':
case 'thread_comments_depth':
$value = abs((int) $value);
break;
case 'posts_per_page':
case 'posts_per_rss':
$value = (int) $value;
if ( empty($value) ) $value = 1;
if ( $value < -1 ) $value = abs($value);
break;
case 'default_ping_status':
case 'default_comment_status':
// Options that if not there have 0 value but need to be something like "closed"
if ( $value == '0' || $value == '')
$value = 'closed';
break;
case 'blogdescription':
case 'blogname':
$value = addslashes($value);
$value = wp_filter_post_kses( $value ); // calls stripslashes then addslashes
$value = stripslashes($value);
$value = wp_specialchars( $value );
break;
case 'blog_charset':
$value = preg_replace('/[^a-zA-Z0-9_-]/', '', $value); // strips slashes
break;
case 'date_format':
case 'time_format':
case 'mailserver_url':
case 'mailserver_login':
case 'mailserver_pass':
case 'ping_sites':
case 'upload_path':
$value = strip_tags($value);
$value = addslashes($value);
$value = wp_filter_kses($value); // calls stripslashes then addslashes
$value = stripslashes($value);
break;
case 'gmt_offset':
$value = preg_replace('/[^0-9:.-]/', '', $value); // strips slashes
break;
case 'siteurl':
case 'home':
$value = stripslashes($value);
$value = clean_url($value);
break;
default :
$value = apply_filters("sanitize_option_{$option}", $value, $option);
break;
}
return $value;
}
/**
* Parses a string into variables to be stored in an array.
*
* Uses {@link http://www.php.net/parse_str parse_str()} and stripslashes if
* {@link http://www.php.net/magic_quotes magic_quotes_gpc} is on.
*
* @since 2.2.1
* @uses apply_filters() for the 'wp_parse_str' filter.
*
* @param string $string The string to be parsed.
* @param array $array Variables will be stored in this array.
*/
function wp_parse_str( $string, &$array ) {
parse_str( $string, $array );
if ( get_magic_quotes_gpc() )
$array = stripslashes_deep( $array );
$array = apply_filters( 'wp_parse_str', $array );
}
/**
* Convert lone less than signs.
*
* KSES already converts lone greater than signs.
*
* @uses wp_pre_kses_less_than_callback in the callback function.
* @since 2.3.0
*
* @param string $text Text to be converted.
* @return string Converted text.
*/
function wp_pre_kses_less_than( $text ) {
return preg_replace_callback('%<[^>]*?((?=<)|>|$)%', 'wp_pre_kses_less_than_callback', $text);
}
/**
* Callback function used by preg_replace.
*
* @uses wp_specialchars to format the $matches text.
* @since 2.3.0
*
* @param array $matches Populated by matches to preg_replace.
* @return string The text returned after wp_specialchars if needed.
*/
function wp_pre_kses_less_than_callback( $matches ) {
if ( false === strpos($matches[0], '>') )
return wp_specialchars($matches[0]);
return $matches[0];
}
/**
* WordPress implementation of PHP sprintf() with filters.
*
* @since 2.5.0
* @link http://www.php.net/sprintf
*
* @param string $pattern The string which formatted args are inserted.
* @param mixed $args,... Arguments to be formatted into the $pattern string.
* @return string The formatted string.
*/
function wp_sprintf( $pattern ) {
$args = func_get_args( );
$len = strlen($pattern);
$start = 0;
$result = '';
$arg_index = 0;
while ( $len > $start ) {
// Last character: append and break
if ( strlen($pattern) - 1 == $start ) {
$result .= substr($pattern, -1);
break;
}
// Literal %: append and continue
if ( substr($pattern, $start, 2) == '%%' ) {
$start += 2;
$result .= '%';
continue;
}
// Get fragment before next %
$end = strpos($pattern, '%', $start + 1);
if ( false === $end )
$end = $len;
$fragment = substr($pattern, $start, $end - $start);
// Fragment has a specifier
if ( $pattern{$start} == '%' ) {
// Find numbered arguments or take the next one in order
if ( preg_match('/^%(\d+)\$/', $fragment, $matches) ) {
$arg = isset($args[$matches[1]]) ? $args[$matches[1]] : '';
$fragment = str_replace("%{$matches[1]}$", '%', $fragment);
} else {
++$arg_index;
$arg = isset($args[$arg_index]) ? $args[$arg_index] : '';
}
// Apply filters OR sprintf
$_fragment = apply_filters( 'wp_sprintf', $fragment, $arg );
if ( $_fragment != $fragment )
$fragment = $_fragment;
else
$fragment = sprintf($fragment, strval($arg) );
}
// Append to result and move to next fragment
$result .= $fragment;
$start = $end;
}
return $result;
}
/**
* Localize list items before the rest of the content.
*
* The '%l' must be at the first characters can then contain the rest of the
* content. The list items will have ', ', ', and', and ' and ' added depending
* on the amount of list items in the $args parameter.
*
* @since 2.5.0
*
* @param string $pattern Content containing '%l' at the beginning.
* @param array $args List items to prepend to the content and replace '%l'.
* @return string Localized list items and rest of the content.
*/
function wp_sprintf_l($pattern, $args) {
// Not a match
if ( substr($pattern, 0, 2) != '%l' )
return $pattern;
// Nothing to work with
if ( empty($args) )
return '';
// Translate and filter the delimiter set (avoid ampersands and entities here)
$l = apply_filters('wp_sprintf_l', array(
'between' => _c(', |between list items'),
'between_last_two' => _c(', and |between last two list items'),
'between_only_two' => _c(' and |between only two list items'),
));
$args = (array) $args;
$result = array_shift($args);
if ( count($args) == 1 )
$result .= $l['between_only_two'] . array_shift($args);
// Loop when more than two args
$i = count($args);
while ( $i ) {
$arg = array_shift($args);
$i--;
if ( $i == 1 )
$result .= $l['between_last_two'] . $arg;
else
$result .= $l['between'] . $arg;
}
return $result . substr($pattern, 2);
}
/**
* Safely extracts not more than the first $count characters from html string.
*
* UTF-8, tags and entities safe prefix extraction. Entities inside will *NOT*
* be counted as one character. For example & will be counted as 4, < as
* 3, etc.
*
* @since 2.5.0
*
* @param integer $str String to get the excerpt from.
* @param integer $count Maximum number of characters to take.
* @return string The excerpt.
*/
function wp_html_excerpt( $str, $count ) {
$str = strip_tags( $str );
$str = mb_strcut( $str, 0, $count );
// remove part of an entity at the end
$str = preg_replace( '/&[^;\s]{0,6}$/', '', $str );
return $str;
}
/**
* Add a Base url to relative links in passed content.
*
* By default it supports the 'src' and 'href' attributes. However this can be
* changed via the 3rd param.
*
* @since 2.7.0
*
* @param string $content String to search for links in.
* @param string $base The base URL to prefix to links.
* @param array $attrs The attributes which should be processed.
* @return string The processed content.
*/
function links_add_base_url( $content, $base, $attrs = array('src', 'href') ) {
$attrs = implode('|', (array)$attrs);
return preg_replace_callback("!($attrs)=(['\"])(.+?)\\2!i",
create_function('$m', 'return _links_add_base($m, "' . $base . '");'),
$content);
}
/**
* Callback to add a base url to relative links in passed content.
*
* @since 2.7.0
* @access private
*
* @param string $m The matched link.
* @param string $base The base URL to prefix to links.
* @return string The processed link.
*/
function _links_add_base($m, $base) {
//1 = attribute name 2 = quotation mark 3 = URL
return $m[1] . '=' . $m[2] .
(strpos($m[3], 'http://') === false ?
path_join($base, $m[3]) :
$m[3])
. $m[2];
}
/**
* Adds a Target attribute to all links in passed content.
*
* This function by default only applies to <a> tags, however this can be
* modified by the 3rd param.
*
* <b>NOTE:</b> Any current target attributed will be striped and replaced.
*
* @since 2.7.0
*
* @param string $content String to search for links in.
* @param string $target The Target to add to the links.
* @param array $tags An array of tags to apply to.
* @return string The processed content.
*/
function links_add_target( $content, $target = '_blank', $tags = array('a') ) {
$tags = implode('|', (array)$tags);
return preg_replace_callback("!<($tags)(.+?)>!i",
create_function('$m', 'return _links_add_target($m, "' . $target . '");'),
$content);
}
/**
* Callback to add a target attribute to all links in passed content.
*
* @since 2.7.0
* @access private
*
* @param string $m The matched link.
* @param string $target The Target to add to the links.
* @return string The processed link.
*/
function _links_add_target( $m, $target ) {
$tag = $m[1];
$link = preg_replace('|(target=[\'"](.*?)[\'"])|i', '', $m[2]);
return '<' . $tag . $link . ' target="' . $target . '">';
}
// normalize EOL characters and strip duplicate whitespace
function normalize_whitespace( $str ) {
$str = trim($str);
$str = str_replace("\r", "\n", $str);
$str = preg_replace( array( '/\n+/', '/[ \t]+/' ), array( "\n", ' ' ), $str );
return $str;
}
?>
waterwise-wp/wp-includes/plugin.php 0000644 0001033 0000041 00000056063 11107610233 017555 0 ustar robert www-data <?php
/**
* The plugin API is located in this file, which allows for creating actions
* and filters and hooking functions, and methods. The functions or methods will
* then be run when the action or filter is called.
*
* The API callback examples reference functions, but can be methods of classes.
* To hook methods, you'll need to pass an array one of two ways.
*
* Any of the syntaxes explained in the PHP documentation for the
* {@link http://us2.php.net/manual/en/language.pseudo-types.php#language.types.callback 'callback'}
* type are valid.
*
* Also see the {@link http://codex.wordpress.org/Plugin_API Plugin API} for
* more information and examples on how to use a lot of these functions.
*
* @package WordPress
* @subpackage Plugin
* @since 1.5
*/
/**
* Hooks a function or method to a specific filter action.
*
* Filters are the hooks that WordPress launches to modify text of various types
* before adding it to the database or sending it to the browser screen. Plugins
* can specify that one or more of its PHP functions is executed to
* modify specific types of text at these times, using the Filter API.
*
* To use the API, the following code should be used to bind a callback to the
* filter.
*
* <code>
* function example_hook($example) { echo $example; }
* add_filter('example_filter', 'example_hook');
* </code>
*
* In WordPress 1.5.1+, hooked functions can take extra arguments that are set
* when the matching do_action() or apply_filters() call is run. The
* $accepted_args allow for calling functions only when the number of args
* match. Hooked functions can take extra arguments that are set when the
* matching do_action() or apply_filters() call is run. For example, the action
* comment_id_not_found will pass any functions that hook onto it the ID of the
* requested comment.
*
* <strong>Note:</strong> the function will return true no matter if the
* function was hooked fails or not. There are no checks for whether the
* function exists beforehand and no checks to whether the <tt>$function_to_add
* is even a string. It is up to you to take care and this is done for
* optimization purposes, so everything is as quick as possible.
*
* @package WordPress
* @subpackage Plugin
* @since 0.71
* @global array $wp_filter Stores all of the filters added in the form of
* wp_filter['tag']['array of priorities']['array of functions serialized']['array of ['array (functions, accepted_args)]']
* @global array $merged_filters Tracks the tags that need to be merged for later. If the hook is added, it doesn't need to run through that process.
*
* @param string $tag The name of the filter to hook the $function_to_add to.
* @param callback $function_to_add The name of the function to be called when the filter is applied.
* @param int $priority optional. Used to specify the order in which the functions associated with a particular action are executed (default: 10). Lower numbers correspond with earlier execution, and functions with the same priority are executed in the order in which they were added to the action.
* @param int $accepted_args optional. The number of arguments the function accept (default 1).
* @return boolean true
*/
function add_filter($tag, $function_to_add, $priority = 10, $accepted_args = 1) {
global $wp_filter, $merged_filters;
$idx = _wp_filter_build_unique_id($tag, $function_to_add, $priority);
$wp_filter[$tag][$priority][$idx] = array('function' => $function_to_add, 'accepted_args' => $accepted_args);
unset( $merged_filters[ $tag ] );
return true;
}
/**
* Check if any filter has been registered for a hook.
*
* @package WordPress
* @subpackage Plugin
* @since 2.5
* @global array $wp_filter Stores all of the filters
*
* @param string $tag The name of the filter hook.
* @param callback $function_to_check optional. If specified, return the priority of that function on this hook or false if not attached.
* @return int|boolean Optionally returns the priority on that hook for the specified function.
*/
function has_filter($tag, $function_to_check = false) {
global $wp_filter;
$has = !empty($wp_filter[$tag]);
if ( false === $function_to_check || false == $has )
return $has;
if ( !$idx = _wp_filter_build_unique_id($tag, $function_to_check, false) )
return false;
foreach ( (array) array_keys($wp_filter[$tag]) as $priority ) {
if ( isset($wp_filter[$tag][$priority][$idx]) )
return $priority;
}
return false;
}
/**
* Call the functions added to a filter hook.
*
* The callback functions attached to filter hook $tag are invoked by calling
* this function. This function can be used to create a new filter hook by
* simply calling this function with the name of the new hook specified using
* the $tag parameter.
*
* The function allows for additional arguments to be added and passed to hooks.
* <code>
* function example_hook($string, $arg1, $arg2)
* {
* //Do stuff
* return $string;
* }
* $value = apply_filters('example_filter', 'filter me', 'arg1', 'arg2');
* </code>
*
* @package WordPress
* @subpackage Plugin
* @since 0.71
* @global array $wp_filter Stores all of the filters
* @global array $merged_filters Merges the filter hooks using this function.
* @global array $wp_current_filter stores the list of current filters with the current one last
*
* @param string $tag The name of the filter hook.
* @param mixed $value The value on which the filters hooked to <tt>$tag</tt> are applied on.
* @param mixed $var,... Additional variables passed to the functions hooked to <tt>$tag</tt>.
* @return mixed The filtered value after all hooked functions are applied to it.
*/
function apply_filters($tag, $value) {
global $wp_filter, $merged_filters, $wp_current_filter;
$args = array();
$wp_current_filter[] = $tag;
// Do 'all' actions first
if ( isset($wp_filter['all']) ) {
$args = func_get_args();
_wp_call_all_hook($args);
}
if ( !isset($wp_filter[$tag]) ) {
array_pop($wp_current_filter);
return $value;
}
// Sort
if ( !isset( $merged_filters[ $tag ] ) ) {
ksort($wp_filter[$tag]);
$merged_filters[ $tag ] = true;
}
reset( $wp_filter[ $tag ] );
if ( empty($args) )
$args = func_get_args();
do {
foreach( (array) current($wp_filter[$tag]) as $the_ )
if ( !is_null($the_['function']) ){
$args[1] = $value;
$value = call_user_func_array($the_['function'], array_slice($args, 1, (int) $the_['accepted_args']));
}
} while ( next($wp_filter[$tag]) !== false );
array_pop( $wp_current_filter );
return $value;
}
/**
* Removes a function from a specified filter hook.
*
* This function removes a function attached to a specified filter hook. This
* method can be used to remove default functions attached to a specific filter
* hook and possibly replace them with a substitute.
*
* To remove a hook, the $function_to_remove and $priority arguments must match
* when the hook was added. This goes for both filters and actions. No warning
* will be given on removal failure.
*
* @package WordPress
* @subpackage Plugin
* @since 1.2
*
* @param string $tag The filter hook to which the function to be removed is hooked.
* @param callback $function_to_remove The name of the function which should be removed.
* @param int $priority optional. The priority of the function (default: 10).
* @param int $accepted_args optional. The number of arguments the function accpets (default: 1).
* @return boolean Whether the function existed before it was removed.
*/
function remove_filter($tag, $function_to_remove, $priority = 10, $accepted_args = 1) {
$function_to_remove = _wp_filter_build_unique_id($tag, $function_to_remove, $priority);
$r = isset($GLOBALS['wp_filter'][$tag][$priority][$function_to_remove]);
if ( true === $r) {
unset($GLOBALS['wp_filter'][$tag][$priority][$function_to_remove]);
if ( empty($GLOBALS['wp_filter'][$tag][$priority]) )
unset($GLOBALS['wp_filter'][$tag][$priority]);
unset($GLOBALS['merged_filters'][$tag]);
}
return $r;
}
/**
* Remove all of the hooks from a filter.
*
* @since 2.7
*
* @param string $tag The filter to remove hooks from.
* @param int $priority The priority number to remove.
* @return bool True when finished.
*/
function remove_all_filters($tag, $priority = false) {
global $wp_filter, $merged_filters;
if( isset($wp_filter[$tag]) ) {
if( false !== $priority && isset($$wp_filter[$tag][$priority]) )
unset($wp_filter[$tag][$priority]);
else
unset($wp_filter[$tag]);
}
if( isset($merged_filters[$tag]) )
unset($merged_filters[$tag]);
return true;
}
/**
* Retrieve the name of the current filter or action.
*
* @package WordPress
* @subpackage Plugin
* @since 2.5
*
* @return string Hook name of the current filter or action.
*/
function current_filter() {
global $wp_current_filter;
return end( $wp_current_filter );
}
/**
* Hooks a function on to a specific action.
*
* Actions are the hooks that the WordPress core launches at specific points
* during execution, or when specific events occur. Plugins can specify that
* one or more of its PHP functions are executed at these points, using the
* Action API.
*
* @uses add_filter() Adds an action. Parameter list and functionality are the same.
*
* @package WordPress
* @subpackage Plugin
* @since 1.2
*
* @param string $tag The name of the action to which the $function_to_add is hooked.
* @param callback $function_to_add The name of the function you wish to be called.
* @param int $priority optional. Used to specify the order in which the functions associated with a particular action are executed (default: 10). Lower numbers correspond with earlier execution, and functions with the same priority are executed in the order in which they were added to the action.
* @param int $accepted_args optional. The number of arguments the function accept (default 1).
*/
function add_action($tag, $function_to_add, $priority = 10, $accepted_args = 1) {
return add_filter($tag, $function_to_add, $priority, $accepted_args);
}
/**
* Execute functions hooked on a specific action hook.
*
* This function invokes all functions attached to action hook $tag. It is
* possible to create new action hooks by simply calling this function,
* specifying the name of the new hook using the <tt>$tag</tt> parameter.
*
* You can pass extra arguments to the hooks, much like you can with
* apply_filters().
*
* @see apply_filters() This function works similar with the exception that
* nothing is returned and only the functions or methods are called.
*
* @package WordPress
* @subpackage Plugin
* @since 1.2
* @global array $wp_filter Stores all of the filters
* @global array $wp_actions Increments the amount of times action was triggered.
*
* @param string $tag The name of the action to be executed.
* @param mixed $arg,... Optional additional arguments which are passed on to the functions hooked to the action.
* @return null Will return null if $tag does not exist in $wp_filter array
*/
function do_action($tag, $arg = '') {
global $wp_filter, $wp_actions, $merged_filters, $wp_current_filter;
if ( is_array($wp_actions) )
$wp_actions[] = $tag;
else
$wp_actions = array($tag);
$wp_current_filter[] = $tag;
// Do 'all' actions first
if ( isset($wp_filter['all']) ) {
$all_args = func_get_args();
_wp_call_all_hook($all_args);
}
if ( !isset($wp_filter[$tag]) ) {
array_pop($wp_current_filter);
return;
}
$args = array();
if ( is_array($arg) && 1 == count($arg) && is_object($arg[0]) ) // array(&$this)
$args[] =& $arg[0];
else
$args[] = $arg;
for ( $a = 2; $a < func_num_args(); $a++ )
$args[] = func_get_arg($a);
// Sort
if ( !isset( $merged_filters[ $tag ] ) ) {
ksort($wp_filter[$tag]);
$merged_filters[ $tag ] = true;
}
reset( $wp_filter[ $tag ] );
do {
foreach ( (array) current($wp_filter[$tag]) as $the_ )
if ( !is_null($the_['function']) )
call_user_func_array($the_['function'], array_slice($args, 0, (int) $the_['accepted_args']));
} while ( next($wp_filter[$tag]) !== false );
array_pop($wp_current_filter);
}
/**
* Retrieve the number times an action is fired.
*
* @package WordPress
* @subpackage Plugin
* @since 2.1
* @global array $wp_actions Increments the amount of times action was triggered.
*
* @param string $tag The name of the action hook.
* @return int The number of times action hook <tt>$tag</tt> is fired
*/
function did_action($tag) {
global $wp_actions;
if ( empty($wp_actions) )
return 0;
return count(array_keys($wp_actions, $tag));
}
/**
* Execute functions hooked on a specific action hook, specifying arguments in an array.
*
* @see do_action() This function is identical, but the arguments passed to the
* functions hooked to <tt>$tag</tt> are supplied using an array.
*
* @package WordPress
* @subpackage Plugin
* @since 2.1
* @global array $wp_filter Stores all of the filters
* @global array $wp_actions Increments the amount of times action was triggered.
*
* @param string $tag The name of the action to be executed.
* @param array $args The arguments supplied to the functions hooked to <tt>$tag</tt>
* @return null Will return null if $tag does not exist in $wp_filter array
*/
function do_action_ref_array($tag, $args) {
global $wp_filter, $wp_actions, $merged_filters, $wp_current_filter;
if ( !is_array($wp_actions) )
$wp_actions = array($tag);
else
$wp_actions[] = $tag;
$wp_current_filter[] = $tag;
// Do 'all' actions first
if ( isset($wp_filter['all']) ) {
$all_args = func_get_args();
_wp_call_all_hook($all_args);
}
if ( !isset($wp_filter[$tag]) ) {
array_pop($wp_current_filter);
return;
}
// Sort
if ( !isset( $merged_filters[ $tag ] ) ) {
ksort($wp_filter[$tag]);
$merged_filters[ $tag ] = true;
}
reset( $wp_filter[ $tag ] );
do {
foreach( (array) current($wp_filter[$tag]) as $the_ )
if ( !is_null($the_['function']) )
call_user_func_array($the_['function'], array_slice($args, 0, (int) $the_['accepted_args']));
} while ( next($wp_filter[$tag]) !== false );
array_pop($wp_current_filter);
}
/**
* Check if any action has been registered for a hook.
*
* @package WordPress
* @subpackage Plugin
* @since 2.5
* @see has_filter() has_action() is an alias of has_filter().
*
* @param string $tag The name of the action hook.
* @param callback $function_to_check optional. If specified, return the priority of that function on this hook or false if not attached.
* @return int|boolean Optionally returns the priority on that hook for the specified function.
*/
function has_action($tag, $function_to_check = false) {
return has_filter($tag, $function_to_check);
}
/**
* Removes a function from a specified action hook.
*
* This function removes a function attached to a specified action hook. This
* method can be used to remove default functions attached to a specific filter
* hook and possibly replace them with a substitute.
*
* @package WordPress
* @subpackage Plugin
* @since 1.2
*
* @param string $tag The action hook to which the function to be removed is hooked.
* @param callback $function_to_remove The name of the function which should be removed.
* @param int $priority optional The priority of the function (default: 10).
* @param int $accepted_args optional. The number of arguments the function accpets (default: 1).
* @return boolean Whether the function is removed.
*/
function remove_action($tag, $function_to_remove, $priority = 10, $accepted_args = 1) {
return remove_filter($tag, $function_to_remove, $priority, $accepted_args);
}
/**
* Remove all of the hooks from an action.
*
* @since 2.7
*
* @param string $tag The action to remove hooks from.
* @param int $priority The priority number to remove them from.
* @return bool True when finished.
*/
function remove_all_actions($tag, $priority = false) {
return remove_all_filters($tag, $priority);
}
//
// Functions for handling plugins.
//
/**
* Gets the basename of a plugin.
*
* This method extracts the name of a plugin from its filename.
*
* @package WordPress
* @subpackage Plugin
* @since 1.5
*
* @access private
*
* @param string $file The filename of plugin.
* @return string The name of a plugin.
* @uses WP_PLUGIN_DIR
*/
function plugin_basename($file) {
$file = str_replace('\\','/',$file); // sanitize for Win32 installs
$file = preg_replace('|/+|','/', $file); // remove any duplicate slash
$plugin_dir = str_replace('\\','/',WP_PLUGIN_DIR); // sanitize for Win32 installs
$plugin_dir = preg_replace('|/+|','/', $plugin_dir); // remove any duplicate slash
$file = preg_replace('|^' . preg_quote($plugin_dir, '|') . '/|','',$file); // get relative path from plugins dir
return $file;
}
/**
* Set the activation hook for a plugin.
*
* When a plugin is activated, the action 'activate_PLUGINNAME' hook is
* activated. In the name of this hook, PLUGINNAME is replaced with the name of
* the plugin, including the optional subdirectory. For example, when the plugin
* is located in wp-content/plugin/sampleplugin/sample.php, then the name of
* this hook will become 'activate_sampleplugin/sample.php'. When the plugin
* consists of only one file and is (as by default) located at
* wp-content/plugin/sample.php the name of this hook will be
* 'activate_sample.php'.
*
* @package WordPress
* @subpackage Plugin
* @since 2.0
*
* @access private
*
* @param string $file The filename of the plugin including the path.
* @param callback $function the function hooked to the 'activate_PLUGIN' action.
*/
function register_activation_hook($file, $function) {
$file = plugin_basename($file);
add_action('activate_' . $file, $function);
}
/**
* Set the deactivation hook for a plugin.
*
* When a plugin is deactivated, the action 'deactivate_PLUGINNAME' hook is
* deactivated. In the name of this hook, PLUGINNAME is replaced with the name
* of the plugin, including the optional subdirectory. For example, when the
* plugin is located in wp-content/plugin/sampleplugin/sample.php, then
* the name of this hook will become 'activate_sampleplugin/sample.php'.
*
* When the plugin consists of only one file and is (as by default) located at
* wp-content/plugin/sample.php the name of this hook will be
* 'activate_sample.php'.
*
* @package WordPress
* @subpackage Plugin
* @since 2.0
*
* @access private
*
* @param string $file The filename of the plugin including the path.
* @param callback $function the function hooked to the 'activate_PLUGIN' action.
*/
function register_deactivation_hook($file, $function) {
$file = plugin_basename($file);
add_action('deactivate_' . $file, $function);
}
/**
* Set the uninstallation hook for a plugin.
*
* Registers the uninstall hook that will be called when the user clicks on the
* uninstall link that calls for the plugin to uninstall itself. The link won't
* be active unless the plugin hooks into the action.
*
* The plugin should not run arbitrary code outside of functions, when
* registering the uninstall hook. In order to run using the hook, the plugin
* will have to be included, which means that any code laying outside of a
* function will be run during the uninstall process. The plugin should not
* hinder the uninstall process.
*
* If the plugin can not be written without running code within the plugin, then
* the plugin should create a file named 'uninstall.php' in the base plugin
* folder. This file will be called, if it exists, during the uninstall process
* bypassing the uninstall hook. The plugin, when using the 'uninstall.php'
* should always check for the 'WP_UNINSTALL_PLUGIN' constant, before
* executing.
*
* @since 2.7
*
* @param string $file
* @param callback $callback The callback to run when the hook is called.
*/
function register_uninstall_hook($file, $callback) {
// The option should not be autoloaded, because it is not needed in most
// cases. Emphasis should be put on using the 'uninstall.php' way of
// uninstalling the plugin.
$uninstallable_plugins = (array) get_option('uninstall_plugins');
$uninstallable_plugins[plugin_basename($file)] = $callback;
update_option('uninstall_plugins', $uninstallable_plugins);
}
/**
* Calls the 'all' hook, which will process the functions hooked into it.
*
* The 'all' hook passes all of the arguments or parameters that were used for
* the hook, which this function was called for.
*
* This function is used internally for apply_filters(), do_action(), and
* do_action_ref_array() and is not meant to be used from outside those
* functions. This function does not check for the existence of the all hook, so
* it will fail unless the all hook exists prior to this function call.
*
* @package WordPress
* @subpackage Plugin
* @since 2.5
* @access private
*
* @uses $wp_filter Used to process all of the functions in the 'all' hook
*
* @param array $args The collected parameters from the hook that was called.
* @param string $hook Optional. The hook name that was used to call the 'all' hook.
*/
function _wp_call_all_hook($args) {
global $wp_filter;
reset( $wp_filter['all'] );
do {
foreach( (array) current($wp_filter['all']) as $the_ )
if ( !is_null($the_['function']) )
call_user_func_array($the_['function'], $args);
} while ( next($wp_filter['all']) !== false );
}
/**
* Build Unique ID for storage and retrieval.
*
* The old way to serialize the callback caused issues and this function is the
* solution. It works by checking for objects and creating an a new property in
* the class to keep track of the object and new objects of the same class that
* need to be added.
*
* It also allows for the removal of actions and filters for objects after they
* change class properties. It is possible to include the property $wp_filter_id
* in your class and set it to "null" or a number to bypass the workaround.
* However this will prevent you from adding new classes and any new classes
* will overwrite the previous hook by the same class.
*
* Functions and static method callbacks are just returned as strings and
* shouldn't have any speed penalty.
*
* @package WordPress
* @subpackage Plugin
* @access private
* @since 2.2.3
* @link http://trac.wordpress.org/ticket/3875
*
* @global array $wp_filter Storage for all of the filters and actions
* @param string $tag Used in counting how many hooks were applied
* @param string|array $function Used for creating unique id
* @param int|bool $priority Used in counting how many hooks were applied. If === false and $function is an object reference, we return the unique id only if it already has one, false otherwise.
* @param string $type filter or action
* @return string Unique ID for usage as array key
*/
function _wp_filter_build_unique_id($tag, $function, $priority) {
global $wp_filter;
// If function then just skip all of the tests and not overwrite the following.
if ( is_string($function) )
return $function;
// Object Class Calling
else if (is_object($function[0]) ) {
$obj_idx = get_class($function[0]).$function[1];
if ( !isset($function[0]->wp_filter_id) ) {
if ( false === $priority )
return false;
$count = isset($wp_filter[$tag][$priority]) ? count((array)$wp_filter[$tag][$priority]) : 0;
$function[0]->wp_filter_id = $count;
$obj_idx .= $count;
unset($count);
} else
$obj_idx .= $function[0]->wp_filter_id;
return $obj_idx;
}
// Static Calling
else if ( is_string($function[0]) )
return $function[0].$function[1];
}
?>
waterwise-wp/wp-includes/vars.php 0000644 0001033 0000041 00000005324 11115225366 017234 0 ustar robert www-data <?php
/**
* Creates common globals for the rest of WordPress
*
* Sets $pagenow global which is the current page. Checks
* for the browser to set which one is currently being used.
*
* Detects which user environment WordPress is being used on.
* Only attempts to check for Apache and IIS. Two web servers
* with known permalink capability.
*
* @package WordPress
*/
// On which page are we ?
if ( is_admin() ) {
// wp-admin pages are checked more carefully
preg_match('#/wp-admin/?(.*?)$#i', $PHP_SELF, $self_matches);
$pagenow = $self_matches[1];
$pagenow = preg_replace('#\?.*?$#', '', $pagenow);
if ( '' === $pagenow || 'index' === $pagenow || 'index.php' === $pagenow ) {
$pagenow = 'index.php';
} else {
preg_match('#(.*?)(/|$)#', $pagenow, $self_matches);
$pagenow = strtolower($self_matches[1]);
if ( '.php' !== substr($pagenow, -4, 4) )
$pagenow .= '.php'; // for Options +Multiviews: /wp-admin/themes/index.php (themes.php is queried)
}
} else {
if ( preg_match('#([^/]+\.php)([?/].*?)?$#i', $PHP_SELF, $self_matches) )
$pagenow = strtolower($self_matches[1]);
else
$pagenow = 'index.php';
}
// Simple browser detection
$is_lynx = $is_gecko = $is_winIE = $is_macIE = $is_opera = $is_NS4 = $is_safari = $is_chrome = $is_iphone = false;
if (strpos($_SERVER['HTTP_USER_AGENT'], 'Lynx') !== false) {
$is_lynx = true;
} elseif ( strpos(strtolower($_SERVER['HTTP_USER_AGENT']), 'chrome') !== false ) {
$is_chrome = true;
} elseif ( strpos(strtolower($_SERVER['HTTP_USER_AGENT']), 'safari') !== false ) {
$is_safari = true;
} elseif (strpos($_SERVER['HTTP_USER_AGENT'], 'Gecko') !== false) {
$is_gecko = true;
} elseif (strpos($_SERVER['HTTP_USER_AGENT'], 'MSIE') !== false && strpos($_SERVER['HTTP_USER_AGENT'], 'Win') !== false) {
$is_winIE = true;
} elseif (strpos($_SERVER['HTTP_USER_AGENT'], 'MSIE') !== false && strpos($_SERVER['HTTP_USER_AGENT'], 'Mac') !== false) {
$is_macIE = true;
} elseif (strpos($_SERVER['HTTP_USER_AGENT'], 'Opera') !== false) {
$is_opera = true;
} elseif (strpos($_SERVER['HTTP_USER_AGENT'], 'Nav') !== false && strpos($_SERVER['HTTP_USER_AGENT'], 'Mozilla/4.') !== false) {
$is_NS4 = true;
}
if ( $is_safari && strpos(strtolower($_SERVER['HTTP_USER_AGENT']), 'mobile') !== false )
$is_iphone = true;
$is_IE = ( $is_macIE || $is_winIE );
// Server detection
/**
* Whether the server software is Apache or something else
* @global bool $is_apache
*/
$is_apache = ((strpos($_SERVER['SERVER_SOFTWARE'], 'Apache') !== false) || (strpos($_SERVER['SERVER_SOFTWARE'], 'LiteSpeed') !== false)) ? true : false;
/**
* Whether the server software is IIS or something else
* @global bool $is_IIS
*/
$is_IIS = (strpos($_SERVER['SERVER_SOFTWARE'], 'Microsoft-IIS') !== false) ? true : false;
?> waterwise-wp/wp-includes/script-loader.php 0000644 0001033 0000041 00000051245 11136601033 021024 0 ustar robert www-data <?php
/**
* WordPress scripts and styles default loader.
*
* Most of the functionality that existed here was moved to
* {@link http://backpress.automattic.com/ BackPress}. WordPress themes and
* plugins will only be concerned about the filters and actions set in this
* file.
*
* @package WordPress
*/
/** BackPress: WordPress Dependencies Class */
require( ABSPATH . WPINC . '/class.wp-dependencies.php' );
/** BackPress: WordPress Scripts Class */
require( ABSPATH . WPINC . '/class.wp-scripts.php' );
/** BackPress: WordPress Scripts Functions */
require( ABSPATH . WPINC . '/functions.wp-scripts.php' );
/** BackPress: WordPress Styles Class */
require( ABSPATH . WPINC . '/class.wp-styles.php' );
/** BackPress: WordPress Styles Functions */
require( ABSPATH . WPINC . '/functions.wp-styles.php' );
/**
* Setup WordPress scripts to load by default for Administration Panels.
*
* Localizes a few of the scripts.
*
* @since 2.6.0
*
* @param object $scripts WP_Scripts object.
*/
function wp_default_scripts( &$scripts ) {
if (!$guessurl = site_url())
$guessurl = wp_guess_url();
$scripts->base_url = $guessurl;
$scripts->default_version = get_bloginfo( 'version' );
$scripts->add( 'common', '/wp-admin/js/common.js', array('jquery', 'hoverIntent'), '20081210' );
$scripts->add( 'sack', '/wp-includes/js/tw-sack.js', false, '1.6.1' );
$scripts->add( 'quicktags', '/wp-includes/js/quicktags.js', false, '20081210' );
$scripts->localize( 'quicktags', 'quicktagsL10n', array(
'quickLinks' => __('(Quick Links)'),
'wordLookup' => __('Enter a word to look up:'),
'dictionaryLookup' => attribute_escape(__('Dictionary lookup')),
'lookup' => attribute_escape(__('lookup')),
'closeAllOpenTags' => attribute_escape(__('Close all open tags')),
'closeTags' => attribute_escape(__('close tags')),
'enterURL' => __('Enter the URL'),
'enterImageURL' => __('Enter the URL of the image'),
'enterImageDescription' => __('Enter a description of the image'),
'l10n_print_after' => 'try{convertEntities(quicktagsL10n);}catch(e){};'
) );
$scripts->add( 'colorpicker', '/wp-includes/js/colorpicker.js', array('prototype'), '3517' );
// Modify this version when tinyMCE plugins are changed.
function mce_version() {
return '20081129';
}
add_filter( 'tiny_mce_version', 'mce_version' );
$scripts->add( 'editor', '/wp-admin/js/editor.js', false, mce_version() );
$scripts->add( 'prototype', '/wp-includes/js/prototype.js', false, '1.6');
$scripts->add( 'wp-ajax-response', '/wp-includes/js/wp-ajax-response.js', array('jquery'), '20081210' );
$scripts->localize( 'wp-ajax-response', 'wpAjax', array(
'noPerm' => __('You do not have permission to do that.'),
'broken' => __('An unidentified error has occurred.'),
'l10n_print_after' => 'try{convertEntities(wpAjax);}catch(e){};'
) );
$scripts->add( 'autosave', '/wp-includes/js/autosave.js', array('schedule', 'wp-ajax-response'), '20081210' );
$scripts->add( 'wp-lists', '/wp-includes/js/wp-lists.js', array('wp-ajax-response'), '20081210' );
$scripts->localize( 'wp-lists', 'wpListL10n', array(
'url' => admin_url('admin-ajax.php')
) );
$scripts->add( 'scriptaculous-root', '/wp-includes/js/scriptaculous/wp-scriptaculous.js', array('prototype'), '1.8.0');
$scripts->add( 'scriptaculous-builder', '/wp-includes/js/scriptaculous/builder.js', array('scriptaculous-root'), '1.8.0');
$scripts->add( 'scriptaculous-dragdrop', '/wp-includes/js/scriptaculous/dragdrop.js', array('scriptaculous-builder', 'scriptaculous-effects'), '1.8.0');
$scripts->add( 'scriptaculous-effects', '/wp-includes/js/scriptaculous/effects.js', array('scriptaculous-root'), '1.8.0');
$scripts->add( 'scriptaculous-slider', '/wp-includes/js/scriptaculous/slider.js', array('scriptaculous-effects'), '1.8.0');
$scripts->add( 'scriptaculous-sound', '/wp-includes/js/scriptaculous/sound.js', array( 'scriptaculous-root' ), '1.8.0' );
$scripts->add( 'scriptaculous-controls', '/wp-includes/js/scriptaculous/controls.js', array('scriptaculous-root'), '1.8.0');
$scripts->add( 'scriptaculous', '', array('scriptaculous-dragdrop', 'scriptaculous-slider', 'scriptaculous-controls'), '1.8.0');
$scripts->add( 'cropper', '/wp-includes/js/crop/cropper.js', array('scriptaculous-dragdrop'), '20070118');
$scripts->add( 'jquery', '/wp-includes/js/jquery/jquery.js', false, '1.2.6');
$scripts->add( 'jquery-form', '/wp-includes/js/jquery/jquery.form.js', array('jquery'), '2.02');
$scripts->add( 'jquery-color', '/wp-includes/js/jquery/jquery.color.js', array('jquery'), '2.0-4561');
$scripts->add( 'interface', '/wp-includes/js/jquery/interface.js', array('jquery'), '1.2' );
$scripts->add( 'suggest', '/wp-includes/js/jquery/suggest.js', array('jquery'), '1.1b');
$scripts->add( 'schedule', '/wp-includes/js/jquery/jquery.schedule.js', array('jquery'), '20');
$scripts->add( 'jquery-hotkeys', '/wp-includes/js/jquery/jquery.hotkeys.js', array('jquery'), '0.0.2' );
$scripts->add( 'jquery-table-hotkeys', '/wp-includes/js/jquery/jquery.table-hotkeys.js', array('jquery', 'jquery-hotkeys'), '20081128' );
$scripts->add( 'thickbox', '/wp-includes/js/thickbox/thickbox.js', array('jquery'), '3.1-20090123');
$scripts->add( 'swfupload', '/wp-includes/js/swfupload/swfupload.js', false, '2.2.0-20081031');
$scripts->add( 'swfupload-degrade', '/wp-includes/js/swfupload/plugins/swfupload.graceful_degradation.js', array('swfupload'), '2.2.0-20081031');
$scripts->add( 'swfupload-swfobject', '/wp-includes/js/swfupload/plugins/swfupload.swfobject.js', array('swfupload'), '2.2.0-20081031');
$scripts->localize( 'swfupload-degrade', 'uploadDegradeOptions', array(
'is_lighttpd_before_150' => is_lighttpd_before_150(),
) );
$scripts->add( 'swfupload-queue', '/wp-includes/js/swfupload/plugins/swfupload.queue.js', array('swfupload'), '2.2.0-20081031');
$scripts->add( 'swfupload-handlers', '/wp-includes/js/swfupload/handlers.js', array('swfupload'), '2.2.0-20081201');
// these error messages came from the sample swfupload js, they might need changing.
$scripts->localize( 'swfupload-handlers', 'swfuploadL10n', array(
'queue_limit_exceeded' => __('You have attempted to queue too many files.'),
'file_exceeds_size_limit' => sprintf(__('This file is too big. Your php.ini upload_max_filesize is %s.'), @ini_get('upload_max_filesize')),
'zero_byte_file' => __('This file is empty. Please try another.'),
'invalid_filetype' => __('This file type is not allowed. Please try another.'),
'default_error' => __('An error occurred in the upload. Please try again later.'),
'missing_upload_url' => __('There was a configuration error. Please contact the server administrator.'),
'upload_limit_exceeded' => __('You may only upload 1 file.'),
'http_error' => __('HTTP error.'),
'upload_failed' => __('Upload failed.'),
'io_error' => __('IO error.'),
'security_error' => __('Security error.'),
'file_cancelled' => __('File cancelled.'),
'upload_stopped' => __('Upload stopped.'),
'dismiss' => __('Dismiss'),
'crunching' => __('Crunching…'),
'deleted' => __('Deleted'),
'l10n_print_after' => 'try{convertEntities(swfuploadL10n);}catch(e){};'
) );
$scripts->add( 'jquery-ui-core', '/wp-includes/js/jquery/ui.core.js', array('jquery'), '1.5.2' );
$scripts->add( 'jquery-ui-tabs', '/wp-includes/js/jquery/ui.tabs.js', array('jquery-ui-core'), '1.5.2' );
$scripts->add( 'jquery-ui-sortable', '/wp-includes/js/jquery/ui.sortable.js', array('jquery-ui-core'), '1.5.2c' );
$scripts->add( 'jquery-ui-draggable', '/wp-includes/js/jquery/ui.draggable.js', array('jquery-ui-core'), '1.5.2' );
$scripts->add( 'jquery-ui-resizable', '/wp-includes/js/jquery/ui.resizable.js', array('jquery-ui-core'), '1.5.2' );
$scripts->add( 'jquery-ui-dialog', '/wp-includes/js/jquery/ui.dialog.js', array('jquery-ui-resizable', 'jquery-ui-draggable'), '1.5.2' );
$scripts->add( 'comment-reply', '/wp-includes/js/comment-reply.js', false, '20081210');
if ( is_admin() ) {
$scripts->add( 'ajaxcat', '/wp-admin/js/cat.js', array( 'wp-lists' ), '20081210' );
$scripts->localize( 'ajaxcat', 'catL10n', array(
'add' => attribute_escape(__('Add')),
'how' => __('Separate multiple categories with commas.'),
'l10n_print_after' => 'try{convertEntities(catL10n);}catch(e){};'
) );
$scripts->add( 'admin-categories', '/wp-admin/js/categories.js', array('wp-lists'), '20081210' );
$scripts->add( 'admin-tags', '/wp-admin/js/tags.js', array('wp-lists'), '20081210' );
$scripts->add( 'admin-custom-fields', '/wp-admin/js/custom-fields.js', array('wp-lists'), '20081210' );
$scripts->add( 'password-strength-meter', '/wp-admin/js/password-strength-meter.js', array('jquery'), '20081210' );
$scripts->localize( 'password-strength-meter', 'pwsL10n', array(
'empty' => __('Strength indicator'),
'short' => __('Very weak'),
'bad' => __('Weak'),
'good' => _c('Medium|password strength'),
'strong' => __('Strong'),
'l10n_print_after' => 'try{convertEntities(pwsL10n);}catch(e){};'
) );
$scripts->add( 'admin-comments', '/wp-admin/js/edit-comments.js', array('wp-lists', 'jquery-ui-resizable', 'quicktags'), '20081210' );
$scripts->localize( 'admin-comments', 'adminCommentsL10n', array(
'hotkeys_highlight_first' => isset($_GET['hotkeys_highlight_first']),
'hotkeys_highlight_last' => isset($_GET['hotkeys_highlight_last'])
) );
$scripts->add( 'admin-users', '/wp-admin/js/users.js', array('wp-lists'), '20081210' );
$scripts->add( 'xfn', '/wp-admin/js/xfn.js', false, '3517' );
$scripts->add( 'postbox', '/wp-admin/js/postbox.js', array('jquery-ui-sortable'), '20081210' );
$scripts->localize( 'postbox', 'postboxL10n', array(
'requestFile' => admin_url('admin-ajax.php')
) );
$scripts->add( 'slug', '/wp-admin/js/slug.js', array('jquery'), '20081210' );
$scripts->localize( 'slug', 'slugL10n', array(
'requestFile' => admin_url('admin-ajax.php'),
'save' => __('Save'),
'cancel' => __('Cancel'),
'l10n_print_after' => 'try{convertEntities(slugL10n);}catch(e){};'
) );
$scripts->add( 'post', '/wp-admin/js/post.js', array('suggest', 'jquery-ui-tabs', 'wp-lists', 'postbox', 'slug'), '20081210' );
$scripts->localize( 'post', 'postL10n', array(
'tagsUsed' => __('Tags used on this post:'),
'add' => attribute_escape(__('Add')),
'addTag' => attribute_escape(__('Add new tag')),
'separate' => __('Separate tags with commas'),
'cancel' => __('Cancel'),
'edit' => __('Edit'),
'publishOn' => __('Publish on:'),
'publishOnFuture' => __('Schedule for:'),
'publishOnPast' => __('Published on:'),
'showcomm' => __('Show more comments'),
'endcomm' => __('No more comments found.'),
'publish' => __('Publish'),
'schedule' => __('Schedule'),
'update' => __('Update Post'),
'savePending' => __('Save as Pending'),
'saveDraft' => __('Save Draft'),
'private' => __('Private'),
'public' => __('Public'),
'publicSticky' => __('Public, Sticky'),
'password' => __('Password Protected'),
'privatelyPublished' => __('Privately Published'),
'published' => __('Published'),
'l10n_print_after' => 'try{convertEntities(postL10n);}catch(e){};'
) );
$scripts->add( 'page', '/wp-admin/js/page.js', array('jquery', 'slug', 'wp-lists', 'postbox'), '20081210' );
$scripts->localize( 'page', 'postL10n', array(
'cancel' => __('Cancel'),
'edit' => __('Edit'),
'publishOn' => __('Publish on:'),
'publishOnFuture' => __('Schedule for:'),
'publishOnPast' => __('Published on:'),
'showcomm' => __('Show more comments'),
'endcomm' => __('No more comments found.'),
'publish' => __('Publish'),
'schedule' => __('Schedule'),
'update' => __('Update Page'),
'savePending' => __('Save as Pending'),
'saveDraft' => __('Save Draft'),
'private' => __('Private'),
'public' => __('Public'),
'password' => __('Password Protected'),
'privatelyPublished' => __('Privately Published'),
'published' => __('Published'),
'l10n_print_after' => 'try{convertEntities(postL10n);}catch(e){};'
) );
$scripts->add( 'link', '/wp-admin/js/link.js', array('jquery-ui-tabs', 'wp-lists', 'postbox'), '20081210' );
$scripts->add( 'comment', '/wp-admin/js/comment.js', array('jquery'), '20081210' );
$scripts->localize( 'comment', 'commentL10n', array(
'cancel' => __('Cancel'),
'edit' => __('Edit'),
'submittedOn' => __('Submitted on:'),
'l10n_print_after' => 'try{convertEntities(commentL10n);}catch(e){};'
) );
$scripts->add( 'admin-gallery', '/wp-admin/js/gallery.js', array( 'jquery-ui-sortable' ), '20081210' );
$scripts->add( 'media-upload', '/wp-admin/js/media-upload.js', array( 'thickbox' ), '20081210' );
$scripts->add( 'admin-widgets', '/wp-admin/js/widgets.js', array( 'interface' ), '20081210' );
$scripts->localize( 'admin-widgets', 'widgetsL10n', array(
'add' => __('Add'),
'edit' => __('Edit'),
'cancel' => __('Cancel'),
'lameReminder' => __('Remember to click the "Save Changes" button at the bottom of the Current Widgets column after you\'re all done!'),
'lamerReminder' => __("You're about to leave without having saved your changes!"),
'l10n_print_after' => 'try{convertEntities(widgetsL10n);}catch(e){};'
));
$scripts->add( 'word-count', '/wp-admin/js/word-count.js', array( 'jquery' ), '20081210' );
$scripts->localize( 'word-count', 'wordCountL10n', array(
'count' => __('Word count: %d'),
'l10n_print_after' => 'try{convertEntities(wordCountL10n);}catch(e){};'
));
$scripts->add( 'wp-gears', '/wp-admin/js/wp-gears.js', false, '20081210' );
$scripts->localize( 'wp-gears', 'wpGearsL10n', array(
'updateCompleted' => __('Update completed.'),
'error' => __('Error:'),
'l10n_print_after' => 'try{convertEntities(wpGearsL10n);}catch(e){};'
));
$scripts->add( 'theme-preview', '/wp-admin/js/theme-preview.js', array( 'thickbox', 'jquery' ), '20081210' );
$scripts->add( 'inline-edit-post', '/wp-admin/js/inline-edit-post.js', array( 'jquery', 'jquery-form', 'suggest' ), '20081210' );
$scripts->localize( 'inline-edit-post', 'inlineEditL10n', array(
'error' => __('Error while saving the changes.'),
'ntdeltitle' => __('Remove From Bulk Edit'),
'notitle' => __('(no title)'),
'l10n_print_after' => 'try{convertEntities(inlineEditL10n);}catch(e){};'
) );
$scripts->add( 'inline-edit-tax', '/wp-admin/js/inline-edit-tax.js', array( 'jquery', 'jquery-form' ), '20081210' );
$scripts->localize( 'inline-edit-tax', 'inlineEditL10n', array(
'error' => __('Error while saving the changes.'),
'l10n_print_after' => 'try{convertEntities(inlineEditL10n);}catch(e){};'
) );
$scripts->add( 'plugin-install', '/wp-admin/js/plugin-install.js', array( 'thickbox', 'jquery' ), '20081210' );
$scripts->localize( 'plugin-install', 'plugininstallL10n', array(
'plugin_information' => __('Plugin Information:'),
'l10n_print_after' => 'try{convertEntities(plugininstallL10n);}catch(e){};'
) );
$scripts->add( 'farbtastic', '/wp-admin/js/farbtastic.js', array('jquery'), '1.2' );
$scripts->add( 'dashboard', '/wp-admin/js/dashboard.js', array( 'jquery', 'admin-comments', 'postbox' ), '20081210' );
$scripts->add( 'hoverIntent', '/wp-includes/js/hoverIntent.js', array('jquery'), '20081210' );
}
}
/**
* Assign default styles to $styles object.
*
* Nothing is returned, because the $styles parameter is passed by reference.
* Meaning that whatever object is passed will be updated without having to
* reassign the variable that was passed back to the same value. This saves
* memory.
*
* Adding default styles is not the only task, it also assigns the base_url
* property, the default version, and text direction for the object.
*
* @since 2.6.0
*
* @param object $styles
*/
function wp_default_styles( &$styles ) {
// This checks to see if site_url() returns something and if it does not
// then it assigns $guess_url to wp_guess_url(). Strange format, but it works.
if ( ! $guessurl = site_url() )
$guessurl = wp_guess_url();
$styles->base_url = $guessurl;
$styles->default_version = get_bloginfo( 'version' );
$styles->text_direction = 'rtl' == get_bloginfo( 'text_direction' ) ? 'rtl' : 'ltr';
$rtl_styles = array( 'global', 'colors', 'dashboard', 'ie', 'install', 'login', 'media', 'theme-editor', 'upload', 'widgets', 'press-this', 'plugin-install', 'farbtastic' );
$styles->add( 'wp-admin', '/wp-admin/wp-admin.css', array(), '20081210' );
$styles->add_data( 'wp-admin', 'rtl', '/wp-admin/rtl.css' );
$styles->add( 'ie', '/wp-admin/css/ie.css', array(), '20081210' );
$styles->add_data( 'ie', 'conditional', 'gte IE 6' );
$styles->add( 'colors', true, array(), '20081210' ); // Register "meta" stylesheet for admin colors
$styles->add( 'colors-fresh', '/wp-admin/css/colors-fresh.css', array(), '20081210'); // for login.php. Is there a better way?
$styles->add_data( 'colors-fresh', 'rtl', true );
$styles->add( 'colors-classic', '/wp-admin/css/colors-classic.css', array(), '20081210');
$styles->add_data( 'colors-classic', 'rtl', true );
$styles->add( 'global', '/wp-admin/css/global.css', array(), '20081210' );
$styles->add( 'media', '/wp-admin/css/media.css', array(), '20081210' );
$styles->add( 'widgets', '/wp-admin/css/widgets.css', array(), '20081210' );
$styles->add( 'dashboard', '/wp-admin/css/dashboard.css', array(), '20081210' );
$styles->add( 'install', '/wp-admin/css/install.css', array(), '20081210' );
$styles->add( 'theme-editor', '/wp-admin/css/theme-editor.css', array(), '20081210' );
$styles->add( 'press-this', '/wp-admin/css/press-this.css', array(), '20081210' );
$styles->add( 'thickbox', '/wp-includes/js/thickbox/thickbox.css', array(), '20081210' );
$styles->add( 'login', '/wp-admin/css/login.css', array(), '20081210' );
$styles->add( 'plugin-install', '/wp-admin/css/plugin-install.css', array(), '20081210' );
$styles->add( 'farbtastic', '/wp-admin/css/farbtastic.css', array(), '1.2' );
foreach ( $rtl_styles as $rtl_style )
$styles->add_data( $rtl_style, 'rtl', true );
}
/**
* Reorder JavaScript scripts array to place prototype before jQuery.
*
* @since 2.3.1
*
* @param array $js_array JavaScript scripst array
* @return array Reordered array, if needed.
*/
function wp_prototype_before_jquery( $js_array ) {
if ( false === $jquery = array_search( 'jquery', $js_array ) )
return $js_array;
if ( false === $prototype = array_search( 'prototype', $js_array ) )
return $js_array;
if ( $prototype < $jquery )
return $js_array;
unset($js_array[$prototype]);
array_splice( $js_array, $jquery, 0, 'prototype' );
return $js_array;
}
/**
* Load localized script just in time for MCE.
*
* These localizations require information that may not be loaded even by init.
*
* @since 2.5.0
*/
function wp_just_in_time_script_localization() {
global $current_user;
wp_localize_script( 'autosave', 'autosaveL10n', array(
'autosaveInterval' => AUTOSAVE_INTERVAL,
'previewPageText' => __('Preview this Page'),
'previewPostText' => __('Preview this Post'),
'requestFile' => admin_url('admin-ajax.php'),
'savingText' => __('Saving Draft…'),
'l10n_print_after' => 'try{convertEntities(autosaveL10n);}catch(e){};'
) );
$userid = isset($current_user) ? $current_user->ID : 0;
wp_localize_script( 'common', 'userSettings', array(
'url' => SITECOOKIEPATH,
'uid' => $userid,
'time' => time()
) );
}
/**
* Administration Panel CSS for changing the styles.
*
* If installing the 'wp-admin/' directory will be replaced with './'.
*
* The $_wp_admin_css_colors global manages the Administration Panels CSS
* stylesheet that is loaded. The option that is set is 'admin_color' and is the
* color and key for the array. The value for the color key is an object with
* a 'url' parameter that has the URL path to the CSS file.
*
* The query from $src parameter will be appended to the URL that is given from
* the $_wp_admin_css_colors array value URL.
*
* @since 2.6.0
* @uses $_wp_admin_css_colors
*
* @param string $src Source URL.
* @param string $handle Either 'colors' or 'colors-rtl'.
* @return string URL path to CSS stylesheet for Administration Panels.
*/
function wp_style_loader_src( $src, $handle ) {
if ( defined('WP_INSTALLING') )
return preg_replace( '#^wp-admin/#', './', $src );
if ( 'colors' == $handle || 'colors-rtl' == $handle ) {
global $_wp_admin_css_colors;
$color = get_user_option('admin_color');
if ( empty($color) || !isset($_wp_admin_css_colors[$color]) )
$color = 'fresh';
$color = $_wp_admin_css_colors[$color];
$parsed = parse_url( $src );
$url = $color->url;
if ( isset($parsed['query']) && $parsed['query'] ) {
wp_parse_str( $parsed['query'], $qv );
$url = add_query_arg( $qv, $url );
}
return $url;
}
return $src;
}
add_action( 'wp_default_scripts', 'wp_default_scripts' );
add_filter( 'wp_print_scripts', 'wp_just_in_time_script_localization' );
add_filter( 'print_scripts_array', 'wp_prototype_before_jquery' );
add_action( 'wp_default_styles', 'wp_default_styles' );
add_filter( 'style_loader_src', 'wp_style_loader_src', 10, 2 );
waterwise-wp/wp-includes/link-template.php 0000644 0001033 0000041 00000122201 11136560161 021017 0 ustar robert www-data <?php
/**
* WordPress Link Template Functions
*
* @package WordPress
* @subpackage Template
*/
/**
* Display the permalink for the current post.
*
* @since 1.2.0
* @uses apply_filters() Calls 'the_permalink' filter on the permalink string.
*/
function the_permalink() {
echo apply_filters('the_permalink', get_permalink());
}
/**
* Retrieve trailing slash string, if blog set for adding trailing slashes.
*
* Conditionally adds a trailing slash if the permalink structure has a trailing
* slash, strips the trailing slash if not. The string is passed through the
* 'user_trailingslashit' filter. Will remove trailing slash from string, if
* blog is not set to have them.
*
* @since 2.2.0
* @uses $wp_rewrite
*
* @param $string String a URL with or without a trailing slash.
* @param $type_of_url String the type of URL being considered (e.g. single, category, etc) for use in the filter.
* @return string
*/
function user_trailingslashit($string, $type_of_url = '') {
global $wp_rewrite;
if ( $wp_rewrite->use_trailing_slashes )
$string = trailingslashit($string);
else
$string = untrailingslashit($string);
// Note that $type_of_url can be one of following:
// single, single_trackback, single_feed, single_paged, feed, category, page, year, month, day, paged
$string = apply_filters('user_trailingslashit', $string, $type_of_url);
return $string;
}
/**
* Display permalink anchor for current post.
*
* The permalink mode title will use the post title for the 'a' element 'id'
* attribute. The id mode uses 'post-' with the post ID for the 'id' attribute.
*
* @since 0.71
*
* @param string $mode Permalink mode can be either 'title', 'id', or default, which is 'id'.
*/
function permalink_anchor($mode = 'id') {
global $post;
switch ( strtolower($mode) ) {
case 'title':
$title = sanitize_title($post->post_title) . '-' . $post->ID;
echo '<a id="'.$title.'"></a>';
break;
case 'id':
default:
echo '<a id="post-' . $post->ID . '"></a>';
break;
}
}
/**
* Retrieve full permalink for current post or post ID.
*
* @since 1.0.0
*
* @param int $id Optional. Post ID.
* @param bool $leavename Optional, defaults to false. Whether to keep post name or page name.
* @return string
*/
function get_permalink($id = 0, $leavename = false) {
$rewritecode = array(
'%year%',
'%monthnum%',
'%day%',
'%hour%',
'%minute%',
'%second%',
$leavename? '' : '%postname%',
'%post_id%',
'%category%',
'%author%',
$leavename? '' : '%pagename%',
);
if ( is_object($id) && isset($id->filter) && 'sample' == $id->filter )
$post = $id;
else
$post = &get_post($id);
if ( empty($post->ID) ) return false;
if ( $post->post_type == 'page' )
return get_page_link($post->ID, $leavename);
elseif ($post->post_type == 'attachment')
return get_attachment_link($post->ID);
$permalink = get_option('permalink_structure');
if ( '' != $permalink && !in_array($post->post_status, array('draft', 'pending')) ) {
$unixtime = strtotime($post->post_date);
$category = '';
if ( strpos($permalink, '%category%') !== false ) {
$cats = get_the_category($post->ID);
if ( $cats ) {
usort($cats, '_usort_terms_by_ID'); // order by ID
$category = $cats[0]->slug;
if ( $parent = $cats[0]->parent )
$category = get_category_parents($parent, false, '/', true) . $category;
}
// show default category in permalinks, without
// having to assign it explicitly
if ( empty($category) ) {
$default_category = get_category( get_option( 'default_category' ) );
$category = is_wp_error( $default_category ) ? '' : $default_category->slug;
}
}
$author = '';
if ( strpos($permalink, '%author%') !== false ) {
$authordata = get_userdata($post->post_author);
$author = $authordata->user_nicename;
}
$date = explode(" ",date('Y m d H i s', $unixtime));
$rewritereplace =
array(
$date[0],
$date[1],
$date[2],
$date[3],
$date[4],
$date[5],
$post->post_name,
$post->ID,
$category,
$author,
$post->post_name,
);
$permalink = get_option('home') . str_replace($rewritecode, $rewritereplace, $permalink);
$permalink = user_trailingslashit($permalink, 'single');
return apply_filters('post_link', $permalink, $post, $leavename);
} else { // if they're not using the fancy permalink option
$permalink = get_option('home') . '/?p=' . $post->ID;
return apply_filters('post_link', $permalink, $post, $leavename);
}
}
/**
* Retrieve permalink from post ID.
*
* @since 1.0.0
*
* @param int $post_id Optional. Post ID.
* @param mixed $deprecated Not used.
* @return string
*/
function post_permalink($post_id = 0, $deprecated = '') {
return get_permalink($post_id);
}
/**
* Retrieve the permalink for current page or page ID.
*
* Respects page_on_front. Use this one.
*
* @since 1.5.0
*
* @param int $id Optional. Post ID.
* @param bool $leavename Optional, defaults to false. Whether to keep post name or page name.
* @return string
*/
function get_page_link($id = false, $leavename = false) {
global $post;
$id = (int) $id;
if ( !$id )
$id = (int) $post->ID;
if ( 'page' == get_option('show_on_front') && $id == get_option('page_on_front') )
$link = get_option('home');
else
$link = _get_page_link( $id , $leavename );
return apply_filters('page_link', $link, $id);
}
/**
* Retrieve the page permalink.
*
* Ignores page_on_front. Internal use only.
*
* @since 2.1.0
* @access private
*
* @param int $id Optional. Post ID.
* @param bool $leavename Optional. Leave name.
* @return string
*/
function _get_page_link( $id = false, $leavename = false ) {
global $post, $wp_rewrite;
if ( !$id )
$id = (int) $post->ID;
else
$post = &get_post($id);
$pagestruct = $wp_rewrite->get_page_permastruct();
if ( '' != $pagestruct && isset($post->post_status) && 'draft' != $post->post_status ) {
$link = get_page_uri($id);
$link = ( $leavename ) ? $pagestruct : str_replace('%pagename%', $link, $pagestruct);
$link = get_option('home') . "/$link";
$link = user_trailingslashit($link, 'page');
} else {
$link = get_option('home') . "/?page_id=$id";
}
return apply_filters( '_get_page_link', $link, $id );
}
/**
* Retrieve permalink for attachment.
*
* This can be used in the WordPress Loop or outside of it.
*
* @since 2.0.0
*
* @param int $id Optional. Post ID.
* @return string
*/
function get_attachment_link($id = false) {
global $post, $wp_rewrite;
$link = false;
if (! $id) {
$id = (int) $post->ID;
}
$object = get_post($id);
if ( $wp_rewrite->using_permalinks() && ($object->post_parent > 0) && ($object->post_parent != $id) ) {
$parent = get_post($object->post_parent);
if ( 'page' == $parent->post_type )
$parentlink = _get_page_link( $object->post_parent ); // Ignores page_on_front
else
$parentlink = get_permalink( $object->post_parent );
if ( is_numeric($object->post_name) || false !== strpos(get_option('permalink_structure'), '%category%') )
$name = 'attachment/' . $object->post_name; // <permalink>/<int>/ is paged so we use the explicit attachment marker
else
$name = $object->post_name;
if (strpos($parentlink, '?') === false)
$link = user_trailingslashit( trailingslashit($parentlink) . $name );
}
if (! $link ) {
$link = get_bloginfo('url') . "/?attachment_id=$id";
}
return apply_filters('attachment_link', $link, $id);
}
/**
* Retrieve the permalink for the year archives.
*
* @since 1.5.0
*
* @param int|bool $year False for current year or year for permalink.
* @return string
*/
function get_year_link($year) {
global $wp_rewrite;
if ( !$year )
$year = gmdate('Y', time()+(get_option('gmt_offset') * 3600));
$yearlink = $wp_rewrite->get_year_permastruct();
if ( !empty($yearlink) ) {
$yearlink = str_replace('%year%', $year, $yearlink);
return apply_filters('year_link', get_option('home') . user_trailingslashit($yearlink, 'year'), $year);
} else {
return apply_filters('year_link', get_option('home') . '/?m=' . $year, $year);
}
}
/**
* Retrieve the permalink for the month archives with year.
*
* @since 1.0.0
*
* @param bool|int $year False for current year. Integer of year.
* @param bool|int $month False for current month. Integer of month.
* @return string
*/
function get_month_link($year, $month) {
global $wp_rewrite;
if ( !$year )
$year = gmdate('Y', time()+(get_option('gmt_offset') * 3600));
if ( !$month )
$month = gmdate('m', time()+(get_option('gmt_offset') * 3600));
$monthlink = $wp_rewrite->get_month_permastruct();
if ( !empty($monthlink) ) {
$monthlink = str_replace('%year%', $year, $monthlink);
$monthlink = str_replace('%monthnum%', zeroise(intval($month), 2), $monthlink);
return apply_filters('month_link', get_option('home') . user_trailingslashit($monthlink, 'month'), $year, $month);
} else {
return apply_filters('month_link', get_option('home') . '/?m=' . $year . zeroise($month, 2), $year, $month);
}
}
/**
* Retrieve the permalink for the day archives with year and month.
*
* @since 1.0.0
*
* @param bool|int $year False for current year. Integer of year.
* @param bool|int $month False for current month. Integer of month.
* @param bool|int $day False for current day. Integer of day.
* @return string
*/
function get_day_link($year, $month, $day) {
global $wp_rewrite;
if ( !$year )
$year = gmdate('Y', time()+(get_option('gmt_offset') * 3600));
if ( !$month )
$month = gmdate('m', time()+(get_option('gmt_offset') * 3600));
if ( !$day )
$day = gmdate('j', time()+(get_option('gmt_offset') * 3600));
$daylink = $wp_rewrite->get_day_permastruct();
if ( !empty($daylink) ) {
$daylink = str_replace('%year%', $year, $daylink);
$daylink = str_replace('%monthnum%', zeroise(intval($month), 2), $daylink);
$daylink = str_replace('%day%', zeroise(intval($day), 2), $daylink);
return apply_filters('day_link', get_option('home') . user_trailingslashit($daylink, 'day'), $year, $month, $day);
} else {
return apply_filters('day_link', get_option('home') . '/?m=' . $year . zeroise($month, 2) . zeroise($day, 2), $year, $month, $day);
}
}
/**
* Retrieve the permalink for the feed type.
*
* @since 1.5.0
*
* @param string $feed Optional, defaults to default feed. Feed type.
* @return string
*/
function get_feed_link($feed = '') {
global $wp_rewrite;
$permalink = $wp_rewrite->get_feed_permastruct();
if ( '' != $permalink ) {
if ( false !== strpos($feed, 'comments_') ) {
$feed = str_replace('comments_', '', $feed);
$permalink = $wp_rewrite->get_comment_feed_permastruct();
}
if ( get_default_feed() == $feed )
$feed = '';
$permalink = str_replace('%feed%', $feed, $permalink);
$permalink = preg_replace('#/+#', '/', "/$permalink");
$output = get_option('home') . user_trailingslashit($permalink, 'feed');
} else {
if ( empty($feed) )
$feed = get_default_feed();
if ( false !== strpos($feed, 'comments_') )
$feed = str_replace('comments_', 'comments-', $feed);
$output = get_option('home') . "/?feed={$feed}";
}
return apply_filters('feed_link', $output, $feed);
}
/**
* Retrieve the permalink for the post comments feed.
*
* @since 2.2.0
*
* @param int $post_id Optional. Post ID.
* @param string $feed Optional. Feed type.
* @return string
*/
function get_post_comments_feed_link($post_id = '', $feed = '') {
global $id;
if ( empty($post_id) )
$post_id = (int) $id;
if ( empty($feed) )
$feed = get_default_feed();
if ( '' != get_option('permalink_structure') ) {
$url = trailingslashit( get_permalink($post_id) ) . 'feed';
if ( $feed != get_default_feed() )
$url .= "/$feed";
$url = user_trailingslashit($url, 'single_feed');
} else {
$type = get_post_field('post_type', $post_id);
if ( 'page' == $type )
$url = get_option('home') . "/?feed=$feed&page_id=$post_id";
else
$url = get_option('home') . "/?feed=$feed&p=$post_id";
}
return apply_filters('post_comments_feed_link', $url);
}
/**
* Display the comment feed link for a post.
*
* Prints out the comment feed link for a post. Link text is placed in the
* anchor. If no link text is specified, default text is used. If no post ID is
* specified, the current post is used.
*
* @package WordPress
* @subpackage Feed
* @since 2.5.0
*
* @param string $link_text Descriptive text.
* @param int $post_id Optional post ID. Default to current post.
* @param string $feed Optional. Feed format.
* @return string Link to the comment feed for the current post.
*/
function post_comments_feed_link( $link_text = '', $post_id = '', $feed = '' ) {
$url = get_post_comments_feed_link($post_id, $feed);
if ( empty($link_text) )
$link_text = __('Comments Feed');
echo "<a href='$url'>$link_text</a>";
}
/**
* Retrieve the feed link for a given author.
*
* Returns a link to the feed for all posts by a given author. A specific feed
* can be requested or left blank to get the default feed.
*
* @package WordPress
* @subpackage Feed
* @since 2.5.0
*
* @param int $author_id ID of an author.
* @param string $feed Optional. Feed type.
* @return string Link to the feed for the author specified by $author_id.
*/
function get_author_feed_link( $author_id, $feed = '' ) {
$author_id = (int) $author_id;
$permalink_structure = get_option('permalink_structure');
if ( empty($feed) )
$feed = get_default_feed();
if ( '' == $permalink_structure ) {
$link = get_option('home') . "?feed=$feed&author=" . $author_id;
} else {
$link = get_author_posts_url($author_id);
if ( $feed == get_default_feed() )
$feed_link = 'feed';
else
$feed_link = "feed/$feed";
$link = trailingslashit($link) . user_trailingslashit($feed_link, 'feed');
}
$link = apply_filters('author_feed_link', $link, $feed);
return $link;
}
/**
* Retrieve the feed link for a category.
*
* Returns a link to the feed for all post in a given category. A specific feed
* can be requested or left blank to get the default feed.
*
* @package WordPress
* @subpackage Feed
* @since 2.5.0
*
* @param int $cat_id ID of a category.
* @param string $feed Optional. Feed type.
* @return string Link to the feed for the category specified by $cat_id.
*/
function get_category_feed_link($cat_id, $feed = '') {
$cat_id = (int) $cat_id;
$category = get_category($cat_id);
if ( empty($category) || is_wp_error($category) )
return false;
if ( empty($feed) )
$feed = get_default_feed();
$permalink_structure = get_option('permalink_structure');
if ( '' == $permalink_structure ) {
$link = get_option('home') . "?feed=$feed&cat=" . $cat_id;
} else {
$link = get_category_link($cat_id);
if( $feed == get_default_feed() )
$feed_link = 'feed';
else
$feed_link = "feed/$feed";
$link = trailingslashit($link) . user_trailingslashit($feed_link, 'feed');
}
$link = apply_filters('category_feed_link', $link, $feed);
return $link;
}
/**
* Retrieve permalink for feed of tag.
*
* @since 2.3.0
*
* @param int $tag_id Tag ID.
* @param string $feed Optional. Feed type.
* @return string
*/
function get_tag_feed_link($tag_id, $feed = '') {
$tag_id = (int) $tag_id;
$tag = get_tag($tag_id);
if ( empty($tag) || is_wp_error($tag) )
return false;
$permalink_structure = get_option('permalink_structure');
if ( empty($feed) )
$feed = get_default_feed();
if ( '' == $permalink_structure ) {
$link = get_option('home') . "?feed=$feed&tag=" . $tag->slug;
} else {
$link = get_tag_link($tag->term_id);
if ( $feed == get_default_feed() )
$feed_link = 'feed';
else
$feed_link = "feed/$feed";
$link = trailingslashit($link) . user_trailingslashit($feed_link, 'feed');
}
$link = apply_filters('tag_feed_link', $link, $feed);
return $link;
}
/**
* Retrieve edit tag link.
*
* @since 2.7.0
*
* @param int $tag_id Tag ID
* @return string
*/
function get_edit_tag_link( $tag_id = 0 ) {
$tag = get_term($tag_id, 'post_tag');
if ( !current_user_can('manage_categories') )
return;
$location = admin_url('edit-tags.php?action=edit&tag_ID=') . $tag->term_id;
return apply_filters( 'get_edit_tag_link', $location );
}
/**
* Display or retrieve edit tag link with formatting.
*
* @since 2.7.0
*
* @param string $link Optional. Anchor text.
* @param string $before Optional. Display before edit link.
* @param string $after Optional. Display after edit link.
* @param int|object $tag Tag object or ID
* @return string|null HTML content, if $echo is set to false.
*/
function edit_tag_link( $link = '', $before = '', $after = '', $tag = null ) {
$tag = get_term($tag, 'post_tag');
if ( !current_user_can('manage_categories') )
return;
if ( empty($link) )
$link = __('Edit This');
$link = '<a href="' . get_edit_tag_link( $tag->term_id ) . '" title="' . __( 'Edit tag' ) . '">' . $link . '</a>';
echo $before . apply_filters( 'edit_tag_link', $link, $tag->term_id ) . $after;
}
/**
* Retrieve the permalink for the feed of the search results.
*
* @since 2.5.0
*
* @param string $search_query Optional. Search query.
* @param string $feed Optional. Feed type.
* @return string
*/
function get_search_feed_link($search_query = '', $feed = '') {
if ( empty($search_query) )
$search = attribute_escape(get_search_query());
else
$search = attribute_escape(stripslashes($search_query));
if ( empty($feed) )
$feed = get_default_feed();
$link = get_option('home') . "?s=$search&feed=$feed";
$link = apply_filters('search_feed_link', $link);
return $link;
}
/**
* Retrieve the permalink for the comments feed of the search results.
*
* @since 2.5.0
*
* @param string $search_query Optional. Search query.
* @param string $feed Optional. Feed type.
* @return string
*/
function get_search_comments_feed_link($search_query = '', $feed = '') {
if ( empty($search_query) )
$search = attribute_escape(get_search_query());
else
$search = attribute_escape(stripslashes($search_query));
if ( empty($feed) )
$feed = get_default_feed();
$link = get_option('home') . "?s=$search&feed=comments-$feed";
$link = apply_filters('search_feed_link', $link);
return $link;
}
/**
* Retrieve edit posts link for post.
*
* Can be used within the WordPress loop or outside of it. Can be used with
* pages, posts, attachments, and revisions.
*
* @since 2.3.0
*
* @param int $id Optional. Post ID.
* @param string $context Optional, default to display. How to write the '&', defaults to '&'.
* @return string
*/
function get_edit_post_link( $id = 0, $context = 'display' ) {
if ( !$post = &get_post( $id ) )
return;
if ( 'display' == $context )
$action = 'action=edit&';
else
$action = 'action=edit&';
switch ( $post->post_type ) :
case 'page' :
if ( !current_user_can( 'edit_page', $post->ID ) )
return;
$file = 'page';
$var = 'post';
break;
case 'attachment' :
if ( !current_user_can( 'edit_post', $post->ID ) )
return;
$file = 'media';
$var = 'attachment_id';
break;
case 'revision' :
if ( !current_user_can( 'edit_post', $post->ID ) )
return;
$file = 'revision';
$var = 'revision';
$action = '';
break;
default :
if ( !current_user_can( 'edit_post', $post->ID ) )
return;
$file = 'post';
$var = 'post';
break;
endswitch;
return apply_filters( 'get_edit_post_link', admin_url("$file.php?{$action}$var=$post->ID"), $post->ID, $context );
}
/**
* Retrieve edit posts link for post.
*
* @since 1.0.0
*
* @param string $link Optional. Anchor text.
* @param string $before Optional. Display before edit link.
* @param string $after Optional. Display after edit link.
*/
function edit_post_link( $link = 'Edit This', $before = '', $after = '' ) {
global $post;
if ( $post->post_type == 'page' ) {
if ( !current_user_can( 'edit_page', $post->ID ) )
return;
} else {
if ( !current_user_can( 'edit_post', $post->ID ) )
return;
}
$link = '<a class="post-edit-link" href="' . get_edit_post_link( $post->ID ) . '" title="' . attribute_escape( __( 'Edit post' ) ) . '">' . $link . '</a>';
echo $before . apply_filters( 'edit_post_link', $link, $post->ID ) . $after;
}
/**
* Retrieve edit comment link.
*
* @since 2.3.0
*
* @param int $comment_id Optional. Comment ID.
* @return string
*/
function get_edit_comment_link( $comment_id = 0 ) {
$comment = &get_comment( $comment_id );
$post = &get_post( $comment->comment_post_ID );
if ( $post->post_type == 'page' ) {
if ( !current_user_can( 'edit_page', $post->ID ) )
return;
} else {
if ( !current_user_can( 'edit_post', $post->ID ) )
return;
}
$location = admin_url('comment.php?action=editcomment&c=') . $comment->comment_ID;
return apply_filters( 'get_edit_comment_link', $location );
}
/**
* Display or retrieve edit comment link with formatting.
*
* @since 1.0.0
*
* @param string $link Optional. Anchor text.
* @param string $before Optional. Display before edit link.
* @param string $after Optional. Display after edit link.
* @return string|null HTML content, if $echo is set to false.
*/
function edit_comment_link( $link = 'Edit This', $before = '', $after = '' ) {
global $comment, $post;
if ( $post->post_type == 'attachment' ) {
} elseif ( $post->post_type == 'page' ) {
if ( !current_user_can( 'edit_page', $post->ID ) )
return;
} else {
if ( !current_user_can( 'edit_post', $post->ID ) )
return;
}
$link = '<a class="comment-edit-link" href="' . get_edit_comment_link( $comment->comment_ID ) . '" title="' . __( 'Edit comment' ) . '">' . $link . '</a>';
echo $before . apply_filters( 'edit_comment_link', $link, $comment->comment_ID ) . $after;
}
/**
* Display edit bookmark (literally a URL external to blog) link.
*
* @since 2.7.0
*
* @param int $link Optional. Bookmark ID.
* @return string
*/
function get_edit_bookmark_link( $link = 0 ) {
$link = get_bookmark( $link );
if ( !current_user_can('manage_links') )
return;
$location = admin_url('link.php?action=edit&link_id=') . $link->link_id;
return apply_filters( 'get_edit_bookmark_link', $location, $link->link_id );
}
/**
* Display edit bookmark (literally a URL external to blog) link anchor content.
*
* @since 2.7.0
*
* @param string $link Optional. Anchor text.
* @param string $before Optional. Display before edit link.
* @param string $after Optional. Display after edit link.
* @param int $bookmark Optional. Bookmark ID.
*/
function edit_bookmark_link( $link = '', $before = '', $after = '', $bookmark = null ) {
$bookmark = get_bookmark($bookmark);
if ( !current_user_can('manage_links') )
return;
if ( empty($link) )
$link = __('Edit This');
$link = '<a href="' . get_edit_bookmark_link( $link ) . '" title="' . __( 'Edit link' ) . '">' . $link . '</a>';
echo $before . apply_filters( 'edit_bookmark_link', $link, $bookmark->link_id ) . $after;
}
// Navigation links
/**
* Retrieve previous post link that is adjacent to current post.
*
* @since 1.5.0
*
* @param bool $in_same_cat Optional. Whether link should be in same category.
* @param string $excluded_categories Optional. Excluded categories IDs.
* @return string
*/
function get_previous_post($in_same_cat = false, $excluded_categories = '') {
return get_adjacent_post($in_same_cat, $excluded_categories);
}
/**
* Retrieve next post link that is adjacent to current post.
*
* @since 1.5.0
*
* @param bool $in_same_cat Optional. Whether link should be in same category.
* @param string $excluded_categories Optional. Excluded categories IDs.
* @return string
*/
function get_next_post($in_same_cat = false, $excluded_categories = '') {
return get_adjacent_post($in_same_cat, $excluded_categories, false);
}
/**
* Retrieve adjacent post link.
*
* Can either be next or previous post link.
*
* @since 2.5.0
*
* @param bool $in_same_cat Optional. Whether link should be in same category.
* @param string $excluded_categories Optional. Excluded categories IDs.
* @param bool $previous Optional. Whether to retrieve previous post.
* @return string
*/
function get_adjacent_post($in_same_cat = false, $excluded_categories = '', $previous = true) {
global $post, $wpdb;
if( empty($post) || !is_single() || is_attachment() )
return null;
$current_post_date = $post->post_date;
$join = '';
$posts_in_ex_cats_sql = '';
if ( $in_same_cat || !empty($excluded_categories) ) {
$join = " INNER JOIN $wpdb->term_relationships AS tr ON p.ID = tr.object_id INNER JOIN $wpdb->term_taxonomy tt ON tr.term_taxonomy_id = tt.term_taxonomy_id";
if ( $in_same_cat ) {
$cat_array = wp_get_object_terms($post->ID, 'category', 'fields=ids');
$join .= " AND tt.taxonomy = 'category' AND tt.term_id IN (" . implode(',', $cat_array) . ")";
}
$posts_in_ex_cats_sql = "AND tt.taxonomy = 'category'";
if ( !empty($excluded_categories) ) {
$excluded_categories = array_map('intval', explode(' and ', $excluded_categories));
if ( !empty($cat_array) ) {
$excluded_categories = array_diff($excluded_categories, $cat_array);
$posts_in_ex_cats_sql = '';
}
if ( !empty($excluded_categories) ) {
$posts_in_ex_cats_sql = " AND tt.taxonomy = 'category' AND tt.term_id NOT IN (" . implode($excluded_categories, ',') . ')';
}
}
}
$adjacent = $previous ? 'previous' : 'next';
$op = $previous ? '<' : '>';
$order = $previous ? 'DESC' : 'ASC';
$join = apply_filters( "get_{$adjacent}_post_join", $join, $in_same_cat, $excluded_categories );
$where = apply_filters( "get_{$adjacent}_post_where", $wpdb->prepare("WHERE p.post_date $op %s AND p.post_type = 'post' AND p.post_status = 'publish' $posts_in_ex_cats_sql", $current_post_date), $in_same_cat, $excluded_categories );
$sort = apply_filters( "get_{$adjacent}_post_sort", "ORDER BY p.post_date $order LIMIT 1" );
return $wpdb->get_row("SELECT p.* FROM $wpdb->posts AS p $join $where $sort");
}
/**
* Display previous post link that is adjacent to the current post.
*
* @since 1.5.0
*
* @param string $format Optional. Link anchor format.
* @param string $link Optional. Link permalink format.
* @param bool $in_same_cat Optional. Whether link should be in same category.
* @param string $excluded_categories Optional. Excluded categories IDs.
*/
function previous_post_link($format='« %link', $link='%title', $in_same_cat = false, $excluded_categories = '') {
adjacent_post_link($format, $link, $in_same_cat, $excluded_categories, true);
}
/**
* Display next post link that is adjacent to the current post.
*
* @since 1.5.0
*
* @param string $format Optional. Link anchor format.
* @param string $link Optional. Link permalink format.
* @param bool $in_same_cat Optional. Whether link should be in same category.
* @param string $excluded_categories Optional. Excluded categories IDs.
*/
function next_post_link($format='%link »', $link='%title', $in_same_cat = false, $excluded_categories = '') {
adjacent_post_link($format, $link, $in_same_cat, $excluded_categories, false);
}
/**
* Display adjacent post link.
*
* Can be either next post link or previous.
*
* @since 2.5.0
*
* @param string $format Link anchor format.
* @param string $link Link permalink format.
* @param bool $in_same_cat Optional. Whether link should be in same category.
* @param string $excluded_categories Optional. Excluded categories IDs.
* @param bool $previous Optional, default is true. Whether display link to previous post.
*/
function adjacent_post_link($format, $link, $in_same_cat = false, $excluded_categories = '', $previous = true) {
if ( $previous && is_attachment() )
$post = & get_post($GLOBALS['post']->post_parent);
else
$post = get_adjacent_post($in_same_cat, $excluded_categories, $previous);
if ( !$post )
return;
$title = $post->post_title;
if ( empty($post->post_title) )
$title = $previous ? __('Previous Post') : __('Next Post');
$title = apply_filters('the_title', $title, $post);
$date = mysql2date(get_option('date_format'), $post->post_date);
$string = '<a href="'.get_permalink($post).'">';
$link = str_replace('%title', $title, $link);
$link = str_replace('%date', $date, $link);
$link = $string . $link . '</a>';
$format = str_replace('%link', $link, $format);
$adjacent = $previous ? 'previous' : 'next';
echo apply_filters( "{$adjacent}_post_link", $format, $link );
}
/**
* Retrieve get links for page numbers.
*
* @since 1.5.0
*
* @param int $pagenum Optional. Page ID.
* @return string
*/
function get_pagenum_link($pagenum = 1) {
global $wp_rewrite;
$pagenum = (int) $pagenum;
$request = remove_query_arg( 'paged' );
$home_root = parse_url(get_option('home'));
$home_root = ( isset($home_root['path']) ) ? $home_root['path'] : '';
$home_root = preg_quote( trailingslashit( $home_root ), '|' );
$request = preg_replace('|^'. $home_root . '|', '', $request);
$request = preg_replace('|^/+|', '', $request);
if ( !$wp_rewrite->using_permalinks() || is_admin() ) {
$base = trailingslashit( get_bloginfo( 'home' ) );
if ( $pagenum > 1 ) {
$result = add_query_arg( 'paged', $pagenum, $base . $request );
} else {
$result = $base . $request;
}
} else {
$qs_regex = '|\?.*?$|';
preg_match( $qs_regex, $request, $qs_match );
if ( !empty( $qs_match[0] ) ) {
$query_string = $qs_match[0];
$request = preg_replace( $qs_regex, '', $request );
} else {
$query_string = '';
}
$request = preg_replace( '|page/\d+/?$|', '', $request);
$request = preg_replace( '|^index\.php|', '', $request);
$request = ltrim($request, '/');
$base = trailingslashit( get_bloginfo( 'url' ) );
if ( $wp_rewrite->using_index_permalinks() && ( $pagenum > 1 || '' != $request ) )
$base .= 'index.php/';
if ( $pagenum > 1 ) {
$request = ( ( !empty( $request ) ) ? trailingslashit( $request ) : $request ) . user_trailingslashit( 'page/' . $pagenum, 'paged' );
}
$result = $base . $request . $query_string;
}
$result = apply_filters('get_pagenum_link', $result);
return $result;
}
/**
* Retrieve next posts pages link.
*
* Backported from 2.1.3 to 2.0.10.
*
* @since 2.0.10
*
* @param int $max_page Optional. Max pages.
* @return string
*/
function get_next_posts_page_link($max_page = 0) {
global $paged;
if ( !is_single() ) {
if ( !$paged )
$paged = 1;
$nextpage = intval($paged) + 1;
if ( !$max_page || $max_page >= $nextpage )
return get_pagenum_link($nextpage);
}
}
/**
* Display or return the next posts pages link.
*
* @since 0.71
*
* @param int $max_page Optional. Max pages.
* @param boolean $echo Optional. Echo or return;
*/
function next_posts( $max_page = 0, $echo = true ) {
$output = clean_url( get_next_posts_page_link( $max_page ) );
if ( $echo )
echo $output;
else
return $output;
}
/**
* Return the next posts pages link.
*
* @since 2.7.0
*
* @param string $label Content for link text.
* @param int $max_page Optional. Max pages.
* @return string|null
*/
function get_next_posts_link( $label = 'Next Page »', $max_page = 0 ) {
global $paged, $wp_query;
if ( !$max_page ) {
$max_page = $wp_query->max_num_pages;
}
if ( !$paged )
$paged = 1;
$nextpage = intval($paged) + 1;
if ( !is_single() && ( empty($paged) || $nextpage <= $max_page) ) {
$attr = apply_filters( 'next_posts_link_attributes', '' );
return '<a href="' . next_posts( $max_page, false ) . "\" $attr>". preg_replace('/&([^#])(?![a-z]{1,8};)/', '&$1', $label) .'</a>';
}
}
/**
* Display the next posts pages link.
*
* @since 0.71
* @uses get_next_posts_link()
*
* @param string $label Content for link text.
* @param int $max_page Optional. Max pages.
*/
function next_posts_link( $label = 'Next Page »', $max_page = 0 ) {
echo get_next_posts_link( $label, $max_page );
}
/**
* Retrieve previous post pages link.
*
* Will only return string, if not on a single page or post.
*
* Backported to 2.0.10 from 2.1.3.
*
* @since 2.0.10
*
* @return string|null
*/
function get_previous_posts_page_link() {
global $paged;
if ( !is_single() ) {
$nextpage = intval($paged) - 1;
if ( $nextpage < 1 )
$nextpage = 1;
return get_pagenum_link($nextpage);
}
}
/**
* Display or return the previous posts pages link.
*
* @since 0.71
*
* @param boolean $echo Optional. Echo or return;
*/
function previous_posts( $echo = true ) {
$output = clean_url( get_previous_posts_page_link() );
if ( $echo )
echo $output;
else
return $output;
}
/**
* Return the previous posts pages link.
*
* @since 2.7.0
*
* @param string $label Optional. Previous page link text.
* @return string|null
*/
function get_previous_posts_link( $label = '« Previous Page' ) {
global $paged;
if ( !is_single() && $paged > 1 ) {
$attr = apply_filters( 'previous_posts_link_attributes', '' );
return '<a href="' . previous_posts( false ) . "\" $attr>". preg_replace( '/&([^#])(?![a-z]{1,8};)/', '&$1', $label ) .'</a>';
}
}
/**
* Display the previous posts page link.
*
* @since 0.71
* @uses get_previous_posts_link()
*
* @param string $label Optional. Previous page link text.
*/
function previous_posts_link( $label = '« Previous Page' ) {
echo get_previous_posts_link( $label );
}
/**
* Display post pages link navigation for previous and next pages.
*
* @since 0.71
*
* @param string $sep Optional. Separator for posts navigation links.
* @param string $prelabel Optional. Label for previous pages.
* @param string $nxtlabel Optional Label for next pages.
*/
function posts_nav_link( $sep = ' — ', $prelabel = '« Previous Page', $nxtlabel = 'Next Page »' ) {
global $wp_query;
if ( !is_singular() ) {
$max_num_pages = $wp_query->max_num_pages;
$paged = get_query_var('paged');
//only have sep if there's both prev and next results
if ($paged < 2 || $paged >= $max_num_pages) {
$sep = '';
}
if ( $max_num_pages > 1 ) {
previous_posts_link($prelabel);
echo preg_replace('/&([^#])(?![a-z]{1,8};)/', '&$1', $sep);
next_posts_link($nxtlabel);
}
}
}
/**
* Retrieve page numbers links.
*
* @since 2.7.0
*
* @param int $pagenum Optional. Page number.
* @return string
*/
function get_comments_pagenum_link( $pagenum = 1, $max_page = 0 ) {
global $post, $wp_rewrite;
$pagenum = (int) $pagenum;
$result = get_permalink( $post->ID );
if ( 'newest' == get_option('default_comments_page') ) {
if ( $pagenum != $max_page ) {
if ( $wp_rewrite->using_permalinks() )
$result = user_trailingslashit( trailingslashit($result) . 'comment-page-' . $pagenum, 'commentpaged');
else
$result = add_query_arg( 'cpage', $pagenum, $result );
}
} elseif ( $pagenum > 1 ) {
if ( $wp_rewrite->using_permalinks() )
$result = user_trailingslashit( trailingslashit($result) . 'comment-page-' . $pagenum, 'commentpaged');
else
$result = add_query_arg( 'cpage', $pagenum, $result );
}
$result .= '#comments';
$result = apply_filters('get_comments_pagenum_link', $result);
return $result;
}
/**
* Return the link to next comments pages.
*
* @since 2.7.1
*
* @param string $label Optional. Label for link text.
* @param int $max_page Optional. Max page.
* @return string|null
*/
function get_next_comments_link( $label = '', $max_page = 0 ) {
global $wp_query;
if ( !is_singular() )
return;
$page = get_query_var('cpage');
$nextpage = intval($page) + 1;
if ( empty($max_page) )
$max_page = $wp_query->max_num_comment_pages;
if ( empty($max_page) )
$max_page = get_comment_pages_count();
if ( $nextpage > $max_page )
return;
if ( empty($label) )
$label = __('Newer Comments »');
return '<a href="' . clean_url( get_comments_pagenum_link( $nextpage, $max_page ) ) . '" ' . apply_filters( 'next_comments_link_attributes', '' ) . '>'. preg_replace('/&([^#])(?![a-z]{1,8};)/', '&$1', $label) .'</a>';
}
/**
* Display the link to next comments pages.
*
* @since 2.7.0
*
* @param string $label Optional. Label for link text.
* @param int $max_page Optional. Max page.
*/
function next_comments_link( $label = '', $max_page = 0 ) {
echo get_next_comments_link( $label, $max_page );
}
/**
* Return the previous comments page link.
*
* @since 2.7.1
*
* @param string $label Optional. Label for comments link text.
* @return string|null
*/
function get_previous_comments_link( $label = '' ) {
if ( !is_singular() )
return;
$page = get_query_var('cpage');
if ( intval($page) <= 1 )
return;
$prevpage = intval($page) - 1;
if ( empty($label) )
$label = __('« Older Comments');
return '<a href="' . clean_url( get_comments_pagenum_link( $prevpage ) ) . '" ' . apply_filters( 'previous_comments_link_attributes', '' ) . '>' . preg_replace('/&([^#])(?![a-z]{1,8};)/', '&$1', $label) .'</a>';
}
/**
* Display the previous comments page link.
*
* @since 2.7.0
*
* @param string $label Optional. Label for comments link text.
*/
function previous_comments_link( $label = '' ) {
echo get_previous_comments_link( $label );
}
/**
* Create pagination links for the comments on the current post.
*
* @see paginate_links()
* @since 2.7.0
*
* @param string|array $args Optional args. See paginate_links.
* @return string Markup for pagination links.
*/
function paginate_comments_links($args = array()) {
global $wp_query, $wp_rewrite;
if ( !is_singular() )
return;
$page = get_query_var('cpage');
if ( !$page )
$page = 1;
$max_page = get_comment_pages_count();
$defaults = array(
'base' => add_query_arg( 'cpage', '%#%' ),
'format' => '',
'total' => $max_page,
'current' => $page,
'echo' => true,
'add_fragment' => '#comments'
);
if ( $wp_rewrite->using_permalinks() )
$defaults['base'] = user_trailingslashit(trailingslashit(get_permalink()) . 'comment-page-%#%', 'commentpaged');
$args = wp_parse_args( $args, $defaults );
$page_links = paginate_links( $args );
if ( $args['echo'] )
echo $page_links;
else
return $page_links;
}
/**
* Retrieve shortcut link.
*
* Use this in 'a' element 'href' attribute.
*
* @since 2.6.0
*
* @return string
*/
function get_shortcut_link() {
$link = "javascript:
var d=document,
w=window,
e=w.getSelection,
k=d.getSelection,
x=d.selection,
s=(e?e():(k)?k():(x?x.createRange().text:0)),
f='" . admin_url('press-this.php') . "',
l=d.location,
e=encodeURIComponent,
g=f+'?u='+e(l.href)+'&t='+e(d.title)+'&s='+e(s)+'&v=2';
function a(){
if(!w.open(g,'t','toolbar=0,resizable=0,scrollbars=1,status=1,width=720,height=570')){
l.href=g;
}
}";
if (strpos($_SERVER['HTTP_USER_AGENT'], 'Firefox') !== false)
$link .= 'setTimeout(a,0);';
else
$link .= 'a();';
$link .= "void(0);";
$link = str_replace(array("\r", "\n", "\t"), '', $link);
return apply_filters('shortcut_link', $link);
}
/**
* Retrieve the site url.
*
* Returns the 'site_url' option with the appropriate protocol, 'https' if
* is_ssl() and 'http' otherwise. If $scheme is 'http' or 'https', is_ssl() is
* overridden.
*
* @package WordPress
* @since 2.6.0
*
* @param string $path Optional. Path relative to the site url.
* @param string $scheme Optional. Scheme to give the site url context. Currently 'http','https', 'login', 'login_post', or 'admin'.
* @return string Site url link with optional path appended.
*/
function site_url($path = '', $scheme = null) {
// should the list of allowed schemes be maintained elsewhere?
$orig_scheme = $scheme;
if ( !in_array($scheme, array('http', 'https')) ) {
if ( ('login_post' == $scheme) && ( force_ssl_login() || force_ssl_admin() ) )
$scheme = 'https';
elseif ( ('login' == $scheme) && ( force_ssl_admin() ) )
$scheme = 'https';
elseif ( ('admin' == $scheme) && force_ssl_admin() )
$scheme = 'https';
else
$scheme = ( is_ssl() ? 'https' : 'http' );
}
$url = str_replace( 'http://', "{$scheme}://", get_option('siteurl') );
if ( !empty($path) && is_string($path) && strpos($path, '..') === false )
$url .= '/' . ltrim($path, '/');
return apply_filters('site_url', $url, $path, $orig_scheme);
}
/**
* Retrieve the url to the admin area.
*
* @package WordPress
* @since 2.6.0
*
* @param string $path Optional path relative to the admin url
* @return string Admin url link with optional path appended
*/
function admin_url($path = '') {
$url = site_url('wp-admin/', 'admin');
if ( !empty($path) && is_string($path) && strpos($path, '..') === false )
$url .= ltrim($path, '/');
return $url;
}
/**
* Retrieve the url to the includes directory.
*
* @package WordPress
* @since 2.6.0
*
* @param string $path Optional. Path relative to the includes url.
* @return string Includes url link with optional path appended.
*/
function includes_url($path = '') {
$url = site_url() . '/' . WPINC . '/';
if ( !empty($path) && is_string($path) && strpos($path, '..') === false )
$url .= ltrim($path, '/');
return $url;
}
/**
* Retrieve the url to the content directory.
*
* @package WordPress
* @since 2.6.0
*
* @param string $path Optional. Path relative to the content url.
* @return string Content url link with optional path appended.
*/
function content_url($path = '') {
$scheme = ( is_ssl() ? 'https' : 'http' );
$url = WP_CONTENT_URL;
if ( 0 === strpos($url, 'http') ) {
if ( is_ssl() )
$url = str_replace( 'http://', "{$scheme}://", $url );
}
if ( !empty($path) && is_string($path) && strpos($path, '..') === false )
$url .= '/' . ltrim($path, '/');
return $url;
}
/**
* Retrieve the url to the plugins directory.
*
* @package WordPress
* @since 2.6.0
*
* @param string $path Optional. Path relative to the plugins url.
* @return string Plugins url link with optional path appended.
*/
function plugins_url($path = '') {
$scheme = ( is_ssl() ? 'https' : 'http' );
$url = WP_PLUGIN_URL;
if ( 0 === strpos($url, 'http') ) {
if ( is_ssl() )
$url = str_replace( 'http://', "{$scheme}://", $url );
}
if ( !empty($path) && is_string($path) && strpos($path, '..') === false )
$url .= '/' . ltrim($path, '/');
return $url;
}
?>
waterwise-wp/wp-includes/bookmark-template.php 0000644 0001033 0000041 00000022415 11121657265 021703 0 ustar robert www-data <?php
/**
* Bookmark Template Functions for usage in Themes
*
* @package WordPress
* @subpackage Template
*/
/**
* The formatted output of a list of bookmarks.
*
* The $bookmarks array must contain bookmark objects and will be iterated over
* to retrieve the bookmark to be used in the output.
*
* The output is formatted as HTML with no way to change that format. However,
* what is between, before, and after can be changed. The link itself will be
* HTML.
*
* This function is used internally by wp_list_bookmarks() and should not be
* used by themes.
*
* The defaults for overwriting are:
* 'show_updated' - Default is 0 (integer). Will show the time of when the
* bookmark was last updated.
* 'show_description' - Default is 0 (integer). Whether to show the description
* of the bookmark.
* 'show_images' - Default is 1 (integer). Whether to show link image if
* available.
* 'show_name' - Default is 0 (integer). Whether to show link name if
* available.
* 'before' - Default is '<li>' (string). The html or text to prepend to each
* bookmarks.
* 'after' - Default is '</li>' (string). The html or text to append to each
* bookmarks.
* 'link_before' - Default is '' (string). The html or text to prepend to each
* bookmarks inside the <a> tag.
* 'link_after' - Default is '' (string). The html or text to append to each
* bookmarks inside the <a> tag.
* 'between' - Default is '\n' (string). The string for use in between the link,
* description, and image.
* 'show_rating' - Default is 0 (integer). Whether to show the link rating.
*
* @since 2.1.0
* @access private
* @usedby wp_list_bookmarks()
*
* @param array $bookmarks List of bookmarks to traverse
* @param string|array $args Optional. Overwrite the defaults.
* @return string Formatted output in HTML
*/
function _walk_bookmarks($bookmarks, $args = '' ) {
$defaults = array(
'show_updated' => 0, 'show_description' => 0,
'show_images' => 1, 'show_name' => 0,
'before' => '<li>', 'after' => '</li>', 'between' => "\n",
'show_rating' => 0, 'link_before' => '', 'link_after' => ''
);
$r = wp_parse_args( $args, $defaults );
extract( $r, EXTR_SKIP );
$output = ''; // Blank string to start with.
foreach ( (array) $bookmarks as $bookmark ) {
if ( !isset($bookmark->recently_updated) )
$bookmark->recently_updated = false;
$output .= $before;
if ( $show_updated && $bookmark->recently_updated )
$output .= get_option('links_recently_updated_prepend');
$the_link = '#';
if ( !empty($bookmark->link_url) )
$the_link = clean_url($bookmark->link_url);
$rel = $bookmark->link_rel;
if ( '' != $rel )
$rel = ' rel="' . $rel . '"';
$desc = attribute_escape(sanitize_bookmark_field('link_description', $bookmark->link_description, $bookmark->link_id, 'display'));
$name = attribute_escape(sanitize_bookmark_field('link_name', $bookmark->link_name, $bookmark->link_id, 'display'));
$title = $desc;
if ( $show_updated )
if ( '00' != substr($bookmark->link_updated_f, 0, 2) ) {
$title .= ' (';
$title .= sprintf(__('Last updated: %s'), date(get_option('links_updated_date_format'), $bookmark->link_updated_f + (get_option('gmt_offset') * 3600)));
$title .= ')';
}
if ( '' != $title )
$title = ' title="' . $title . '"';
$alt = ' alt="' . $name . '"';
$target = $bookmark->link_target;
if ( '' != $target )
$target = ' target="' . $target . '"';
$output .= '<a href="' . $the_link . '"' . $rel . $title . $target. '>';
$output .= $link_before;
if ( $bookmark->link_image != null && $show_images ) {
if ( strpos($bookmark->link_image, 'http') !== false )
$output .= "<img src=\"$bookmark->link_image\" $alt $title />";
else // If it's a relative path
$output .= "<img src=\"" . get_option('siteurl') . "$bookmark->link_image\" $alt $title />";
if ($show_name) $output .= $name;
} else {
$output .= $name;
}
$output .= $link_after;
$output .= '</a>';
if ( $show_updated && $bookmark->recently_updated )
$output .= get_option('links_recently_updated_append');
if ( $show_description && '' != $desc )
$output .= $between . $desc;
if ($show_rating) {
$output .= $between . sanitize_bookmark_field('link_rating', $bookmark->link_rating, $bookmark->link_id, 'display');
}
$output .= "$after\n";
} // end while
return $output;
}
/**
* Retrieve or echo all of the bookmarks.
*
* List of default arguments are as follows:
* 'orderby' - Default is 'name' (string). How to order the links by. String is
* based off of the bookmark scheme.
* 'order' - Default is 'ASC' (string). Either 'ASC' or 'DESC'. Orders in either
* ascending or descending order.
* 'limit' - Default is -1 (integer) or show all. The amount of bookmarks to
* display.
* 'category' - Default is empty string (string). Include the links in what
* category ID(s).
* 'category_name' - Default is empty string (string). Get links by category
* name.
* 'hide_invisible' - Default is 1 (integer). Whether to show (default) or hide
* links marked as 'invisible'.
* 'show_updated' - Default is 0 (integer). Will show the time of when the
* bookmark was last updated.
* 'echo' - Default is 1 (integer). Whether to echo (default) or return the
* formatted bookmarks.
* 'categorize' - Default is 1 (integer). Whether to show links listed by
* category (default) or show links in one column.
*
* These options define how the Category name will appear before the category
* links are displayed, if 'categorize' is 1. If 'categorize' is 0, then it will
* display for only the 'title_li' string and only if 'title_li' is not empty.
* 'title_li' - Default is 'Bookmarks' (translatable string). What to show
* before the links appear.
* 'title_before' - Default is '<h2>' (string). The HTML or text to show before
* the 'title_li' string.
* 'title_after' - Default is '</h2>' (string). The HTML or text to show after
* the 'title_li' string.
* 'class' - Default is 'linkcat' (string). The CSS class to use for the
* 'title_li'.
*
* 'category_before' - Default is '<li id="%id" class="%class">'. String must
* contain '%id' and '%class' to get
* the id of the category and the 'class' argument. These are used for
* formatting in themes.
* Argument will be displayed before the 'title_before' argument.
* 'category_after' - Default is '</li>' (string). The HTML or text that will
* appear after the list of links.
*
* These are only used if 'categorize' is set to 1 or true.
* 'category_orderby' - Default is 'name'. How to order the bookmark category
* based on term scheme.
* 'category_order' - Default is 'ASC'. Set the order by either ASC (ascending)
* or DESC (descending).
*
* @see _walk_bookmarks() For other arguments that can be set in this function
* and passed to _walk_bookmarks().
* @see get_bookmarks() For other arguments that can be set in this function and
* passed to get_bookmarks().
* @link http://codex.wordpress.org/Template_Tags/wp_list_bookmarks
*
* @since 2.1.0
* @uses _list_bookmarks() Used to iterate over all of the bookmarks and return
* the html
* @uses get_terms() Gets all of the categories that are for links.
*
* @param string|array $args Optional. Overwrite the defaults of the function
* @return string|null Will only return if echo option is set to not echo.
* Default is not return anything.
*/
function wp_list_bookmarks($args = '') {
$defaults = array(
'orderby' => 'name', 'order' => 'ASC',
'limit' => -1, 'category' => '', 'exclude_category' => '',
'category_name' => '', 'hide_invisible' => 1,
'show_updated' => 0, 'echo' => 1,
'categorize' => 1, 'title_li' => __('Bookmarks'),
'title_before' => '<h2>', 'title_after' => '</h2>',
'category_orderby' => 'name', 'category_order' => 'ASC',
'class' => 'linkcat', 'category_before' => '<li id="%id" class="%class">',
'category_after' => '</li>'
);
$r = wp_parse_args( $args, $defaults );
extract( $r, EXTR_SKIP );
$output = '';
if ( $categorize ) {
//Split the bookmarks into ul's for each category
$cats = get_terms('link_category', array('name__like' => $category_name, 'include' => $category, 'exclude' => $exclude_category, 'orderby' => $category_orderby, 'order' => $category_order, 'hierarchical' => 0));
foreach ( (array) $cats as $cat ) {
$params = array_merge($r, array('category'=>$cat->term_id));
$bookmarks = get_bookmarks($params);
if ( empty($bookmarks) )
continue;
$output .= str_replace(array('%id', '%class'), array("linkcat-$cat->term_id", $class), $category_before);
$catname = apply_filters( "link_category", $cat->name );
$output .= "$title_before$catname$title_after\n\t<ul class='xoxo blogroll'>\n";
$output .= _walk_bookmarks($bookmarks, $r);
$output .= "\n\t</ul>\n$category_after\n";
}
} else {
//output one single list using title_li for the title
$bookmarks = get_bookmarks($r);
if ( !empty($bookmarks) ) {
if ( !empty( $title_li ) ){
$output .= str_replace(array('%id', '%class'), array("linkcat-$category", $class), $category_before);
$output .= "$title_before$title_li$title_after\n\t<ul class='xoxo blogroll'>\n";
$output .= _walk_bookmarks($bookmarks, $r);
$output .= "\n\t</ul>\n$category_after\n";
} else {
$output .= _walk_bookmarks($bookmarks, $r);
}
}
}
$output = apply_filters( 'wp_list_bookmarks', $output );
if ( !$echo )
return $output;
echo $output;
}
?>
waterwise-wp/wp-includes/http.php 0000644 0001033 0000041 00000116124 11130712501 017226 0 ustar robert www-data <?php
/**
* Simple and uniform HTTP request API.
*
* Will eventually replace and standardize the WordPress HTTP requests made.
*
* @link http://trac.wordpress.org/ticket/4779 HTTP API Proposal
*
* @package WordPress
* @subpackage HTTP
* @since 2.7
* @author Jacob Santos <wordpress@santosj.name>
*/
/**
* WordPress HTTP Class for managing HTTP Transports and making HTTP requests.
*
* This class is called for the functionality of making HTTP requests and should
* replace Snoopy functionality, eventually. There is no available functionality
* to add HTTP transport implementations, since most of the HTTP transports are
* added and available for use.
*
* The exception is that cURL is not available as a transport and lacking an
* implementation. It will be added later and should be a patch on the WordPress
* Trac.
*
* There are no properties, because none are needed and for performance reasons.
* Some of the functions are static and while they do have some overhead over
* functions in PHP4, the purpose is maintainability. When PHP5 is finally the
* requirement, it will be easy to add the static keyword to the code. It is not
* as easy to convert a function to a method after enough code uses the old way.
*
* @package WordPress
* @subpackage HTTP
* @since 2.7
*/
class WP_Http {
/**
* PHP4 style Constructor - Calls PHP5 Style Constructor
*
* @since 2.7
* @return WP_Http
*/
function WP_Http() {
$this->__construct();
}
/**
* PHP5 style Constructor - Setup available transport if not available.
*
* PHP4 does not have the 'self' keyword and since WordPress supports PHP4,
* the class needs to be used for the static call.
*
* The transport are setup to save time. This should only be called once, so
* the overhead should be fine.
*
* @since 2.7
* @return WP_Http
*/
function __construct() {
WP_Http::_getTransport();
WP_Http::_postTransport();
}
/**
* Tests the WordPress HTTP objects for an object to use and returns it.
*
* Tests all of the objects and returns the object that passes. Also caches
* that object to be used later.
*
* The order for the GET/HEAD requests are Streams, HTTP Extension, Fopen,
* and finally Fsockopen. fsockopen() is used last, because it has the most
* overhead in its implementation. There isn't any real way around it, since
* redirects have to be supported, much the same way the other transports
* also handle redirects.
*
* There are currently issues with "localhost" not resolving correctly with
* DNS. This may cause an error "failed to open stream: A connection attempt
* failed because the connected party did not properly respond after a
* period of time, or established connection failed because connected host
* has failed to respond."
*
* @since 2.7
* @access private
*
* @param array $args Request args, default us an empty array
* @return object|null Null if no transports are available, HTTP transport object.
*/
function &_getTransport( $args = array() ) {
static $working_transport, $blocking_transport, $nonblocking_transport;
if ( is_null($working_transport) ) {
if ( true === WP_Http_ExtHttp::test() && apply_filters('use_http_extension_transport', true) ) {
$working_transport['exthttp'] = new WP_Http_ExtHttp();
$blocking_transport[] = &$working_transport['exthttp'];
} else if ( true === WP_Http_Curl::test() && apply_filters('use_curl_transport', true) ) {
$working_transport['curl'] = new WP_Http_Curl();
$blocking_transport[] = &$working_transport['curl'];
} else if ( true === WP_Http_Streams::test() && apply_filters('use_streams_transport', true) ) {
$working_transport['streams'] = new WP_Http_Streams();
$blocking_transport[] = &$working_transport['streams'];
} else if ( true === WP_Http_Fopen::test() && apply_filters('use_fopen_transport', true) ) {
$working_transport['fopen'] = new WP_Http_Fopen();
$blocking_transport[] = &$working_transport['fopen'];
} else if ( true === WP_Http_Fsockopen::test() && apply_filters('use_fsockopen_transport', true) ) {
$working_transport['fsockopen'] = new WP_Http_Fsockopen();
$blocking_transport[] = &$working_transport['fsockopen'];
}
foreach ( array('curl', 'streams', 'fopen', 'fsockopen', 'exthttp') as $transport ) {
if ( isset($working_transport[$transport]) )
$nonblocking_transport[] = &$working_transport[$transport];
}
}
if ( isset($args['blocking']) && !$args['blocking'] )
return $nonblocking_transport;
else
return $blocking_transport;
}
/**
* Tests the WordPress HTTP objects for an object to use and returns it.
*
* Tests all of the objects and returns the object that passes. Also caches
* that object to be used later. This is for posting content to a URL and
* is used when there is a body. The plain Fopen Transport can not be used
* to send content, but the streams transport can. This is a limitation that
* is addressed here, by just not including that transport.
*
* @since 2.7
* @access private
*
* @param array $args Request args, default us an empty array
* @return object|null Null if no transports are available, HTTP transport object.
*/
function &_postTransport( $args = array() ) {
static $working_transport, $blocking_transport, $nonblocking_transport;
if ( is_null($working_transport) ) {
if ( true === WP_Http_ExtHttp::test() && apply_filters('use_http_extension_transport', true) ) {
$working_transport['exthttp'] = new WP_Http_ExtHttp();
$blocking_transport[] = &$working_transport['exthttp'];
} else if ( true === WP_Http_Streams::test() && apply_filters('use_streams_transport', true) ) {
$working_transport['streams'] = new WP_Http_Streams();
$blocking_transport[] = &$working_transport['streams'];
} else if ( true === WP_Http_Fsockopen::test() && apply_filters('use_fsockopen_transport', true) ) {
$working_transport['fsockopen'] = new WP_Http_Fsockopen();
$blocking_transport[] = &$working_transport['fsockopen'];
}
foreach ( array('streams', 'fsockopen', 'exthttp') as $transport ) {
if ( isset($working_transport[$transport]) )
$nonblocking_transport[] = &$working_transport[$transport];
}
}
if ( isset($args['blocking']) && !$args['blocking'] )
return $nonblocking_transport;
else
return $blocking_transport;
}
/**
* Send a HTTP request to a URI.
*
* The body and headers are part of the arguments. The 'body' argument is
* for the body and will accept either a string or an array. The 'headers'
* argument should be an array, but a string is acceptable. If the 'body'
* argument is an array, then it will automatically be escaped using
* http_build_query().
*
* The only URI that are supported in the HTTP Transport implementation are
* the HTTP and HTTPS protocols. HTTP and HTTPS are assumed so the server
* might not know how to handle the send headers. Other protocols are
* unsupported and most likely will fail.
*
* The defaults are 'method', 'timeout', 'redirection', 'httpversion',
* 'blocking' and 'user-agent'.
*
* Accepted 'method' values are 'GET', 'POST', and 'HEAD', some transports
* technically allow others, but should not be assumed. The 'timeout' is
* used to sent how long the connection should stay open before failing when
* no response. 'redirection' is used to track how many redirects were taken
* and used to sent the amount for other transports, but not all transports
* accept setting that value.
*
* The 'httpversion' option is used to sent the HTTP version and accepted
* values are '1.0', and '1.1' and should be a string. Version 1.1 is not
* supported, because of chunk response. The 'user-agent' option is the
* user-agent and is used to replace the default user-agent, which is
* 'WordPress/WP_Version', where WP_Version is the value from $wp_version.
*
* 'blocking' is the default, which is used to tell the transport, whether
* it should halt PHP while it performs the request or continue regardless.
* Actually, that isn't entirely correct. Blocking mode really just means
* whether the fread should just pull what it can whenever it gets bytes or
* if it should wait until it has enough in the buffer to read or finishes
* reading the entire content. It doesn't actually always mean that PHP will
* continue going after making the request.
*
* @access public
* @since 2.7
*
* @param string $url URI resource.
* @param str|array $args Optional. Override the defaults.
* @return boolean
*/
function request( $url, $args = array() ) {
global $wp_version;
$defaults = array(
'method' => 'GET',
'timeout' => apply_filters( 'http_request_timeout', 5),
'redirection' => apply_filters( 'http_request_redirection_count', 5),
'httpversion' => apply_filters( 'http_request_version', '1.0'),
'user-agent' => apply_filters( 'http_headers_useragent', 'WordPress/' . $wp_version ),
'blocking' => true,
'headers' => array(), 'body' => null
);
$r = wp_parse_args( $args, $defaults );
$r = apply_filters( 'http_request_args', $r );
if ( is_null( $r['headers'] ) )
$r['headers'] = array();
if ( ! is_array($r['headers']) ) {
$processedHeaders = WP_Http::processHeaders($r['headers']);
$r['headers'] = $processedHeaders['headers'];
}
if ( isset($r['headers']['User-Agent']) ) {
$r['user-agent'] = $r['headers']['User-Agent'];
unset($r['headers']['User-Agent']);
}
if ( isset($r['headers']['user-agent']) ) {
$r['user-agent'] = $r['headers']['user-agent'];
unset($r['headers']['user-agent']);
}
if ( is_null($r['body']) ) {
// Some servers fail when sending content without the content-length
// header being set.
$r['headers']['Content-Length'] = 0;
$transports = WP_Http::_getTransport($r);
} else {
if ( is_array( $r['body'] ) || is_object( $r['body'] ) ) {
$r['body'] = http_build_query($r['body'], null, '&');
$r['headers']['Content-Type'] = 'application/x-www-form-urlencoded; charset=' . get_option('blog_charset');
$r['headers']['Content-Length'] = strlen($r['body']);
}
if ( ! isset( $r['headers']['Content-Length'] ) && ! isset( $r['headers']['content-length'] ) )
$r['headers']['Content-Length'] = strlen($r['body']);
$transports = WP_Http::_postTransport($r);
}
$response = array( 'headers' => array(), 'body' => '', 'response' => array('code', 'message') );
foreach( (array) $transports as $transport ) {
$response = $transport->request($url, $r);
if( !is_wp_error($response) )
return $response;
}
return $response;
}
/**
* Uses the POST HTTP method.
*
* Used for sending data that is expected to be in the body.
*
* @access public
* @since 2.7
*
* @param string $url URI resource.
* @param str|array $args Optional. Override the defaults.
* @return boolean
*/
function post($url, $args = array()) {
$defaults = array('method' => 'POST');
$r = wp_parse_args( $args, $defaults );
return $this->request($url, $r);
}
/**
* Uses the GET HTTP method.
*
* Used for sending data that is expected to be in the body.
*
* @access public
* @since 2.7
*
* @param string $url URI resource.
* @param str|array $args Optional. Override the defaults.
* @return boolean
*/
function get($url, $args = array()) {
$defaults = array('method' => 'GET');
$r = wp_parse_args( $args, $defaults );
return $this->request($url, $r);
}
/**
* Uses the HEAD HTTP method.
*
* Used for sending data that is expected to be in the body.
*
* @access public
* @since 2.7
*
* @param string $url URI resource.
* @param str|array $args Optional. Override the defaults.
* @return boolean
*/
function head($url, $args = array()) {
$defaults = array('method' => 'HEAD');
$r = wp_parse_args( $args, $defaults );
return $this->request($url, $r);
}
/**
* Parses the responses and splits the parts into headers and body.
*
* @access public
* @static
* @since 2.7
*
* @param string $strResponse The full response string
* @return array Array with 'headers' and 'body' keys.
*/
function processResponse($strResponse) {
list($theHeaders, $theBody) = explode("\r\n\r\n", $strResponse, 2);
return array('headers' => $theHeaders, 'body' => $theBody);
}
/**
* Transform header string into an array.
*
* If an array is given then it is assumed to be raw header data with
* numeric keys with the headers as the values. No headers must be passed
* that were already processed.
*
* @access public
* @static
* @since 2.7
*
* @param string|array $headers
* @return array Processed string headers
*/
function processHeaders($headers) {
if ( is_string($headers) )
$headers = explode("\n", str_replace(array("\r\n", "\r"), "\n", $headers) );
$response = array('code' => 0, 'message' => '');
$newheaders = array();
foreach ( $headers as $tempheader ) {
if ( empty($tempheader) )
continue;
if ( false === strpos($tempheader, ':') ) {
list( , $iResponseCode, $strResponseMsg) = explode(' ', $tempheader, 3);
$response['code'] = $iResponseCode;
$response['message'] = $strResponseMsg;
continue;
}
list($key, $value) = explode(':', $tempheader, 2);
if ( ! empty($value) )
$newheaders[strtolower($key)] = trim($value);
}
return array('response' => $response, 'headers' => $newheaders);
}
/**
* Decodes chunk transfer-encoding, based off the HTTP 1.1 specification.
*
* Based off the HTTP http_encoding_dechunk function. Does not support
* UTF-8. Does not support returning footer headers. Shouldn't be too
* difficult to support it though.
*
* @todo Add support for footer chunked headers.
* @access public
* @since 2.7
* @static
*
* @param string $body Body content
* @return string Chunked decoded body on success or raw body on failure.
*/
function chunkTransferDecode($body) {
$body = str_replace(array("\r\n", "\r"), "\n", $body);
// The body is not chunked encoding or is malformed.
if ( ! preg_match( '/^[0-9a-f]+(\s|\n)+/mi', trim($body) ) )
return $body;
$parsedBody = '';
//$parsedHeaders = array(); Unsupported
while ( true ) {
$hasChunk = (bool) preg_match( '/^([0-9a-f]+)(\s|\n)+/mi', $body, $match );
if ( $hasChunk ) {
if ( empty($match[1]) )
return $body;
$length = hexdec( $match[1] );
$chunkLength = strlen( $match[0] );
$strBody = substr($body, $chunkLength, $length);
$parsedBody .= $strBody;
$body = ltrim(str_replace(array($match[0], $strBody), '', $body), "\n");
if( "0" == trim($body) )
return $parsedBody; // Ignore footer headers.
} else {
return $body;
}
}
}
}
/**
* HTTP request method uses fsockopen function to retrieve the url.
*
* This would be the preferred method, but the fsockopen implementation has the
* most overhead of all the HTTP transport implementations.
*
* @package WordPress
* @subpackage HTTP
* @since 2.7
*/
class WP_Http_Fsockopen {
/**
* Send a HTTP request to a URI using fsockopen().
*
* Does not support non-blocking mode.
*
* @see WP_Http::request For default options descriptions.
*
* @since 2.7
* @access public
* @param string $url URI resource.
* @param str|array $args Optional. Override the defaults.
* @return array 'headers', 'body', and 'response' keys.
*/
function request($url, $args = array()) {
$defaults = array(
'method' => 'GET', 'timeout' => 5,
'redirection' => 5, 'httpversion' => '1.0',
'blocking' => true,
'headers' => array(), 'body' => null
);
$r = wp_parse_args( $args, $defaults );
if ( isset($r['headers']['User-Agent']) ) {
$r['user-agent'] = $r['headers']['User-Agent'];
unset($r['headers']['User-Agent']);
} else if( isset($r['headers']['user-agent']) ) {
$r['user-agent'] = $r['headers']['user-agent'];
unset($r['headers']['user-agent']);
}
$iError = null; // Store error number
$strError = null; // Store error string
$arrURL = parse_url($url);
$secure_transport = false;
if ( ! isset($arrURL['port']) ) {
if ( ($arrURL['scheme'] == 'ssl' || $arrURL['scheme'] == 'https') && extension_loaded('openssl') ) {
$arrURL['host'] = 'ssl://' . $arrURL['host'];
$arrURL['port'] = apply_filters('http_request_port', 443);
$secure_transport = true;
} else {
$arrURL['port'] = apply_filters('http_request_default_port', 80);
}
} else {
$arrURL['port'] = apply_filters('http_request_port', $arrURL['port']);
}
// There are issues with the HTTPS and SSL protocols that cause errors
// that can be safely ignored and should be ignored.
if ( true === $secure_transport )
$error_reporting = error_reporting(0);
$startDelay = time();
if ( !defined('WP_DEBUG') || ( defined('WP_DEBUG') && false === WP_DEBUG ) )
$handle = @fsockopen($arrURL['host'], $arrURL['port'], $iError, $strError, $r['timeout'] );
else
$handle = fsockopen($arrURL['host'], $arrURL['port'], $iError, $strError, $r['timeout'] );
$endDelay = time();
// If the delay is greater than the timeout then fsockopen should't be
// used, because it will cause a long delay.
$elapseDelay = ($endDelay-$startDelay) > $r['timeout'];
if ( true === $elapseDelay )
add_option( 'disable_fsockopen', $endDelay, null, true );
if ( false === $handle )
return new WP_Error('http_request_failed', $iError . ': ' . $strError);
// WordPress supports PHP 4.3, which has this function. Removed sanity
// checking for performance reasons.
stream_set_timeout($handle, $r['timeout'] );
$requestPath = $arrURL['path'] . ( isset($arrURL['query']) ? '?' . $arrURL['query'] : '' );
$requestPath = empty($requestPath) ? '/' : $requestPath;
$strHeaders = '';
$strHeaders .= strtoupper($r['method']) . ' ' . $requestPath . ' HTTP/' . $r['httpversion'] . "\r\n";
$strHeaders .= 'Host: ' . $arrURL['host'] . "\r\n";
if( isset($r['user-agent']) )
$strHeaders .= 'User-agent: ' . $r['user-agent'] . "\r\n";
if ( is_array($r['headers']) ) {
foreach ( (array) $r['headers'] as $header => $headerValue )
$strHeaders .= $header . ': ' . $headerValue . "\r\n";
} else {
$strHeaders .= $r['headers'];
}
$strHeaders .= "\r\n";
if ( ! is_null($r['body']) )
$strHeaders .= $r['body'];
fwrite($handle, $strHeaders);
if ( ! $r['blocking'] ) {
fclose($handle);
return array( 'headers' => array(), 'body' => '', 'response' => array('code', 'message') );
}
$strResponse = '';
while ( ! feof($handle) )
$strResponse .= fread($handle, 4096);
fclose($handle);
if ( true === $secure_transport )
error_reporting($error_reporting);
$process = WP_Http::processResponse($strResponse);
$arrHeaders = WP_Http::processHeaders($process['headers']);
// Is the response code within the 400 range?
if ( (int) $arrHeaders['response']['code'] >= 400 && (int) $arrHeaders['response']['code'] < 500 )
return new WP_Error('http_request_failed', $arrHeaders['response']['code'] . ': ' . $arrHeaders['response']['message']);
// If location is found, then assume redirect and redirect to location.
if ( isset($arrHeaders['headers']['location']) ) {
if ( $r['redirection']-- > 0 ) {
return $this->request($arrHeaders['headers']['location'], $r);
} else {
return new WP_Error('http_request_failed', __('Too many redirects.'));
}
}
// If the body was chunk encoded, then decode it.
if ( ! empty( $process['body'] ) && isset( $arrHeaders['headers']['transfer-encoding'] ) && 'chunked' == $arrHeaders['headers']['transfer-encoding'] )
$process['body'] = WP_Http::chunkTransferDecode($process['body']);
return array('headers' => $arrHeaders['headers'], 'body' => $process['body'], 'response' => $arrHeaders['response']);
}
/**
* Whether this class can be used for retrieving an URL.
*
* @since 2.7
* @static
* @return boolean False means this class can not be used, true means it can.
*/
function test() {
if ( false !== ($option = get_option( 'disable_fsockopen' )) && time()-$option < 43200 ) // 12 hours
return false;
if ( function_exists( 'fsockopen' ) )
return true;
return false;
}
}
/**
* HTTP request method uses fopen function to retrieve the url.
*
* Requires PHP version greater than 4.3.0 for stream support. Does not allow
* for $context support, but should still be okay, to write the headers, before
* getting the response. Also requires that 'allow_url_fopen' to be enabled.
*
* @package WordPress
* @subpackage HTTP
* @since 2.7
*/
class WP_Http_Fopen {
/**
* Send a HTTP request to a URI using fopen().
*
* This transport does not support sending of headers and body, therefore
* should not be used in the instances, where there is a body and headers.
*
* Notes: Does not support non-blocking mode. Ignores 'redirection' option.
*
* @see WP_Http::retrieve For default options descriptions.
*
* @access public
* @since 2.7
*
* @param string $url URI resource.
* @param str|array $args Optional. Override the defaults.
* @return array 'headers', 'body', and 'response' keys.
*/
function request($url, $args = array()) {
global $http_response_header;
$defaults = array(
'method' => 'GET', 'timeout' => 5,
'redirection' => 5, 'httpversion' => '1.0',
'blocking' => true,
'headers' => array(), 'body' => null
);
$r = wp_parse_args( $args, $defaults );
$arrURL = parse_url($url);
if ( false === $arrURL )
return new WP_Error('http_request_failed', sprintf(__('Malformed URL: %s'), $url));
if ( 'http' != $arrURL['scheme'] && 'https' != $arrURL['scheme'] )
$url = str_replace($arrURL['scheme'], 'http', $url);
if ( !defined('WP_DEBUG') || ( defined('WP_DEBUG') && false === WP_DEBUG ) )
$handle = @fopen($url, 'r');
else
$handle = fopen($url, 'r');
if (! $handle)
return new WP_Error('http_request_failed', sprintf(__('Could not open handle for fopen() to %s'), $url));
// WordPress supports PHP 4.3, which has this function. Removed sanity
// checking for performance reasons.
stream_set_timeout($handle, $r['timeout'] );
if ( ! $r['blocking'] ) {
fclose($handle);
return array( 'headers' => array(), 'body' => '', 'response' => array('code', 'message') );
}
$strResponse = '';
while ( ! feof($handle) )
$strResponse .= fread($handle, 4096);
$theHeaders = '';
if ( function_exists('stream_get_meta_data') ) {
$meta = stream_get_meta_data($handle);
$theHeaders = $meta['wrapper_data'];
if( isset( $meta['wrapper_data']['headers'] ) )
$theHeaders = $meta['wrapper_data']['headers'];
} else {
if( ! isset( $http_response_header ) )
global $http_response_header;
$theHeaders = $http_response_header;
}
fclose($handle);
$processedHeaders = WP_Http::processHeaders($theHeaders);
if ( ! empty( $strResponse ) && isset( $processedHeaders['headers']['transfer-encoding'] ) && 'chunked' == $processedHeaders['headers']['transfer-encoding'] )
$strResponse = WP_Http::chunkTransferDecode($strResponse);
return array('headers' => $processedHeaders['headers'], 'body' => $strResponse, 'response' => $processedHeaders['response']);
}
/**
* Whether this class can be used for retrieving an URL.
*
* @static
* @return boolean False means this class can not be used, true means it can.
*/
function test() {
if ( ! function_exists('fopen') || (function_exists('ini_get') && true != ini_get('allow_url_fopen')) )
return false;
return true;
}
}
/**
* HTTP request method uses Streams to retrieve the url.
*
* Requires PHP 5.0+ and uses fopen with stream context. Requires that
* 'allow_url_fopen' PHP setting to be enabled.
*
* Second preferred method for getting the URL, for PHP 5.
*
* @package WordPress
* @subpackage HTTP
* @since 2.7
*/
class WP_Http_Streams {
/**
* Send a HTTP request to a URI using streams with fopen().
*
* @access public
* @since 2.7
*
* @param string $url
* @param str|array $args Optional. Override the defaults.
* @return array 'headers', 'body', and 'response' keys.
*/
function request($url, $args = array()) {
$defaults = array(
'method' => 'GET', 'timeout' => 5,
'redirection' => 5, 'httpversion' => '1.0',
'blocking' => true,
'headers' => array(), 'body' => null
);
$r = wp_parse_args( $args, $defaults );
if ( isset($r['headers']['User-Agent']) ) {
$r['user-agent'] = $r['headers']['User-Agent'];
unset($r['headers']['User-Agent']);
} else if( isset($r['headers']['user-agent']) ) {
$r['user-agent'] = $r['headers']['user-agent'];
unset($r['headers']['user-agent']);
}
$arrURL = parse_url($url);
if ( false === $arrURL )
return new WP_Error('http_request_failed', sprintf(__('Malformed URL: %s'), $url));
if ( 'http' != $arrURL['scheme'] && 'https' != $arrURL['scheme'] )
$url = str_replace($arrURL['scheme'], 'http', $url);
// Convert Header array to string.
$strHeaders = '';
if ( is_array( $r['headers'] ) )
foreach( $r['headers'] as $name => $value )
$strHeaders .= "{$name}: $value\r\n";
else if ( is_string( $r['headers'] ) )
$strHeaders = $r['headers'];
$arrContext = array('http' =>
array(
'method' => strtoupper($r['method']),
'user_agent' => $r['user-agent'],
'max_redirects' => $r['redirection'],
'protocol_version' => (float) $r['httpversion'],
'header' => $strHeaders,
'timeout' => $r['timeout']
)
);
if ( ! is_null($r['body']) && ! empty($r['body'] ) )
$arrContext['http']['content'] = $r['body'];
$context = stream_context_create($arrContext);
if ( ! defined('WP_DEBUG') || ( defined('WP_DEBUG') && false === WP_DEBUG ) )
$handle = @fopen($url, 'r', false, $context);
else
$handle = fopen($url, 'r', false, $context);
if ( ! $handle)
return new WP_Error('http_request_failed', sprintf(__('Could not open handle for fopen() to %s'), $url));
// WordPress supports PHP 4.3, which has this function. Removed sanity
// checking for performance reasons.
stream_set_timeout($handle, $r['timeout'] );
if ( ! $r['blocking'] ) {
stream_set_blocking($handle, 0);
fclose($handle);
return array( 'headers' => array(), 'body' => '', 'response' => array('code', 'message') );
}
$strResponse = stream_get_contents($handle);
$meta = stream_get_meta_data($handle);
$processedHeaders = array();
if( isset( $meta['wrapper_data']['headers'] ) )
$processedHeaders = WP_Http::processHeaders($meta['wrapper_data']['headers']);
else
$processedHeaders = WP_Http::processHeaders($meta['wrapper_data']);
if ( ! empty( $strResponse ) && isset( $processedHeaders['headers']['transfer-encoding'] ) && 'chunked' == $processedHeaders['headers']['transfer-encoding'] )
$strResponse = WP_Http::chunkTransferDecode($strResponse);
fclose($handle);
return array('headers' => $processedHeaders['headers'], 'body' => $strResponse, 'response' => $processedHeaders['response']);
}
/**
* Whether this class can be used for retrieving an URL.
*
* @static
* @access public
* @since 2.7
*
* @return boolean False means this class can not be used, true means it can.
*/
function test() {
if ( ! function_exists('fopen') || (function_exists('ini_get') && true != ini_get('allow_url_fopen')) )
return false;
if ( version_compare(PHP_VERSION, '5.0', '<') )
return false;
return true;
}
}
/**
* HTTP request method uses HTTP extension to retrieve the url.
*
* Requires the HTTP extension to be installed. This would be the preferred
* transport since it can handle a lot of the problems that forces the others to
* use the HTTP version 1.0. Even if PHP 5.2+ is being used, it doesn't mean
* that the HTTP extension will be enabled.
*
* @package WordPress
* @subpackage HTTP
* @since 2.7
*/
class WP_Http_ExtHTTP {
/**
* Send a HTTP request to a URI using HTTP extension.
*
* Does not support non-blocking.
*
* @access public
* @since 2.7
*
* @param string $url
* @param str|array $args Optional. Override the defaults.
* @return array 'headers', 'body', and 'response' keys.
*/
function request($url, $args = array()) {
$defaults = array(
'method' => 'GET', 'timeout' => 5,
'redirection' => 5, 'httpversion' => '1.0',
'blocking' => true,
'headers' => array(), 'body' => null
);
$r = wp_parse_args( $args, $defaults );
if ( isset($r['headers']['User-Agent']) ) {
$r['user-agent'] = $r['headers']['User-Agent'];
unset($r['headers']['User-Agent']);
} else if( isset($r['headers']['user-agent']) ) {
$r['user-agent'] = $r['headers']['user-agent'];
unset($r['headers']['user-agent']);
}
switch ( $r['method'] ) {
case 'POST':
$r['method'] = HTTP_METH_POST;
break;
case 'HEAD':
$r['method'] = HTTP_METH_HEAD;
break;
case 'GET':
default:
$r['method'] = HTTP_METH_GET;
}
$arrURL = parse_url($url);
if ( 'http' != $arrURL['scheme'] || 'https' != $arrURL['scheme'] )
$url = str_replace($arrURL['scheme'], 'http', $url);
$options = array(
'timeout' => $r['timeout'],
'connecttimeout' => $r['timeout'],
'redirect' => $r['redirection'],
'useragent' => $r['user-agent'],
'headers' => $r['headers'],
);
if ( !defined('WP_DEBUG') || ( defined('WP_DEBUG') && false === WP_DEBUG ) ) //Emits warning level notices for max redirects and timeouts
$strResponse = @http_request($r['method'], $url, $r['body'], $options, $info);
else
$strResponse = http_request($r['method'], $url, $r['body'], $options, $info); //Emits warning level notices for max redirects and timeouts
if ( false === $strResponse || ! empty($info['error']) ) //Error may still be set, Response may return headers or partial document, and error contains a reason the request was aborted, eg, timeout expired or max-redirects reached
return new WP_Error('http_request_failed', $info['response_code'] . ': ' . $info['error']);
if ( ! $r['blocking'] )
return array( 'headers' => array(), 'body' => '', 'response' => array('code', 'message') );
list($theHeaders, $theBody) = explode("\r\n\r\n", $strResponse, 2);
$theHeaders = WP_Http::processHeaders($theHeaders);
if ( ! empty( $theBody ) && isset( $theHeaders['headers']['transfer-encoding'] ) && 'chunked' == $theHeaders['headers']['transfer-encoding'] ) {
if ( !defined('WP_DEBUG') || ( defined('WP_DEBUG') && false === WP_DEBUG ) )
$theBody = @http_chunked_decode($theBody);
else
$theBody = http_chunked_decode($theBody);
}
$theResponse = array();
$theResponse['code'] = $info['response_code'];
$theResponse['message'] = get_status_header_desc($info['response_code']);
return array('headers' => $theHeaders['headers'], 'body' => $theBody, 'response' => $theResponse);
}
/**
* Whether this class can be used for retrieving an URL.
*
* @static
* @since 2.7
*
* @return boolean False means this class can not be used, true means it can.
*/
function test() {
if ( function_exists('http_request') )
return true;
return false;
}
}
/**
* HTTP request method uses Curl extension to retrieve the url.
*
* Requires the Curl extension to be installed.
*
* @package WordPress
* @subpackage HTTP
* @since 2.7
*/
class WP_Http_Curl {
/**
* Send a HTTP request to a URI using cURL extension.
*
* @access public
* @since 2.7
*
* @param string $url
* @param str|array $args Optional. Override the defaults.
* @return array 'headers', 'body', and 'response' keys.
*/
function request($url, $args = array()) {
$defaults = array(
'method' => 'GET', 'timeout' => 5,
'redirection' => 5, 'httpversion' => '1.0',
'blocking' => true,
'headers' => array(), 'body' => null
);
$r = wp_parse_args( $args, $defaults );
if ( isset($r['headers']['User-Agent']) ) {
$r['user-agent'] = $r['headers']['User-Agent'];
unset($r['headers']['User-Agent']);
} else if( isset($r['headers']['user-agent']) ) {
$r['user-agent'] = $r['headers']['user-agent'];
unset($r['headers']['user-agent']);
}
// cURL extension will sometimes fail when the timeout is less than 1 as
// it may round down to 0, which gives it unlimited timeout.
if ( $r['timeout'] > 0 && $r['timeout'] < 1 )
$r['timeout'] = 1;
$handle = curl_init();
curl_setopt( $handle, CURLOPT_URL, $url);
// The cURL extension requires that the option be set for the HEAD to
// work properly.
if ( 'HEAD' === $r['method'] ) {
curl_setopt( $handle, CURLOPT_NOBODY, true );
}
if ( true === $r['blocking'] ) {
curl_setopt( $handle, CURLOPT_HEADER, true );
curl_setopt( $handle, CURLOPT_RETURNTRANSFER, 1 );
} else {
curl_setopt( $handle, CURLOPT_HEADER, false );
curl_setopt( $handle, CURLOPT_NOBODY, true );
curl_setopt( $handle, CURLOPT_RETURNTRANSFER, 0 );
}
curl_setopt( $handle, CURLOPT_USERAGENT, $r['user-agent'] );
curl_setopt( $handle, CURLOPT_CONNECTTIMEOUT, 1 );
curl_setopt( $handle, CURLOPT_TIMEOUT, $r['timeout'] );
curl_setopt( $handle, CURLOPT_MAXREDIRS, $r['redirection'] );
// The option doesn't work with safe mode or when open_basedir is set.
if ( !ini_get('safe_mode') && !ini_get('open_basedir') )
curl_setopt( $handle, CURLOPT_FOLLOWLOCATION, true );
if( ! is_null($r['headers']) )
curl_setopt( $handle, CURLOPT_HTTPHEADER, $r['headers'] );
if ( $r['httpversion'] == '1.0' )
curl_setopt( $handle, CURLOPT_HTTP_VERSION, CURL_HTTP_VERSION_1_0 );
else
curl_setopt( $handle, CURLOPT_HTTP_VERSION, CURL_HTTP_VERSION_1_1 );
if ( ! $r['blocking'] ) {
curl_exec( $handle );
curl_close( $handle );
return array( 'headers' => array(), 'body' => '', 'response' => array('code', 'message') );
}
$theResponse = curl_exec( $handle );
if ( !empty($theResponse) ) {
$headerLength = curl_getinfo($handle, CURLINFO_HEADER_SIZE);
$theHeaders = trim( substr($theResponse, 0, $headerLength) );
$theBody = substr( $theResponse, $headerLength );
if ( false !== strrpos($theHeaders, "\r\n\r\n") ) {
$headerParts = explode("\r\n\r\n", $theHeaders);
$theHeaders = $headerParts[ count($headerParts) -1 ];
}
$theHeaders = WP_Http::processHeaders($theHeaders);
} else {
if ( $curl_error = curl_error($handle) )
return new WP_Error('http_request_failed', $curl_error);
if ( in_array( curl_getinfo( $handle, CURLINFO_HTTP_CODE ), array(301, 302) ) )
return new WP_Error('http_request_failed', __('Too many redirects.'));
$theHeaders = array( 'headers' => array() );
$theBody = '';
}
$response = array();
$response['code'] = curl_getinfo( $handle, CURLINFO_HTTP_CODE );
$response['message'] = get_status_header_desc($response['code']);
curl_close( $handle );
return array('headers' => $theHeaders['headers'], 'body' => $theBody, 'response' => $response);
}
/**
* Whether this class can be used for retrieving an URL.
*
* @static
* @since 2.7
*
* @return boolean False means this class can not be used, true means it can.
*/
function test() {
if ( function_exists('curl_init') && function_exists('curl_exec') )
return true;
return false;
}
}
/**
* Returns the initialized WP_Http Object
*
* @since 2.7
* @access private
*
* @return WP_Http HTTP Transport object.
*/
function &_wp_http_get_object() {
static $http;
if ( is_null($http) )
$http = new WP_Http();
return $http;
}
/**
* Retrieve the raw response from the HTTP request.
*
* The array structure is a little complex.
*
* <code>
* $res = array( 'headers' => array(), 'response' => array('code', 'message') );
* </code>
*
* All of the headers in $res['headers'] are with the name as the key and the
* value as the value. So to get the User-Agent, you would do the following.
*
* <code>
* $user_agent = $res['headers']['user-agent'];
* </code>
*
* The body is the raw response content and can be retrieved from $res['body'].
*
* This function is called first to make the request and there are other API
* functions to abstract out the above convoluted setup.
*
* @since 2.7.0
*
* @param string $url Site URL to retrieve.
* @param array $args Optional. Override the defaults.
* @return string The body of the response
*/
function wp_remote_request($url, $args = array()) {
$objFetchSite = _wp_http_get_object();
return $objFetchSite->request($url, $args);
}
/**
* Retrieve the raw response from the HTTP request using the GET method.
*
* @see wp_remote_request() For more information on the response array format.
*
* @since 2.7
*
* @param string $url Site URL to retrieve.
* @param array $args Optional. Override the defaults.
* @return string The body of the response
*/
function wp_remote_get($url, $args = array()) {
$objFetchSite = _wp_http_get_object();
return $objFetchSite->get($url, $args);
}
/**
* Retrieve the raw response from the HTTP request using the POST method.
*
* @see wp_remote_request() For more information on the response array format.
*
* @since 2.7
*
* @param string $url Site URL to retrieve.
* @param array $args Optional. Override the defaults.
* @return string The body of the response
*/
function wp_remote_post($url, $args = array()) {
$objFetchSite = _wp_http_get_object();
return $objFetchSite->post($url, $args);
}
/**
* Retrieve the raw response from the HTTP request using the HEAD method.
*
* @see wp_remote_request() For more information on the response array format.
*
* @since 2.7
*
* @param string $url Site URL to retrieve.
* @param array $args Optional. Override the defaults.
* @return string The body of the response
*/
function wp_remote_head($url, $args = array()) {
$objFetchSite = _wp_http_get_object();
return $objFetchSite->head($url, $args);
}
/**
* Retrieve only the headers from the raw response.
*
* @since 2.7
*
* @param array $response HTTP response.
* @return array The headers of the response. Empty array if incorrect parameter given.
*/
function wp_remote_retrieve_headers(&$response) {
if ( ! isset($response['headers']) || ! is_array($response['headers']))
return array();
return $response['headers'];
}
/**
* Retrieve a single header by name from the raw response.
*
* @since 2.7
*
* @param array $response
* @param string $header Header name to retrieve value from.
* @return array The header value. Empty string on if incorrect parameter given.
*/
function wp_remote_retrieve_header(&$response, $header) {
if ( ! isset($response['headers']) || ! is_array($response['headers']))
return '';
if ( array_key_exists($header, $response['headers']) )
return $response['headers'][$header];
return '';
}
/**
* Retrieve only the response code from the raw response.
*
* Will return an empty array if incorrect parameter value is given.
*
* @since 2.7
*
* @param array $response HTTP response.
* @return array The keys 'code' and 'message' give information on the response.
*/
function wp_remote_retrieve_response_code(&$response) {
if ( ! isset($response['response']) || ! is_array($response['response']))
return '';
return $response['response']['code'];
}
/**
* Retrieve only the response message from the raw response.
*
* Will return an empty array if incorrect parameter value is given.
*
* @since 2.7
*
* @param array $response HTTP response.
* @return array The keys 'code' and 'message' give information on the response.
*/
function wp_remote_retrieve_response_message(&$response) {
if ( ! isset($response['response']) || ! is_array($response['response']))
return '';
return $response['response']['message'];
}
/**
* Retrieve only the body from the raw response.
*
* @since 2.7
*
* @param array $response HTTP response.
* @return string The body of the response. Empty string if no body or incorrect parameter given.
*/
function wp_remote_retrieve_body(&$response) {
if ( ! isset($response['body']) )
return '';
return $response['body'];
}
?>
waterwise-wp/wp-includes/class-pop3.php 0000644 0001033 0000041 00000050216 11103704127 020237 0 ustar robert www-data <?php
/**
* mail_fetch/setup.php
*
* @package SquirrelMail
*
* @copyright (c) 1999-2006 The SquirrelMail Project Team
*
* @copyright (c) 1999 CDI (cdi@thewebmasters.net) All Rights Reserved
* Modified by Philippe Mingo 2001 mingo@rotedic.com
* An RFC 1939 compliant wrapper class for the POP3 protocol.
*
* Licensed under the GNU GPL. For full terms see the file COPYING.
*
* pop3 class
*
* $Id: class-pop3.php 9503 2008-11-03 23:25:11Z ryan $
*/
class POP3 {
var $ERROR = ''; // Error string.
var $TIMEOUT = 60; // Default timeout before giving up on a
// network operation.
var $COUNT = -1; // Mailbox msg count
var $BUFFER = 512; // Socket buffer for socket fgets() calls.
// Per RFC 1939 the returned line a POP3
// server can send is 512 bytes.
var $FP = ''; // The connection to the server's
// file descriptor
var $MAILSERVER = ''; // Set this to hard code the server name
var $DEBUG = FALSE; // set to true to echo pop3
// commands and responses to error_log
// this WILL log passwords!
var $BANNER = ''; // Holds the banner returned by the
// pop server - used for apop()
var $ALLOWAPOP = FALSE; // Allow or disallow apop()
// This must be set to true
// manually
function POP3 ( $server = '', $timeout = '' ) {
settype($this->BUFFER,"integer");
if( !empty($server) ) {
// Do not allow programs to alter MAILSERVER
// if it is already specified. They can get around
// this if they -really- want to, so don't count on it.
if(empty($this->MAILSERVER))
$this->MAILSERVER = $server;
}
if(!empty($timeout)) {
settype($timeout,"integer");
$this->TIMEOUT = $timeout;
if (!ini_get('safe_mode'))
set_time_limit($timeout);
}
return true;
}
function update_timer () {
if (!ini_get('safe_mode'))
set_time_limit($this->TIMEOUT);
return true;
}
function connect ($server, $port = 110) {
// Opens a socket to the specified server. Unless overridden,
// port defaults to 110. Returns true on success, false on fail
// If MAILSERVER is set, override $server with it's value
if (!isset($port) || !$port) {$port = 110;}
if(!empty($this->MAILSERVER))
$server = $this->MAILSERVER;
if(empty($server)){
$this->ERROR = "POP3 connect: " . _("No server specified");
unset($this->FP);
return false;
}
$fp = @fsockopen("$server", $port, $errno, $errstr);
if(!$fp) {
$this->ERROR = "POP3 connect: " . _("Error ") . "[$errno] [$errstr]";
unset($this->FP);
return false;
}
socket_set_blocking($fp,-1);
$this->update_timer();
$reply = fgets($fp,$this->BUFFER);
$reply = $this->strip_clf($reply);
if($this->DEBUG)
error_log("POP3 SEND [connect: $server] GOT [$reply]",0);
if(!$this->is_ok($reply)) {
$this->ERROR = "POP3 connect: " . _("Error ") . "[$reply]";
unset($this->FP);
return false;
}
$this->FP = $fp;
$this->BANNER = $this->parse_banner($reply);
return true;
}
function user ($user = "") {
// Sends the USER command, returns true or false
if( empty($user) ) {
$this->ERROR = "POP3 user: " . _("no login ID submitted");
return false;
} elseif(!isset($this->FP)) {
$this->ERROR = "POP3 user: " . _("connection not established");
return false;
} else {
$reply = $this->send_cmd("USER $user");
if(!$this->is_ok($reply)) {
$this->ERROR = "POP3 user: " . _("Error ") . "[$reply]";
return false;
} else
return true;
}
}
function pass ($pass = "") {
// Sends the PASS command, returns # of msgs in mailbox,
// returns false (undef) on Auth failure
if(empty($pass)) {
$this->ERROR = "POP3 pass: " . _("No password submitted");
return false;
} elseif(!isset($this->FP)) {
$this->ERROR = "POP3 pass: " . _("connection not established");
return false;
} else {
$reply = $this->send_cmd("PASS $pass");
if(!$this->is_ok($reply)) {
$this->ERROR = "POP3 pass: " . _("Authentication failed") . " [$reply]";
$this->quit();
return false;
} else {
// Auth successful.
$count = $this->last("count");
$this->COUNT = $count;
return $count;
}
}
}
function apop ($login,$pass) {
// Attempts an APOP login. If this fails, it'll
// try a standard login. YOUR SERVER MUST SUPPORT
// THE USE OF THE APOP COMMAND!
// (apop is optional per rfc1939)
if(!isset($this->FP)) {
$this->ERROR = "POP3 apop: " . _("No connection to server");
return false;
} elseif(!$this->ALLOWAPOP) {
$retVal = $this->login($login,$pass);
return $retVal;
} elseif(empty($login)) {
$this->ERROR = "POP3 apop: " . _("No login ID submitted");
return false;
} elseif(empty($pass)) {
$this->ERROR = "POP3 apop: " . _("No password submitted");
return false;
} else {
$banner = $this->BANNER;
if( (!$banner) or (empty($banner)) ) {
$this->ERROR = "POP3 apop: " . _("No server banner") . ' - ' . _("abort");
$retVal = $this->login($login,$pass);
return $retVal;
} else {
$AuthString = $banner;
$AuthString .= $pass;
$APOPString = md5($AuthString);
$cmd = "APOP $login $APOPString";
$reply = $this->send_cmd($cmd);
if(!$this->is_ok($reply)) {
$this->ERROR = "POP3 apop: " . _("apop authentication failed") . ' - ' . _("abort");
$retVal = $this->login($login,$pass);
return $retVal;
} else {
// Auth successful.
$count = $this->last("count");
$this->COUNT = $count;
return $count;
}
}
}
}
function login ($login = "", $pass = "") {
// Sends both user and pass. Returns # of msgs in mailbox or
// false on failure (or -1, if the error occurs while getting
// the number of messages.)
if( !isset($this->FP) ) {
$this->ERROR = "POP3 login: " . _("No connection to server");
return false;
} else {
$fp = $this->FP;
if( !$this->user( $login ) ) {
// Preserve the error generated by user()
return false;
} else {
$count = $this->pass($pass);
if( (!$count) || ($count == -1) ) {
// Preserve the error generated by last() and pass()
return false;
} else
return $count;
}
}
}
function top ($msgNum, $numLines = "0") {
// Gets the header and first $numLines of the msg body
// returns data in an array with each returned line being
// an array element. If $numLines is empty, returns
// only the header information, and none of the body.
if(!isset($this->FP)) {
$this->ERROR = "POP3 top: " . _("No connection to server");
return false;
}
$this->update_timer();
$fp = $this->FP;
$buffer = $this->BUFFER;
$cmd = "TOP $msgNum $numLines";
fwrite($fp, "TOP $msgNum $numLines\r\n");
$reply = fgets($fp, $buffer);
$reply = $this->strip_clf($reply);
if($this->DEBUG) {
@error_log("POP3 SEND [$cmd] GOT [$reply]",0);
}
if(!$this->is_ok($reply))
{
$this->ERROR = "POP3 top: " . _("Error ") . "[$reply]";
return false;
}
$count = 0;
$MsgArray = array();
$line = fgets($fp,$buffer);
while ( !ereg("^\.\r\n",$line))
{
$MsgArray[$count] = $line;
$count++;
$line = fgets($fp,$buffer);
if(empty($line)) { break; }
}
return $MsgArray;
}
function pop_list ($msgNum = "") {
// If called with an argument, returns that msgs' size in octets
// No argument returns an associative array of undeleted
// msg numbers and their sizes in octets
if(!isset($this->FP))
{
$this->ERROR = "POP3 pop_list: " . _("No connection to server");
return false;
}
$fp = $this->FP;
$Total = $this->COUNT;
if( (!$Total) or ($Total == -1) )
{
return false;
}
if($Total == 0)
{
return array("0","0");
// return -1; // mailbox empty
}
$this->update_timer();
if(!empty($msgNum))
{
$cmd = "LIST $msgNum";
fwrite($fp,"$cmd\r\n");
$reply = fgets($fp,$this->BUFFER);
$reply = $this->strip_clf($reply);
if($this->DEBUG) {
@error_log("POP3 SEND [$cmd] GOT [$reply]",0);
}
if(!$this->is_ok($reply))
{
$this->ERROR = "POP3 pop_list: " . _("Error ") . "[$reply]";
return false;
}
list($junk,$num,$size) = preg_split('/\s+/',$reply);
return $size;
}
$cmd = "LIST";
$reply = $this->send_cmd($cmd);
if(!$this->is_ok($reply))
{
$reply = $this->strip_clf($reply);
$this->ERROR = "POP3 pop_list: " . _("Error ") . "[$reply]";
return false;
}
$MsgArray = array();
$MsgArray[0] = $Total;
for($msgC=1;$msgC <= $Total; $msgC++)
{
if($msgC > $Total) { break; }
$line = fgets($fp,$this->BUFFER);
$line = $this->strip_clf($line);
if(ereg("^\.",$line))
{
$this->ERROR = "POP3 pop_list: " . _("Premature end of list");
return false;
}
list($thisMsg,$msgSize) = preg_split('/\s+/',$line);
settype($thisMsg,"integer");
if($thisMsg != $msgC)
{
$MsgArray[$msgC] = "deleted";
}
else
{
$MsgArray[$msgC] = $msgSize;
}
}
return $MsgArray;
}
function get ($msgNum) {
// Retrieve the specified msg number. Returns an array
// where each line of the msg is an array element.
if(!isset($this->FP))
{
$this->ERROR = "POP3 get: " . _("No connection to server");
return false;
}
$this->update_timer();
$fp = $this->FP;
$buffer = $this->BUFFER;
$cmd = "RETR $msgNum";
$reply = $this->send_cmd($cmd);
if(!$this->is_ok($reply))
{
$this->ERROR = "POP3 get: " . _("Error ") . "[$reply]";
return false;
}
$count = 0;
$MsgArray = array();
$line = fgets($fp,$buffer);
while ( !ereg("^\.\r\n",$line))
{
if ( $line{0} == '.' ) { $line = substr($line,1); }
$MsgArray[$count] = $line;
$count++;
$line = fgets($fp,$buffer);
if(empty($line)) { break; }
}
return $MsgArray;
}
function last ( $type = "count" ) {
// Returns the highest msg number in the mailbox.
// returns -1 on error, 0+ on success, if type != count
// results in a popstat() call (2 element array returned)
$last = -1;
if(!isset($this->FP))
{
$this->ERROR = "POP3 last: " . _("No connection to server");
return $last;
}
$reply = $this->send_cmd("STAT");
if(!$this->is_ok($reply))
{
$this->ERROR = "POP3 last: " . _("Error ") . "[$reply]";
return $last;
}
$Vars = preg_split('/\s+/',$reply);
$count = $Vars[1];
$size = $Vars[2];
settype($count,"integer");
settype($size,"integer");
if($type != "count")
{
return array($count,$size);
}
return $count;
}
function reset () {
// Resets the status of the remote server. This includes
// resetting the status of ALL msgs to not be deleted.
// This method automatically closes the connection to the server.
if(!isset($this->FP))
{
$this->ERROR = "POP3 reset: " . _("No connection to server");
return false;
}
$reply = $this->send_cmd("RSET");
if(!$this->is_ok($reply))
{
// The POP3 RSET command -never- gives a -ERR
// response - if it ever does, something truely
// wild is going on.
$this->ERROR = "POP3 reset: " . _("Error ") . "[$reply]";
@error_log("POP3 reset: ERROR [$reply]",0);
}
$this->quit();
return true;
}
function send_cmd ( $cmd = "" )
{
// Sends a user defined command string to the
// POP server and returns the results. Useful for
// non-compliant or custom POP servers.
// Do NOT includ the \r\n as part of your command
// string - it will be appended automatically.
// The return value is a standard fgets() call, which
// will read up to $this->BUFFER bytes of data, until it
// encounters a new line, or EOF, whichever happens first.
// This method works best if $cmd responds with only
// one line of data.
if(!isset($this->FP))
{
$this->ERROR = "POP3 send_cmd: " . _("No connection to server");
return false;
}
if(empty($cmd))
{
$this->ERROR = "POP3 send_cmd: " . _("Empty command string");
return "";
}
$fp = $this->FP;
$buffer = $this->BUFFER;
$this->update_timer();
fwrite($fp,"$cmd\r\n");
$reply = fgets($fp,$buffer);
$reply = $this->strip_clf($reply);
if($this->DEBUG) { @error_log("POP3 SEND [$cmd] GOT [$reply]",0); }
return $reply;
}
function quit() {
// Closes the connection to the POP3 server, deleting
// any msgs marked as deleted.
if(!isset($this->FP))
{
$this->ERROR = "POP3 quit: " . _("connection does not exist");
return false;
}
$fp = $this->FP;
$cmd = "QUIT";
fwrite($fp,"$cmd\r\n");
$reply = fgets($fp,$this->BUFFER);
$reply = $this->strip_clf($reply);
if($this->DEBUG) { @error_log("POP3 SEND [$cmd] GOT [$reply]",0); }
fclose($fp);
unset($this->FP);
return true;
}
function popstat () {
// Returns an array of 2 elements. The number of undeleted
// msgs in the mailbox, and the size of the mbox in octets.
$PopArray = $this->last("array");
if($PopArray == -1) { return false; }
if( (!$PopArray) or (empty($PopArray)) )
{
return false;
}
return $PopArray;
}
function uidl ($msgNum = "")
{
// Returns the UIDL of the msg specified. If called with
// no arguments, returns an associative array where each
// undeleted msg num is a key, and the msg's uidl is the element
// Array element 0 will contain the total number of msgs
if(!isset($this->FP)) {
$this->ERROR = "POP3 uidl: " . _("No connection to server");
return false;
}
$fp = $this->FP;
$buffer = $this->BUFFER;
if(!empty($msgNum)) {
$cmd = "UIDL $msgNum";
$reply = $this->send_cmd($cmd);
if(!$this->is_ok($reply))
{
$this->ERROR = "POP3 uidl: " . _("Error ") . "[$reply]";
return false;
}
list ($ok,$num,$myUidl) = preg_split('/\s+/',$reply);
return $myUidl;
} else {
$this->update_timer();
$UIDLArray = array();
$Total = $this->COUNT;
$UIDLArray[0] = $Total;
if ($Total < 1)
{
return $UIDLArray;
}
$cmd = "UIDL";
fwrite($fp, "UIDL\r\n");
$reply = fgets($fp, $buffer);
$reply = $this->strip_clf($reply);
if($this->DEBUG) { @error_log("POP3 SEND [$cmd] GOT [$reply]",0); }
if(!$this->is_ok($reply))
{
$this->ERROR = "POP3 uidl: " . _("Error ") . "[$reply]";
return false;
}
$line = "";
$count = 1;
$line = fgets($fp,$buffer);
while ( !ereg("^\.\r\n",$line)) {
if(ereg("^\.\r\n",$line)) {
break;
}
list ($msg,$msgUidl) = preg_split('/\s+/',$line);
$msgUidl = $this->strip_clf($msgUidl);
if($count == $msg) {
$UIDLArray[$msg] = $msgUidl;
}
else
{
$UIDLArray[$count] = 'deleted';
}
$count++;
$line = fgets($fp,$buffer);
}
}
return $UIDLArray;
}
function delete ($msgNum = "") {
// Flags a specified msg as deleted. The msg will not
// be deleted until a quit() method is called.
if(!isset($this->FP))
{
$this->ERROR = "POP3 delete: " . _("No connection to server");
return false;
}
if(empty($msgNum))
{
$this->ERROR = "POP3 delete: " . _("No msg number submitted");
return false;
}
$reply = $this->send_cmd("DELE $msgNum");
if(!$this->is_ok($reply))
{
$this->ERROR = "POP3 delete: " . _("Command failed ") . "[$reply]";
return false;
}
return true;
}
// *********************************************************
// The following methods are internal to the class.
function is_ok ($cmd = "") {
// Return true or false on +OK or -ERR
if( empty($cmd) )
return false;
else
return( ereg ("^\+OK", $cmd ) );
}
function strip_clf ($text = "") {
// Strips \r\n from server responses
if(empty($text))
return $text;
else {
$stripped = str_replace("\r",'',$text);
$stripped = str_replace("\n",'',$stripped);
return $stripped;
}
}
function parse_banner ( $server_text ) {
$outside = true;
$banner = "";
$length = strlen($server_text);
for($count =0; $count < $length; $count++)
{
$digit = substr($server_text,$count,1);
if(!empty($digit)) {
if( (!$outside) && ($digit != '<') && ($digit != '>') )
{
$banner .= $digit;
}
if ($digit == '<')
{
$outside = false;
}
if($digit == '>')
{
$outside = true;
}
}
}
$banner = $this->strip_clf($banner); // Just in case
return "<$banner>";
}
} // End class
?>
waterwise-wp/wp-includes/feed-atom-comments.php 0000644 0001033 0000041 00000010256 11135435210 021736 0 ustar robert www-data <?php
/**
* Atom Feed Template for displaying Atom Comments feed.
*
* @package WordPress
*/
header('Content-Type: application/atom+xml; charset=' . get_option('blog_charset'), true);
echo '<?xml version="1.0" encoding="' . get_option('blog_charset') . '" ?' . '>';
?>
<feed
xmlns="http://www.w3.org/2005/Atom"
xml:lang="<?php echo get_option('rss_language'); ?>"
xmlns:thr="http://purl.org/syndication/thread/1.0"
<?php do_action('atom_ns'); ?>
>
<title type="text"><?php
if ( is_singular() )
printf(ent2ncr(__('Comments on: %s')), get_the_title_rss());
elseif ( is_search() )
printf(ent2ncr(__('Comments for %1$s searching on %2$s')), get_bloginfo_rss( 'name' ), attribute_escape(get_search_query()));
else
printf(ent2ncr(__('Comments for %s')), get_bloginfo_rss( 'name' ) . get_wp_title_rss());
?>
<?php
if ( !is_singular() ) {
$title = get_the_title($comment_post->ID);
$title = apply_filters('the_title_rss', $title);
printf(ent2ncr(__('Comment on %1$s by %2$s')), $title, get_comment_author_rss());
} else {
printf(ent2ncr(__('By: %s')), get_comment_author_rss());
}
?>
]]>
]]>
comment_parent == 0 ) : // This comment is top level ?>
waterwise-wp/wp-includes/cache.php 0000644 0001033 0000041 00000027450 11110355630 017321 0 ustar robert www-data add($key, $data, $flag, $expire);
}
/**
* Closes the cache.
*
* This function has ceased to do anything since WordPress 2.5. The
* functionality was removed along with the rest of the persistant cache. This
* does not mean that plugins can't implement this function when they need to
* make sure that the cache is cleaned up after WordPress no longer needs it.
*
* @since 2.0.0
*
* @return bool Always returns True
*/
function wp_cache_close() {
return true;
}
/**
* Removes the cache contents matching ID and flag.
*
* @since 2.0.0
* @uses $wp_object_cache Object Cache Class
* @see WP_Object_Cache::delete()
*
* @param int|string $id What the contents in the cache are called
* @param string $flag Where the cache contents are grouped
* @return bool True on successful removal, false on failure
*/
function wp_cache_delete($id, $flag = '') {
global $wp_object_cache;
return $wp_object_cache->delete($id, $flag);
}
/**
* Removes all cache items.
*
* @since 2.0.0
* @uses $wp_object_cache Object Cache Class
* @see WP_Object_Cache::flush()
*
* @return bool Always returns true
*/
function wp_cache_flush() {
global $wp_object_cache;
return $wp_object_cache->flush();
}
/**
* Retrieves the cache contents from the cache by ID and flag.
*
* @since 2.0.0
* @uses $wp_object_cache Object Cache Class
* @see WP_Object_Cache::get()
*
* @param int|string $id What the contents in the cache are called
* @param string $flag Where the cache contents are grouped
* @return bool|mixed False on failure to retrieve contents or the cache
* contents on success
*/
function wp_cache_get($id, $flag = '') {
global $wp_object_cache;
return $wp_object_cache->get($id, $flag);
}
/**
* Sets up Object Cache Global and assigns it.
*
* @since 2.0.0
* @global WP_Object_Cache $wp_object_cache WordPress Object Cache
*/
function wp_cache_init() {
$GLOBALS['wp_object_cache'] =& new WP_Object_Cache();
}
/**
* Replaces the contents of the cache with new data.
*
* @since 2.0.0
* @uses $wp_object_cache Object Cache Class
* @see WP_Object_Cache::replace()
*
* @param int|string $id What to call the contents in the cache
* @param mixed $data The contents to store in the cache
* @param string $flag Where to group the cache contents
* @param int $expire When to expire the cache contents
* @return bool False if cache ID and group already exists, true on success
*/
function wp_cache_replace($key, $data, $flag = '', $expire = 0) {
global $wp_object_cache;
return $wp_object_cache->replace($key, $data, $flag, $expire);
}
/**
* Saves the data to the cache.
*
* @since 2.0
* @uses $wp_object_cache Object Cache Class
* @see WP_Object_Cache::set()
*
* @param int|string $id What to call the contents in the cache
* @param mixed $data The contents to store in the cache
* @param string $flag Where to group the cache contents
* @param int $expire When to expire the cache contents
* @return bool False if cache ID and group already exists, true on success
*/
function wp_cache_set($key, $data, $flag = '', $expire = 0) {
global $wp_object_cache;
return $wp_object_cache->set($key, $data, $flag, $expire);
}
/**
* Adds a group or set of groups to the list of global groups.
*
* @since 2.6.0
*
* @param string|array $groups A group or an array of groups to add
*/
function wp_cache_add_global_groups( $groups ) {
// Default cache doesn't persist so nothing to do here.
return;
}
/**
* Adds a group or set of groups to the list of non-persistent groups.
*
* @since 2.6.0
*
* @param string|array $groups A group or an array of groups to add
*/
function wp_cache_add_non_persistent_groups( $groups ) {
// Default cache doesn't persist so nothing to do here.
return;
}
/**
* WordPress Object Cache
*
* The WordPress Object Cache is used to save on trips to the database. The
* Object Cache stores all of the cache data to memory and makes the cache
* contents available by using a key, which is used to name and later retrieve
* the cache contents.
*
* The Object Cache can be replaced by other caching mechanisms by placing files
* in the wp-content folder which is looked at in wp-settings. If that file
* exists, then this file will not be included.
*
* @package WordPress
* @subpackage Cache
* @since 2.0
*/
class WP_Object_Cache {
/**
* Holds the cached objects
*
* @var array
* @access private
* @since 2.0.0
*/
var $cache = array ();
/**
* Cache objects that do not exist in the cache
*
* @var array
* @access private
* @since 2.0.0
*/
var $non_existant_objects = array ();
/**
* The amount of times the cache data was already stored in the cache.
*
* @since 2.5.0
* @access private
* @var int
*/
var $cache_hits = 0;
/**
* Amount of times the cache did not have the request in cache
*
* @var int
* @access public
* @since 2.0.0
*/
var $cache_misses = 0;
/**
* Adds data to the cache if it doesn't already exist.
*
* @uses WP_Object_Cache::get Checks to see if the cache already has data.
* @uses WP_Object_Cache::set Sets the data after the checking the cache
* contents existance.
*
* @since 2.0.0
*
* @param int|string $id What to call the contents in the cache
* @param mixed $data The contents to store in the cache
* @param string $group Where to group the cache contents
* @param int $expire When to expire the cache contents
* @return bool False if cache ID and group already exists, true on success
*/
function add($id, $data, $group = 'default', $expire = '') {
if (empty ($group))
$group = 'default';
if (false !== $this->get($id, $group, false))
return false;
return $this->set($id, $data, $group, $expire);
}
/**
* Remove the contents of the cache ID in the group
*
* If the cache ID does not exist in the group and $force parameter is set
* to false, then nothing will happen. The $force parameter is set to false
* by default.
*
* On success the group and the id will be added to the
* $non_existant_objects property in the class.
*
* @since 2.0.0
*
* @param int|string $id What the contents in the cache are called
* @param string $group Where the cache contents are grouped
* @param bool $force Optional. Whether to force the unsetting of the cache
* ID in the group
* @return bool False if the contents weren't deleted and true on success
*/
function delete($id, $group = 'default', $force = false) {
if (empty ($group))
$group = 'default';
if (!$force && false === $this->get($id, $group, false))
return false;
unset ($this->cache[$group][$id]);
$this->non_existant_objects[$group][$id] = true;
return true;
}
/**
* Clears the object cache of all data
*
* @since 2.0.0
*
* @return bool Always returns true
*/
function flush() {
$this->cache = array ();
return true;
}
/**
* Retrieves the cache contents, if it exists
*
* The contents will be first attempted to be retrieved by searching by the
* ID in the cache group. If the cache is hit (success) then the contents
* are returned.
*
* On failure, the $non_existant_objects property is checked and if the
* cache group and ID exist in there the cache misses will not be
* incremented. If not in the nonexistant objects property, then the cache
* misses will be incremented and the cache group and ID will be added to
* the nonexistant objects.
*
* @since 2.0.0
*
* @param int|string $id What the contents in the cache are called
* @param string $group Where the cache contents are grouped
* @return bool|mixed False on failure to retrieve contents or the cache
* contents on success
*/
function get($id, $group = 'default') {
if (empty ($group))
$group = 'default';
if (isset ($this->cache[$group][$id])) {
$this->cache_hits += 1;
if ( is_object($this->cache[$group][$id]) )
return wp_clone($this->cache[$group][$id]);
else
return $this->cache[$group][$id];
}
if ( isset ($this->non_existant_objects[$group][$id]) )
return false;
$this->non_existant_objects[$group][$id] = true;
$this->cache_misses += 1;
return false;
}
/**
* Replace the contents in the cache, if contents already exist
*
* @since 2.0.0
* @see WP_Object_Cache::set()
*
* @param int|string $id What to call the contents in the cache
* @param mixed $data The contents to store in the cache
* @param string $group Where to group the cache contents
* @param int $expire When to expire the cache contents
* @return bool False if not exists, true if contents were replaced
*/
function replace($id, $data, $group = 'default', $expire = '') {
if (empty ($group))
$group = 'default';
if (false === $this->get($id, $group, false))
return false;
return $this->set($id, $data, $group, $expire);
}
/**
* Sets the data contents into the cache
*
* The cache contents is grouped by the $group parameter followed by the
* $id. This allows for duplicate ids in unique groups. Therefore, naming of
* the group should be used with care and should follow normal function
* naming guidelines outside of core WordPress usage.
*
* The $expire parameter is not used, because the cache will automatically
* expire for each time a page is accessed and PHP finishes. The method is
* more for cache plugins which use files.
*
* @since 2.0.0
*
* @param int|string $id What to call the contents in the cache
* @param mixed $data The contents to store in the cache
* @param string $group Where to group the cache contents
* @param int $expire Not Used
* @return bool Always returns true
*/
function set($id, $data, $group = 'default', $expire = '') {
if (empty ($group))
$group = 'default';
if (NULL === $data)
$data = '';
if ( is_object($data) )
$data = wp_clone($data);
$this->cache[$group][$id] = $data;
if(isset($this->non_existant_objects[$group][$id]))
unset ($this->non_existant_objects[$group][$id]);
return true;
}
/**
* Echos the stats of the caching.
*
* Gives the cache hits, and cache misses. Also prints every cached group,
* key and the data.
*
* @since 2.0.0
*/
function stats() {
echo "";
echo "Cache Hits: {$this->cache_hits}Cache Misses: {$this->cache_misses}
";
foreach ($this->cache as $group => $cache) {
echo "";
echo "Group: $groupCache: ";
echo "
";
print_r($cache);
echo " ";
}
}
/**
* PHP4 constructor; Calls PHP 5 style constructor
*
* @since 2.0.0
*
* @return WP_Object_Cache
*/
function WP_Object_Cache() {
return $this->__construct();
}
/**
* Sets up object properties; PHP 5 style constructor
*
* @since 2.0.8
* @return null|WP_Object_Cache If cache is disabled, returns null.
*/
function __construct() {
/**
* @todo This should be moved to the PHP4 style constructor, PHP5
* already calls __destruct()
*/
register_shutdown_function(array(&$this, "__destruct"));
}
/**
* Will save the object cache before object is completely destroyed.
*
* Called upon object destruction, which should be when PHP ends.
*
* @since 2.0.8
*
* @return bool True value. Won't be used by PHP
*/
function __destruct() {
return true;
}
}
?>
waterwise-wp/wp-includes/kses.php 0000644 0001033 0000041 00000076745 11135667304 017251 0 ustar robert www-data
*
* @package External
* @subpackage KSES
*
* @internal
* *** CONTACT INFORMATION ***
* E-mail: metaur at users dot sourceforge dot net
* Web page: http://sourceforge.net/projects/kses
* Paper mail: Ulf Harnhammar
* Ymergatan 17 C
* 753 25 Uppsala
* SWEDEN
*
* [kses strips evil scripts!]
*/
/**
* You can override this in your my-hacks.php file You can also override this
* in a plugin file. The my-hacks.php is deprecated in its usage.
*
* @since 1.2.0
*/
if (!defined('CUSTOM_TAGS'))
define('CUSTOM_TAGS', false);
if (!CUSTOM_TAGS) {
/**
* Kses global for default allowable HTML tags.
*
* Can be override by using CUSTOM_TAGS constant.
*
* @global array $allowedposttags
* @since 2.0.0
*/
$allowedposttags = array(
'address' => array(),
'a' => array(
'class' => array (),
'href' => array (),
'id' => array (),
'title' => array (),
'rel' => array (),
'rev' => array (),
'name' => array (),
'target' => array()),
'abbr' => array(
'class' => array (),
'title' => array ()),
'acronym' => array(
'title' => array ()),
'b' => array(),
'big' => array(),
'blockquote' => array(
'id' => array (),
'cite' => array (),
'class' => array(),
'lang' => array(),
'xml:lang' => array()),
'br' => array (
'class' => array ()),
'button' => array(
'disabled' => array (),
'name' => array (),
'type' => array (),
'value' => array ()),
'caption' => array(
'align' => array (),
'class' => array ()),
'cite' => array (
'class' => array(),
'dir' => array(),
'lang' => array(),
'title' => array ()),
'code' => array (
'style' => array()),
'col' => array(
'align' => array (),
'char' => array (),
'charoff' => array (),
'span' => array (),
'dir' => array(),
'style' => array (),
'valign' => array (),
'width' => array ()),
'del' => array(
'datetime' => array ()),
'dd' => array(),
'div' => array(
'align' => array (),
'class' => array (),
'dir' => array (),
'lang' => array(),
'style' => array (),
'xml:lang' => array()),
'dl' => array(),
'dt' => array(),
'em' => array(),
'fieldset' => array(),
'font' => array(
'color' => array (),
'face' => array (),
'size' => array ()),
'form' => array(
'action' => array (),
'accept' => array (),
'accept-charset' => array (),
'enctype' => array (),
'method' => array (),
'name' => array (),
'target' => array ()),
'h1' => array(
'align' => array (),
'class' => array ()),
'h2' => array(
'align' => array (),
'class' => array ()),
'h3' => array(
'align' => array (),
'class' => array ()),
'h4' => array(
'align' => array (),
'class' => array ()),
'h5' => array(
'align' => array (),
'class' => array ()),
'h6' => array(
'align' => array (),
'class' => array ()),
'hr' => array(
'align' => array (),
'class' => array (),
'noshade' => array (),
'size' => array (),
'width' => array ()),
'i' => array(),
'img' => array(
'alt' => array (),
'align' => array (),
'border' => array (),
'class' => array (),
'height' => array (),
'hspace' => array (),
'longdesc' => array (),
'vspace' => array (),
'src' => array (),
'style' => array (),
'width' => array ()),
'ins' => array(
'datetime' => array (),
'cite' => array ()),
'kbd' => array(),
'label' => array(
'for' => array ()),
'legend' => array(
'align' => array ()),
'li' => array (
'align' => array (),
'class' => array ()),
'p' => array(
'class' => array (),
'align' => array (),
'dir' => array(),
'lang' => array(),
'style' => array (),
'xml:lang' => array()),
'pre' => array(
'style' => array(),
'width' => array ()),
'q' => array(
'cite' => array ()),
's' => array(),
'span' => array (
'class' => array (),
'dir' => array (),
'align' => array (),
'lang' => array (),
'style' => array (),
'title' => array (),
'xml:lang' => array()),
'strike' => array(),
'strong' => array(),
'sub' => array(),
'sup' => array(),
'table' => array(
'align' => array (),
'bgcolor' => array (),
'border' => array (),
'cellpadding' => array (),
'cellspacing' => array (),
'class' => array (),
'dir' => array(),
'id' => array(),
'rules' => array (),
'style' => array (),
'summary' => array (),
'width' => array ()),
'tbody' => array(
'align' => array (),
'char' => array (),
'charoff' => array (),
'valign' => array ()),
'td' => array(
'abbr' => array (),
'align' => array (),
'axis' => array (),
'bgcolor' => array (),
'char' => array (),
'charoff' => array (),
'class' => array (),
'colspan' => array (),
'dir' => array(),
'headers' => array (),
'height' => array (),
'nowrap' => array (),
'rowspan' => array (),
'scope' => array (),
'style' => array (),
'valign' => array (),
'width' => array ()),
'textarea' => array(
'cols' => array (),
'rows' => array (),
'disabled' => array (),
'name' => array (),
'readonly' => array ()),
'tfoot' => array(
'align' => array (),
'char' => array (),
'class' => array (),
'charoff' => array (),
'valign' => array ()),
'th' => array(
'abbr' => array (),
'align' => array (),
'axis' => array (),
'bgcolor' => array (),
'char' => array (),
'charoff' => array (),
'class' => array (),
'colspan' => array (),
'headers' => array (),
'height' => array (),
'nowrap' => array (),
'rowspan' => array (),
'scope' => array (),
'valign' => array (),
'width' => array ()),
'thead' => array(
'align' => array (),
'char' => array (),
'charoff' => array (),
'class' => array (),
'valign' => array ()),
'title' => array(),
'tr' => array(
'align' => array (),
'bgcolor' => array (),
'char' => array (),
'charoff' => array (),
'class' => array (),
'style' => array (),
'valign' => array ()),
'tt' => array(),
'u' => array(),
'ul' => array (
'class' => array (),
'style' => array (),
'type' => array ()),
'ol' => array (
'class' => array (),
'start' => array (),
'style' => array (),
'type' => array ()),
'var' => array ());
/**
* Kses allowed HTML elements.
*
* @global array $allowedtags
* @since 1.0.0
*/
$allowedtags = array(
'a' => array(
'href' => array (),
'title' => array ()),
'abbr' => array(
'title' => array ()),
'acronym' => array(
'title' => array ()),
'b' => array(),
'blockquote' => array(
'cite' => array ()),
// 'br' => array(),
'cite' => array (),
'code' => array(),
'del' => array(
'datetime' => array ()),
// 'dd' => array(),
// 'dl' => array(),
// 'dt' => array(),
'em' => array (), 'i' => array (),
// 'ins' => array('datetime' => array(), 'cite' => array()),
// 'li' => array(),
// 'ol' => array(),
// 'p' => array(),
'q' => array(
'cite' => array ()),
'strike' => array(),
'strong' => array(),
// 'sub' => array(),
// 'sup' => array(),
// 'u' => array(),
// 'ul' => array(),
);
}
/**
* Filters content and keeps only allowable HTML elements.
*
* This function makes sure that only the allowed HTML element names, attribute
* names and attribute values plus only sane HTML entities will occur in
* $string. You have to remove any slashes from PHP's magic quotes before you
* call this function.
*
* The default allowed protocols are 'http', 'https', 'ftp', 'mailto', 'news',
* 'irc', 'gopher', 'nntp', 'feed', and finally 'telnet. This covers all common
* link protocols, except for 'javascript' which should not be allowed for
* untrusted users.
*
* @since 1.0.0
*
* @param string $string Content to filter through kses
* @param array $allowed_html List of allowed HTML elements
* @param array $allowed_protocols Optional. Allowed protocol in links.
* @return string Filtered content with only allowed HTML elements
*/
function wp_kses($string, $allowed_html, $allowed_protocols = array ('http', 'https', 'ftp', 'ftps', 'mailto', 'news', 'irc', 'gopher', 'nntp', 'feed', 'telnet')) {
$string = wp_kses_no_null($string);
$string = wp_kses_js_entities($string);
$string = wp_kses_normalize_entities($string);
$allowed_html_fixed = wp_kses_array_lc($allowed_html);
$string = wp_kses_hook($string, $allowed_html_fixed, $allowed_protocols); // WP changed the order of these funcs and added args to wp_kses_hook
return wp_kses_split($string, $allowed_html_fixed, $allowed_protocols);
}
/**
* You add any kses hooks here.
*
* There is currently only one kses WordPress hook and it is called here. All
* parameters are passed to the hooks and expected to recieve a string.
*
* @since 1.0.0
*
* @param string $string Content to filter through kses
* @param array $allowed_html List of allowed HTML elements
* @param array $allowed_protocols Allowed protocol in links
* @return string Filtered content through 'pre_kses' hook
*/
function wp_kses_hook($string, $allowed_html, $allowed_protocols) {
$string = apply_filters('pre_kses', $string, $allowed_html, $allowed_protocols);
return $string;
}
/**
* This function returns kses' version number.
*
* @since 1.0.0
*
* @return string KSES Version Number
*/
function wp_kses_version() {
return '0.2.2';
}
/**
* Searches for HTML tags, no matter how malformed.
*
* It also matches stray ">" characters.
*
* @since 1.0.0
*
* @param string $string Content to filter
* @param array $allowed_html Allowed HTML elements
* @param array $allowed_protocols Allowed protocols to keep
* @return string Content with fixed HTML tags
*/
function wp_kses_split($string, $allowed_html, $allowed_protocols) {
global $pass_allowed_html, $pass_allowed_protocols;
$pass_allowed_html = $allowed_html;
$pass_allowed_protocols = $allowed_protocols;
return preg_replace_callback('%((|$))|(<[^>]*(>|$)|>))%',
create_function('$match', 'global $pass_allowed_html, $pass_allowed_protocols; return wp_kses_split2($match[1], $pass_allowed_html, $pass_allowed_protocols);'), $string);
}
/**
* Callback for wp_kses_split for fixing malformed HTML tags.
*
* This function does a lot of work. It rejects some very malformed things like
* <:::>. It returns an empty string, if the element isn't allowed (look ma, no
* strip_tags()!). Otherwise it splits the tag into an element and an attribute
* list.
*
* After the tag is split into an element and an attribute list, it is run
* through another filter which will remove illegal attributes and once that is
* completed, will be returned.
*
* @access private
* @since 1.0.0
* @uses wp_kses_attr()
*
* @param string $string Content to filter
* @param array $allowed_html Allowed HTML elements
* @param array $allowed_protocols Allowed protocols to keep
* @return string Fixed HTML element
*/
function wp_kses_split2($string, $allowed_html, $allowed_protocols) {
$string = wp_kses_stripslashes($string);
if (substr($string, 0, 1) != '<')
return '>';
# It matched a ">" character
if (preg_match('%^)?$%', $string, $matches)) {
$string = str_replace(array(''), '', $matches[1]);
while ( $string != $newstring = wp_kses($string, $allowed_html, $allowed_protocols) )
$string = $newstring;
if ( $string == '' )
return '';
// prevent multiple dashes in comments
$string = preg_replace('/--+/', '-', $string);
// prevent three dashes closing a comment
$string = preg_replace('/-$/', '', $string);
return "";
}
# Allow HTML comments
if (!preg_match('%^<\s*(/\s*)?([a-zA-Z0-9]+)([^>]*)>?$%', $string, $matches))
return '';
# It's seriously malformed
$slash = trim($matches[1]);
$elem = $matches[2];
$attrlist = $matches[3];
if (!@isset($allowed_html[strtolower($elem)]))
return '';
# They are using a not allowed HTML element
if ($slash != '')
return "<$slash$elem>";
# No attributes are allowed for closing elements
return wp_kses_attr("$slash$elem", $attrlist, $allowed_html, $allowed_protocols);
}
/**
* Removes all attributes, if none are allowed for this element.
*
* If some are allowed it calls wp_kses_hair() to split them further, and then
* it builds up new HTML code from the data that kses_hair() returns. It also
* removes "<" and ">" characters, if there are any left. One more thing it does
* is to check if the tag has a closing XHTML slash, and if it does, it puts one
* in the returned code as well.
*
* @since 1.0.0
*
* @param string $element HTML element/tag
* @param string $attr HTML attributes from HTML element to closing HTML element tag
* @param array $allowed_html Allowed HTML elements
* @param array $allowed_protocols Allowed protocols to keep
* @return string Sanitized HTML element
*/
function wp_kses_attr($element, $attr, $allowed_html, $allowed_protocols) {
# Is there a closing XHTML slash at the end of the attributes?
$xhtml_slash = '';
if (preg_match('%\s/\s*$%', $attr))
$xhtml_slash = ' /';
# Are any attributes allowed at all for this element?
if (@ count($allowed_html[strtolower($element)]) == 0)
return "<$element$xhtml_slash>";
# Split it
$attrarr = wp_kses_hair($attr, $allowed_protocols);
# Go through $attrarr, and save the allowed attributes for this element
# in $attr2
$attr2 = '';
foreach ($attrarr as $arreach) {
if (!@ isset ($allowed_html[strtolower($element)][strtolower($arreach['name'])]))
continue; # the attribute is not allowed
$current = $allowed_html[strtolower($element)][strtolower($arreach['name'])];
if ($current == '')
continue; # the attribute is not allowed
if (!is_array($current))
$attr2 .= ' '.$arreach['whole'];
# there are no checks
else {
# there are some checks
$ok = true;
foreach ($current as $currkey => $currval)
if (!wp_kses_check_attr_val($arreach['value'], $arreach['vless'], $currkey, $currval)) {
$ok = false;
break;
}
if ($ok)
$attr2 .= ' '.$arreach['whole']; # it passed them
} # if !is_array($current)
} # foreach
# Remove any "<" or ">" characters
$attr2 = preg_replace('/[<>]/', '', $attr2);
return "<$element$attr2$xhtml_slash>";
}
/**
* Builds an attribute list from string containing attributes.
*
* This function does a lot of work. It parses an attribute list into an array
* with attribute data, and tries to do the right thing even if it gets weird
* input. It will add quotes around attribute values that don't have any quotes
* or apostrophes around them, to make it easier to produce HTML code that will
* conform to W3C's HTML specification. It will also remove bad URL protocols
* from attribute values. It also reduces duplicate attributes by using the
* attribute defined first (foo='bar' foo='baz' will result in foo='bar').
*
* @since 1.0.0
*
* @param string $attr Attribute list from HTML element to closing HTML element tag
* @param array $allowed_protocols Allowed protocols to keep
* @return array List of attributes after parsing
*/
function wp_kses_hair($attr, $allowed_protocols) {
$attrarr = array ();
$mode = 0;
$attrname = '';
$uris = array('xmlns', 'profile', 'href', 'src', 'cite', 'classid', 'codebase', 'data', 'usemap', 'longdesc', 'action');
# Loop through the whole attribute list
while (strlen($attr) != 0) {
$working = 0; # Was the last operation successful?
switch ($mode) {
case 0 : # attribute name, href for instance
if (preg_match('/^([-a-zA-Z]+)/', $attr, $match)) {
$attrname = $match[1];
$working = $mode = 1;
$attr = preg_replace('/^[-a-zA-Z]+/', '', $attr);
}
break;
case 1 : # equals sign or valueless ("selected")
if (preg_match('/^\s*=\s*/', $attr)) # equals sign
{
$working = 1;
$mode = 2;
$attr = preg_replace('/^\s*=\s*/', '', $attr);
break;
}
if (preg_match('/^\s+/', $attr)) # valueless
{
$working = 1;
$mode = 0;
if(FALSE === array_key_exists($attrname, $attrarr)) {
$attrarr[$attrname] = array ('name' => $attrname, 'value' => '', 'whole' => $attrname, 'vless' => 'y');
}
$attr = preg_replace('/^\s+/', '', $attr);
}
break;
case 2 : # attribute value, a URL after href= for instance
if (preg_match('/^"([^"]*)"(\s+|$)/', $attr, $match))
# "value"
{
$thisval = $match[1];
if ( in_array($attrname, $uris) )
$thisval = wp_kses_bad_protocol($thisval, $allowed_protocols);
if(FALSE === array_key_exists($attrname, $attrarr)) {
$attrarr[$attrname] = array ('name' => $attrname, 'value' => $thisval, 'whole' => "$attrname=\"$thisval\"", 'vless' => 'n');
}
$working = 1;
$mode = 0;
$attr = preg_replace('/^"[^"]*"(\s+|$)/', '', $attr);
break;
}
if (preg_match("/^'([^']*)'(\s+|$)/", $attr, $match))
# 'value'
{
$thisval = $match[1];
if ( in_array($attrname, $uris) )
$thisval = wp_kses_bad_protocol($thisval, $allowed_protocols);
if(FALSE === array_key_exists($attrname, $attrarr)) {
$attrarr[$attrname] = array ('name' => $attrname, 'value' => $thisval, 'whole' => "$attrname='$thisval'", 'vless' => 'n');
}
$working = 1;
$mode = 0;
$attr = preg_replace("/^'[^']*'(\s+|$)/", '', $attr);
break;
}
if (preg_match("%^([^\s\"']+)(\s+|$)%", $attr, $match))
# value
{
$thisval = $match[1];
if ( in_array($attrname, $uris) )
$thisval = wp_kses_bad_protocol($thisval, $allowed_protocols);
if(FALSE === array_key_exists($attrname, $attrarr)) {
$attrarr[$attrname] = array ('name' => $attrname, 'value' => $thisval, 'whole' => "$attrname=\"$thisval\"", 'vless' => 'n');
}
# We add quotes to conform to W3C's HTML spec.
$working = 1;
$mode = 0;
$attr = preg_replace("%^[^\s\"']+(\s+|$)%", '', $attr);
}
break;
} # switch
if ($working == 0) # not well formed, remove and try again
{
$attr = wp_kses_html_error($attr);
$mode = 0;
}
} # while
if ($mode == 1 && FALSE === array_key_exists($attrname, $attrarr))
# special case, for when the attribute list ends with a valueless
# attribute like "selected"
$attrarr[$attrname] = array ('name' => $attrname, 'value' => '', 'whole' => $attrname, 'vless' => 'y');
return $attrarr;
}
/**
* Performs different checks for attribute values.
*
* The currently implemented checks are "maxlen", "minlen", "maxval", "minval"
* and "valueless" with even more checks to come soon.
*
* @since 1.0.0
*
* @param string $value Attribute value
* @param string $vless Whether the value is valueless or not. Use 'y' or 'n'
* @param string $checkname What $checkvalue is checking for.
* @param mixed $checkvalue What constraint the value should pass
* @return bool Whether check passes (true) or not (false)
*/
function wp_kses_check_attr_val($value, $vless, $checkname, $checkvalue) {
$ok = true;
switch (strtolower($checkname)) {
case 'maxlen' :
# The maxlen check makes sure that the attribute value has a length not
# greater than the given value. This can be used to avoid Buffer Overflows
# in WWW clients and various Internet servers.
if (strlen($value) > $checkvalue)
$ok = false;
break;
case 'minlen' :
# The minlen check makes sure that the attribute value has a length not
# smaller than the given value.
if (strlen($value) < $checkvalue)
$ok = false;
break;
case 'maxval' :
# The maxval check does two things: it checks that the attribute value is
# an integer from 0 and up, without an excessive amount of zeroes or
# whitespace (to avoid Buffer Overflows). It also checks that the attribute
# value is not greater than the given value.
# This check can be used to avoid Denial of Service attacks.
if (!preg_match('/^\s{0,6}[0-9]{1,6}\s{0,6}$/', $value))
$ok = false;
if ($value > $checkvalue)
$ok = false;
break;
case 'minval' :
# The minval check checks that the attribute value is a positive integer,
# and that it is not smaller than the given value.
if (!preg_match('/^\s{0,6}[0-9]{1,6}\s{0,6}$/', $value))
$ok = false;
if ($value < $checkvalue)
$ok = false;
break;
case 'valueless' :
# The valueless check checks if the attribute has a value
# (like ) or not (). If the given value
# is a "y" or a "Y", the attribute must not have a value.
# If the given value is an "n" or an "N", the attribute must have one.
if (strtolower($checkvalue) != $vless)
$ok = false;
break;
} # switch
return $ok;
}
/**
* Sanitize string from bad protocols.
*
* This function removes all non-allowed protocols from the beginning of
* $string. It ignores whitespace and the case of the letters, and it does
* understand HTML entities. It does its work in a while loop, so it won't be
* fooled by a string like "javascript:javascript:alert(57)".
*
* @since 1.0.0
*
* @param string $string Content to filter bad protocols from
* @param array $allowed_protocols Allowed protocols to keep
* @return string Filtered content
*/
function wp_kses_bad_protocol($string, $allowed_protocols) {
$string = wp_kses_no_null($string);
$string = preg_replace('/\xad+/', '', $string); # deals with Opera "feature"
$string2 = $string.'a';
while ($string != $string2) {
$string2 = $string;
$string = wp_kses_bad_protocol_once($string, $allowed_protocols);
} # while
return $string;
}
/**
* Removes any NULL characters in $string.
*
* @since 1.0.0
*
* @param string $string
* @return string
*/
function wp_kses_no_null($string) {
$string = preg_replace('/\0+/', '', $string);
$string = preg_replace('/(\\\\0)+/', '', $string);
return $string;
}
/**
* Strips slashes from in front of quotes.
*
* This function changes the character sequence \" to just ". It leaves all
* other slashes alone. It's really weird, but the quoting from
* preg_replace(//e) seems to require this.
*
* @since 1.0.0
*
* @param string $string String to strip slashes
* @return string Fixed strings with quoted slashes
*/
function wp_kses_stripslashes($string) {
return preg_replace('%\\\\"%', '"', $string);
}
/**
* Goes through an array and changes the keys to all lower case.
*
* @since 1.0.0
*
* @param array $inarray Unfiltered array
* @return array Fixed array with all lowercase keys
*/
function wp_kses_array_lc($inarray) {
$outarray = array ();
foreach ( (array) $inarray as $inkey => $inval) {
$outkey = strtolower($inkey);
$outarray[$outkey] = array ();
foreach ( (array) $inval as $inkey2 => $inval2) {
$outkey2 = strtolower($inkey2);
$outarray[$outkey][$outkey2] = $inval2;
} # foreach $inval
} # foreach $inarray
return $outarray;
}
/**
* Removes the HTML JavaScript entities found in early versions of Netscape 4.
*
* @since 1.0.0
*
* @param string $string
* @return string
*/
function wp_kses_js_entities($string) {
return preg_replace('%&\s*\{[^}]*(\}\s*;?|$)%', '', $string);
}
/**
* Handles parsing errors in wp_kses_hair().
*
* The general plan is to remove everything to and including some whitespace,
* but it deals with quotes and apostrophes as well.
*
* @since 1.0.0
*
* @param string $string
* @return string
*/
function wp_kses_html_error($string) {
return preg_replace('/^("[^"]*("|$)|\'[^\']*(\'|$)|\S)*\s*/', '', $string);
}
/**
* Sanitizes content from bad protocols and other characters.
*
* This function searches for URL protocols at the beginning of $string, while
* handling whitespace and HTML entities.
*
* @since 1.0.0
*
* @param string $string Content to check for bad protocols
* @param string $allowed_protocols Allowed protocols
* @return string Sanitized content
*/
function wp_kses_bad_protocol_once($string, $allowed_protocols) {
global $_kses_allowed_protocols;
$_kses_allowed_protocols = $allowed_protocols;
$string2 = preg_split('/:|:|:/i', $string, 2);
if ( isset($string2[1]) && !preg_match('%/\?%', $string2[0]) )
$string = wp_kses_bad_protocol_once2($string2[0]) . trim($string2[1]);
else
$string = preg_replace_callback('/^((&[^;]*;|[\sA-Za-z0-9])*)'.'(:|:|&#[Xx]3[Aa];)\s*/', 'wp_kses_bad_protocol_once2', $string);
return $string;
}
/**
* Callback for wp_kses_bad_protocol_once() regular expression.
*
* This function processes URL protocols, checks to see if they're in the
* white-list or not, and returns different data depending on the answer.
*
* @access private
* @since 1.0.0
*
* @param mixed $matches string or preg_replace_callback() matches array to check for bad protocols
* @return string Sanitized content
*/
function wp_kses_bad_protocol_once2($matches) {
global $_kses_allowed_protocols;
if ( is_array($matches) ) {
if ( ! isset($matches[1]) || empty($matches[1]) )
return '';
$string = $matches[1];
} else {
$string = $matches;
}
$string2 = wp_kses_decode_entities($string);
$string2 = preg_replace('/\s/', '', $string2);
$string2 = wp_kses_no_null($string2);
$string2 = preg_replace('/\xad+/', '', $string2);
# deals with Opera "feature"
$string2 = strtolower($string2);
$allowed = false;
foreach ( (array) $_kses_allowed_protocols as $one_protocol)
if (strtolower($one_protocol) == $string2) {
$allowed = true;
break;
}
if ($allowed)
return "$string2:";
else
return '';
}
/**
* Converts and fixes HTML entities.
*
* This function normalizes HTML entities. It will convert "AT&T" to the correct
* "AT&T", ":" to ":", "&#XYZZY;" to "&#XYZZY;" and so on.
*
* @since 1.0.0
*
* @param string $string Content to normalize entities
* @return string Content with normalized entities
*/
function wp_kses_normalize_entities($string) {
# Disarm all entities by converting & to &
$string = str_replace('&', '&', $string);
# Change back the allowed entities in our entity whitelist
$string = preg_replace('/&([A-Za-z][A-Za-z0-9]{0,19});/', '&\\1;', $string);
$string = preg_replace_callback('/�*([0-9]{1,5});/', 'wp_kses_normalize_entities2', $string);
$string = preg_replace_callback('/&#([Xx])0*(([0-9A-Fa-f]{2}){1,2});/', 'wp_kses_normalize_entities3', $string);
return $string;
}
/**
* Callback for wp_kses_normalize_entities() regular expression.
*
* This function helps wp_kses_normalize_entities() to only accept 16 bit values
* and nothing more for &#number; entities.
*
* @access private
* @since 1.0.0
*
* @param array $matches preg_replace_callback() matches array
* @return string Correctly encoded entity
*/
function wp_kses_normalize_entities2($matches) {
if ( ! isset($matches[1]) || empty($matches[1]) )
return '';
$i = $matches[1];
return ( ( ! valid_unicode($i) ) || ($i > 65535) ? "&#$i;" : "&#$i;" );
}
/**
* Callback for wp_kses_normalize_entities() for regular expression.
*
* This function helps wp_kses_normalize_entities() to only accept valid Unicode
* numeric entities in hex form.
*
* @access private
*
* @param array $matches preg_replace_callback() matches array
* @return string Correctly encoded entity
*/
function wp_kses_normalize_entities3($matches) {
if ( ! isset($matches[2]) || empty($matches[2]) )
return '';
$hexchars = $matches[2];
return ( ( ! valid_unicode(hexdec($hexchars)) ) ? "&#x$hexchars;" : "&#x$hexchars;" );
}
/**
* Helper function to determine if a Unicode value is valid.
*
* @param int $i Unicode value
* @return bool true if the value was a valid Unicode number
*/
function valid_unicode($i) {
return ( $i == 0x9 || $i == 0xa || $i == 0xd ||
($i >= 0x20 && $i <= 0xd7ff) ||
($i >= 0xe000 && $i <= 0xfffd) ||
($i >= 0x10000 && $i <= 0x10ffff) );
}
/**
* Convert all entities to their character counterparts.
*
* This function decodes numeric HTML entities (A and A). It doesn't do
* anything with other entities like ä, but we don't need them in the URL
* protocol whitelisting system anyway.
*
* @since 1.0.0
*
* @param string $string Content to change entities
* @return string Content after decoded entities
*/
function wp_kses_decode_entities($string) {
$string = preg_replace_callback('/&#([0-9]+);/', create_function('$match', 'return chr($match[1]);'), $string);
$string = preg_replace_callback('/&#[Xx]([0-9A-Fa-f]+);/', create_function('$match', 'return chr(hexdec($match[1]));'), $string);
return $string;
}
/**
* Sanitize content with allowed HTML Kses rules.
*
* @since 1.0.0
* @uses $allowedtags
*
* @param string $data Content to filter
* @return string Filtered content
*/
function wp_filter_kses($data) {
global $allowedtags;
return addslashes( wp_kses(stripslashes( $data ), $allowedtags) );
}
/**
* Sanitize content for allowed HTML tags for post content.
*
* Post content refers to the page contents of the 'post' type and not $_POST
* data from forms.
*
* @since 2.0.0
* @uses $allowedposttags
*
* @param string $data Post content to filter
* @return string Filtered post content with allowed HTML tags and attributes intact.
*/
function wp_filter_post_kses($data) {
global $allowedposttags;
return addslashes ( wp_kses(stripslashes( $data ), $allowedposttags) );
}
/**
* Strips all of the HTML in the content.
*
* @since 2.1.0
*
* @param string $data Content to strip all HTML from
* @return string Filtered content without any HTML
*/
function wp_filter_nohtml_kses($data) {
return addslashes ( wp_kses(stripslashes( $data ), array()) );
}
/**
* Adds all Kses input form content filters.
*
* All hooks have default priority. The wp_filter_kses() function is added to
* the 'pre_comment_content' and 'title_save_pre' hooks.
*
* The wp_filter_post_kses() function is added to the 'content_save_pre',
* 'excerpt_save_pre', and 'content_filtered_save_pre' hooks.
*
* @since 2.0.0
* @uses add_filter() See description for what functions are added to what hooks.
*/
function kses_init_filters() {
// Normal filtering.
add_filter('pre_comment_content', 'wp_filter_kses');
add_filter('title_save_pre', 'wp_filter_kses');
// Post filtering
add_filter('content_save_pre', 'wp_filter_post_kses');
add_filter('excerpt_save_pre', 'wp_filter_post_kses');
add_filter('content_filtered_save_pre', 'wp_filter_post_kses');
}
/**
* Removes all Kses input form content filters.
*
* A quick procedural method to removing all of the filters that kses uses for
* content in WordPress Loop.
*
* Does not remove the kses_init() function from 'init' hook (priority is
* default). Also does not remove kses_init() function from 'set_current_user'
* hook (priority is also default).
*
* @since 2.0.6
*/
function kses_remove_filters() {
// Normal filtering.
remove_filter('pre_comment_content', 'wp_filter_kses');
remove_filter('title_save_pre', 'wp_filter_kses');
// Post filtering
remove_filter('content_save_pre', 'wp_filter_post_kses');
remove_filter('excerpt_save_pre', 'wp_filter_post_kses');
remove_filter('content_filtered_save_pre', 'wp_filter_post_kses');
}
/**
* Sets up most of the Kses filters for input form content.
*
* If you remove the kses_init() function from 'init' hook and
* 'set_current_user' (priority is default), then none of the Kses filter hooks
* will be added.
*
* First removes all of the Kses filters in case the current user does not need
* to have Kses filter the content. If the user does not have unfiltered html
* capability, then Kses filters are added.
*
* @uses kses_remove_filters() Removes the Kses filters
* @uses kses_init_filters() Adds the Kses filters back if the user
* does not have unfiltered HTML capability.
* @since 2.0.0
*/
function kses_init() {
kses_remove_filters();
if (current_user_can('unfiltered_html') == false)
kses_init_filters();
}
add_action('init', 'kses_init');
add_action('set_current_user', 'kses_init');
?>
waterwise-wp/wp-includes/comment.php 0000644 0001033 0000041 00000151013 11140145151 017707 0 ustar robert www-data ]*[Hh][Rr][Ee][Ff]=['\"]([^\"'>]+)[^>]*>/", apply_filters('comment_text',$comment), $out) >= get_option('comment_max_links') )
return false; // Check # of external links
$mod_keys = trim(get_option('moderation_keys'));
if ( !empty($mod_keys) ) {
$words = explode("\n", $mod_keys );
foreach ( (array) $words as $word) {
$word = trim($word);
// Skip empty lines
if ( empty($word) )
continue;
// Do some escaping magic so that '#' chars in the
// spam words don't break things:
$word = preg_quote($word, '#');
$pattern = "#$word#i";
if ( preg_match($pattern, $author) ) return false;
if ( preg_match($pattern, $email) ) return false;
if ( preg_match($pattern, $url) ) return false;
if ( preg_match($pattern, $comment) ) return false;
if ( preg_match($pattern, $user_ip) ) return false;
if ( preg_match($pattern, $user_agent) ) return false;
}
}
// Comment whitelisting:
if ( 1 == get_option('comment_whitelist')) {
if ( 'trackback' == $comment_type || 'pingback' == $comment_type ) { // check if domain is in blogroll
$uri = parse_url($url);
$domain = $uri['host'];
$uri = parse_url( get_option('home') );
$home_domain = $uri['host'];
if ( $wpdb->get_var($wpdb->prepare("SELECT link_id FROM $wpdb->links WHERE link_url LIKE (%s) LIMIT 1", '%'.$domain.'%')) || $domain == $home_domain )
return true;
else
return false;
} elseif ( $author != '' && $email != '' ) {
// expected_slashed ($author, $email)
$ok_to_comment = $wpdb->get_var("SELECT comment_approved FROM $wpdb->comments WHERE comment_author = '$author' AND comment_author_email = '$email' and comment_approved = '1' LIMIT 1");
if ( ( 1 == $ok_to_comment ) &&
( empty($mod_keys) || false === strpos( $email, $mod_keys) ) )
return true;
else
return false;
} else {
return false;
}
}
return true;
}
/**
* Retrieve the approved comments for post $post_id.
*
* @since 2.0.0
* @uses $wpdb
*
* @param int $post_id The ID of the post
* @return array $comments The approved comments
*/
function get_approved_comments($post_id) {
global $wpdb;
return $wpdb->get_results($wpdb->prepare("SELECT * FROM $wpdb->comments WHERE comment_post_ID = %d AND comment_approved = '1' ORDER BY comment_date", $post_id));
}
/**
* Retrieves comment data given a comment ID or comment object.
*
* If an object is passed then the comment data will be cached and then returned
* after being passed through a filter. If the comment is empty, then the global
* comment variable will be used, if it is set.
*
* If the comment is empty, then the global comment variable will be used, if it
* is set.
*
* @since 2.0.0
* @uses $wpdb
*
* @param object|string|int $comment Comment to retrieve.
* @param string $output Optional. OBJECT or ARRAY_A or ARRAY_N constants.
* @return object|array|null Depends on $output value.
*/
function &get_comment(&$comment, $output = OBJECT) {
global $wpdb;
if ( empty($comment) ) {
if ( isset($GLOBALS['comment']) )
$_comment = & $GLOBALS['comment'];
else
$_comment = null;
} elseif ( is_object($comment) ) {
wp_cache_add($comment->comment_ID, $comment, 'comment');
$_comment = $comment;
} else {
if ( isset($GLOBALS['comment']) && ($GLOBALS['comment']->comment_ID == $comment) ) {
$_comment = & $GLOBALS['comment'];
} elseif ( ! $_comment = wp_cache_get($comment, 'comment') ) {
$_comment = $wpdb->get_row($wpdb->prepare("SELECT * FROM $wpdb->comments WHERE comment_ID = %d LIMIT 1", $comment));
wp_cache_add($_comment->comment_ID, $_comment, 'comment');
}
}
$_comment = apply_filters('get_comment', $_comment);
if ( $output == OBJECT ) {
return $_comment;
} elseif ( $output == ARRAY_A ) {
$__comment = get_object_vars($_comment);
return $__comment;
} elseif ( $output == ARRAY_N ) {
$__comment = array_values(get_object_vars($_comment));
return $__comment;
} else {
return $_comment;
}
}
/**
* Retrieve a list of comments.
*
* The list of comment arguments are 'status', 'orderby', 'comment_date_gmt',
* 'order', 'number', 'offset', and 'post_id'.
*
* @since 2.7.0
* @uses $wpdb
*
* @param mixed $args Optional. Array or string of options to override defaults.
* @return array List of comments.
*/
function get_comments( $args = '' ) {
global $wpdb;
$defaults = array('status' => '', 'orderby' => 'comment_date_gmt', 'order' => 'DESC', 'number' => '', 'offset' => '', 'post_id' => 0);
$args = wp_parse_args( $args, $defaults );
extract( $args, EXTR_SKIP );
// $args can be whatever, only use the args defined in defaults to compute the key
$key = md5( serialize( compact(array_keys($defaults)) ) );
$last_changed = wp_cache_get('last_changed', 'comment');
if ( !$last_changed ) {
$last_changed = time();
wp_cache_set('last_changed', $last_changed, 'comment');
}
$cache_key = "get_comments:$key:$last_changed";
if ( $cache = wp_cache_get( $cache_key, 'comment' ) ) {
return $cache;
}
$post_id = absint($post_id);
if ( 'hold' == $status )
$approved = "comment_approved = '0'";
elseif ( 'approve' == $status )
$approved = "comment_approved = '1'";
elseif ( 'spam' == $status )
$approved = "comment_approved = 'spam'";
else
$approved = "( comment_approved = '0' OR comment_approved = '1' )";
$order = ( 'ASC' == $order ) ? 'ASC' : 'DESC';
$orderby = 'comment_date_gmt'; // Hard code for now
$number = absint($number);
$offset = absint($offset);
if ( !empty($number) ) {
if ( $offset )
$number = 'LIMIT ' . $offset . ',' . $number;
else
$number = 'LIMIT ' . $number;
} else {
$number = '';
}
if ( ! empty($post_id) )
$post_where = $wpdb->prepare( 'comment_post_ID = %d AND', $post_id );
else
$post_where = '';
$comments = $wpdb->get_results( "SELECT * FROM $wpdb->comments WHERE $post_where $approved ORDER BY $orderby $order $number" );
wp_cache_add( $cache_key, $comments, 'comment' );
return $comments;
}
/**
* Retrieve all of the WordPress supported comment statuses.
*
* Comments have a limited set of valid status values, this provides the comment
* status values and descriptions.
*
* @package WordPress
* @subpackage Post
* @since 2.7.0
*
* @return array List of comment statuses.
*/
function get_comment_statuses( ) {
$status = array(
'hold' => __('Unapproved'),
'approve' => __('Approved'),
'spam' => _c('Spam|adjective'),
);
return $status;
}
/**
* The date the last comment was modified.
*
* @since 1.5.0
* @uses $wpdb
* @global array $cache_lastcommentmodified
*
* @param string $timezone Which timezone to use in reference to 'gmt', 'blog',
* or 'server' locations.
* @return string Last comment modified date.
*/
function get_lastcommentmodified($timezone = 'server') {
global $cache_lastcommentmodified, $wpdb;
if ( isset($cache_lastcommentmodified[$timezone]) )
return $cache_lastcommentmodified[$timezone];
$add_seconds_server = date('Z');
switch ( strtolower($timezone)) {
case 'gmt':
$lastcommentmodified = $wpdb->get_var("SELECT comment_date_gmt FROM $wpdb->comments WHERE comment_approved = '1' ORDER BY comment_date_gmt DESC LIMIT 1");
break;
case 'blog':
$lastcommentmodified = $wpdb->get_var("SELECT comment_date FROM $wpdb->comments WHERE comment_approved = '1' ORDER BY comment_date_gmt DESC LIMIT 1");
break;
case 'server':
$lastcommentmodified = $wpdb->get_var($wpdb->prepare("SELECT DATE_ADD(comment_date_gmt, INTERVAL %s SECOND) FROM $wpdb->comments WHERE comment_approved = '1' ORDER BY comment_date_gmt DESC LIMIT 1", $add_seconds_server));
break;
}
$cache_lastcommentmodified[$timezone] = $lastcommentmodified;
return $lastcommentmodified;
}
/**
* The amount of comments in a post or total comments.
*
* A lot like {@link wp_count_comments()}, in that they both return comment
* stats (albeit with different types). The {@link wp_count_comments()} actual
* caches, but this function does not.
*
* @since 2.0.0
* @uses $wpdb
*
* @param int $post_id Optional. Comment amount in post if > 0, else total comments blog wide.
* @return array The amount of spam, approved, awaiting moderation, and total comments.
*/
function get_comment_count( $post_id = 0 ) {
global $wpdb;
$post_id = (int) $post_id;
$where = '';
if ( $post_id > 0 ) {
$where = $wpdb->prepare("WHERE comment_post_ID = %d", $post_id);
}
$totals = (array) $wpdb->get_results("
SELECT comment_approved, COUNT( * ) AS total
FROM {$wpdb->comments}
{$where}
GROUP BY comment_approved
", ARRAY_A);
$comment_count = array(
"approved" => 0,
"awaiting_moderation" => 0,
"spam" => 0,
"total_comments" => 0
);
foreach ( $totals as $row ) {
switch ( $row['comment_approved'] ) {
case 'spam':
$comment_count['spam'] = $row['total'];
$comment_count["total_comments"] += $row['total'];
break;
case 1:
$comment_count['approved'] = $row['total'];
$comment_count['total_comments'] += $row['total'];
break;
case 0:
$comment_count['awaiting_moderation'] = $row['total'];
$comment_count['total_comments'] += $row['total'];
break;
default:
break;
}
}
return $comment_count;
}
/**
* Sanitizes the cookies sent to the user already.
*
* Will only do anything if the cookies have already been created for the user.
* Mostly used after cookies had been sent to use elsewhere.
*
* @since 2.0.4
*/
function sanitize_comment_cookies() {
if ( isset($_COOKIE['comment_author_'.COOKIEHASH]) ) {
$comment_author = apply_filters('pre_comment_author_name', $_COOKIE['comment_author_'.COOKIEHASH]);
$comment_author = stripslashes($comment_author);
$comment_author = attribute_escape($comment_author);
$_COOKIE['comment_author_'.COOKIEHASH] = $comment_author;
}
if ( isset($_COOKIE['comment_author_email_'.COOKIEHASH]) ) {
$comment_author_email = apply_filters('pre_comment_author_email', $_COOKIE['comment_author_email_'.COOKIEHASH]);
$comment_author_email = stripslashes($comment_author_email);
$comment_author_email = attribute_escape($comment_author_email);
$_COOKIE['comment_author_email_'.COOKIEHASH] = $comment_author_email;
}
if ( isset($_COOKIE['comment_author_url_'.COOKIEHASH]) ) {
$comment_author_url = apply_filters('pre_comment_author_url', $_COOKIE['comment_author_url_'.COOKIEHASH]);
$comment_author_url = stripslashes($comment_author_url);
$_COOKIE['comment_author_url_'.COOKIEHASH] = $comment_author_url;
}
}
/**
* Validates whether this comment is allowed to be made or not.
*
* @since 2.0.0
* @uses $wpdb
* @uses apply_filters() Calls 'pre_comment_approved' hook on the type of comment
* @uses do_action() Calls 'check_comment_flood' hook on $comment_author_IP, $comment_author_email, and $comment_date_gmt
*
* @param array $commentdata Contains information on the comment
* @return mixed Signifies the approval status (0|1|'spam')
*/
function wp_allow_comment($commentdata) {
global $wpdb;
extract($commentdata, EXTR_SKIP);
// Simple duplicate check
// expected_slashed ($comment_post_ID, $comment_author, $comment_author_email, $comment_content)
$dupe = "SELECT comment_ID FROM $wpdb->comments WHERE comment_post_ID = '$comment_post_ID' AND ( comment_author = '$comment_author' ";
if ( $comment_author_email )
$dupe .= "OR comment_author_email = '$comment_author_email' ";
$dupe .= ") AND comment_content = '$comment_content' LIMIT 1";
if ( $wpdb->get_var($dupe) ) {
if ( defined('DOING_AJAX') )
die( __('Duplicate comment detected; it looks as though you\'ve already said that!') );
wp_die( __('Duplicate comment detected; it looks as though you\'ve already said that!') );
}
do_action( 'check_comment_flood', $comment_author_IP, $comment_author_email, $comment_date_gmt );
if ( $user_id ) {
$userdata = get_userdata($user_id);
$user = new WP_User($user_id);
$post_author = $wpdb->get_var($wpdb->prepare("SELECT post_author FROM $wpdb->posts WHERE ID = %d LIMIT 1", $comment_post_ID));
}
if ( isset($userdata) && ( $user_id == $post_author || $user->has_cap('moderate_comments') ) ) {
// The author and the admins get respect.
$approved = 1;
} else {
// Everyone else's comments will be checked.
if ( check_comment($comment_author, $comment_author_email, $comment_author_url, $comment_content, $comment_author_IP, $comment_agent, $comment_type) )
$approved = 1;
else
$approved = 0;
if ( wp_blacklist_check($comment_author, $comment_author_email, $comment_author_url, $comment_content, $comment_author_IP, $comment_agent) )
$approved = 'spam';
}
$approved = apply_filters('pre_comment_approved', $approved);
return $approved;
}
/**
* Check whether comment flooding is occurring.
*
* Won't run, if current user can manage options, so to not block
* administrators.
*
* @since 2.3.0
* @uses $wpdb
* @uses apply_filters() Calls 'comment_flood_filter' filter with first
* parameter false, last comment timestamp, new comment timestamp.
* @uses do_action() Calls 'comment_flood_trigger' action with parameters with
* last comment timestamp and new comment timestamp.
*
* @param string $ip Comment IP.
* @param string $email Comment author email address.
* @param string $date MySQL time string.
*/
function check_comment_flood_db( $ip, $email, $date ) {
global $wpdb;
if ( current_user_can( 'manage_options' ) )
return; // don't throttle admins
if ( $lasttime = $wpdb->get_var( $wpdb->prepare("SELECT comment_date_gmt FROM $wpdb->comments WHERE comment_author_IP = %s OR comment_author_email = %s ORDER BY comment_date DESC LIMIT 1", $ip, $email) ) ) {
$time_lastcomment = mysql2date('U', $lasttime);
$time_newcomment = mysql2date('U', $date);
$flood_die = apply_filters('comment_flood_filter', false, $time_lastcomment, $time_newcomment);
if ( $flood_die ) {
do_action('comment_flood_trigger', $time_lastcomment, $time_newcomment);
if ( defined('DOING_AJAX') )
die( __('You are posting comments too quickly. Slow down.') );
wp_die( __('You are posting comments too quickly. Slow down.'), '', array('response' => 403) );
}
}
}
/**
* Separates an array of comments into an array keyed by comment_type.
*
* @since 2.7.0
*
* @param array $comments Array of comments
* @return array Array of comments keyed by comment_type.
*/
function &separate_comments(&$comments) {
$comments_by_type = array('comment' => array(), 'trackback' => array(), 'pingback' => array(), 'pings' => array());
$count = count($comments);
for ( $i = 0; $i < $count; $i++ ) {
$type = $comments[$i]->comment_type;
if ( empty($type) )
$type = 'comment';
$comments_by_type[$type][] = &$comments[$i];
if ( 'trackback' == $type || 'pingback' == $type )
$comments_by_type['pings'][] = &$comments[$i];
}
return $comments_by_type;
}
/**
* Calculate the total number of comment pages.
*
* @since 2.7.0
* @uses get_query_var() Used to fill in the default for $per_page parameter.
* @uses get_option() Used to fill in defaults for parameters.
* @uses Walker_Comment
*
* @param array $comments Optional array of comment objects. Defaults to $wp_query->comments
* @param int $per_page Optional comments per page.
* @param boolean $threaded Optional control over flat or threaded comments.
* @return int Number of comment pages.
*/
function get_comment_pages_count( $comments = null, $per_page = null, $threaded = null ) {
global $wp_query;
if ( null === $comments && null === $per_page && null === $threaded && !empty($wp_query->max_num_comment_pages) )
return $wp_query->max_num_comment_pages;
if ( !$comments || !is_array($comments) )
$comments = $wp_query->comments;
if ( empty($comments) )
return 0;
if ( !isset($per_page) )
$per_page = (int) get_query_var('comments_per_page');
if ( 0 === $per_page )
$per_page = (int) get_option('comments_per_page');
if ( 0 === $per_page )
return 1;
if ( !isset($threaded) )
$threaded = get_option('thread_comments');
if ( $threaded ) {
$walker = new Walker_Comment;
$count = ceil( $walker->get_number_of_root_elements( $comments ) / $per_page );
} else {
$count = ceil( count( $comments ) / $per_page );
}
return $count;
}
/**
* Calculate what page number a comment will appear on for comment paging.
*
* @since 2.7.0
* @uses get_comment() Gets the full comment of the $comment_ID parameter.
* @uses get_option() Get various settings to control function and defaults.
* @uses get_page_of_comment() Used to loop up to top level comment.
*
* @param int $comment_ID Comment ID.
* @param array $args Optional args.
* @return int|null Comment page number or null on error.
*/
function get_page_of_comment( $comment_ID, $args = array() ) {
global $wpdb;
if ( !$comment = get_comment( $comment_ID ) )
return;
$defaults = array( 'type' => 'all', 'page' => '', 'per_page' => '', 'max_depth' => '' );
$args = wp_parse_args( $args, $defaults );
if ( '' === $args['per_page'] && get_option('page_comments') )
$args['per_page'] = get_query_var('comments_per_page');
if ( empty($args['per_page']) ) {
$args['per_page'] = 0;
$args['page'] = 0;
}
if ( $args['per_page'] < 1 )
return 1;
if ( '' === $args['max_depth'] ) {
if ( get_option('thread_comments') )
$args['max_depth'] = get_option('thread_comments_depth');
else
$args['max_depth'] = -1;
}
// Find this comment's top level parent if threading is enabled
if ( $args['max_depth'] > 1 && 0 != $comment->comment_parent )
return get_page_of_comment( $comment->comment_parent, $args );
$allowedtypes = array(
'comment' => '',
'pingback' => 'pingback',
'trackback' => 'trackback',
);
$comtypewhere = ( 'all' != $args['type'] && isset($allowedtypes[$args['type']]) ) ? " AND comment_type = '" . $allowedtypes[$args['type']] . "'" : '';
// Count comments older than this one
$oldercoms = $wpdb->get_var( $wpdb->prepare( "SELECT COUNT(comment_ID) FROM $wpdb->comments WHERE comment_post_ID = %d AND comment_parent = 0 AND comment_approved = '1' AND comment_date_gmt < '%s'" . $comtypewhere, $comment->comment_post_ID, $comment->comment_date_gmt ) );
// No older comments? Then it's page #1.
if ( 0 == $oldercoms )
return 1;
// Divide comments older than this one by comments per page to get this comment's page number
return ceil( ( $oldercoms + 1 ) / $args['per_page'] );
}
/**
* Does comment contain blacklisted characters or words.
*
* @since 1.5.0
* @uses do_action() Calls 'wp_blacklist_check' hook for all parameters.
*
* @param string $author The author of the comment
* @param string $email The email of the comment
* @param string $url The url used in the comment
* @param string $comment The comment content
* @param string $user_ip The comment author IP address
* @param string $user_agent The author's browser user agent
* @return bool True if comment contains blacklisted content, false if comment does not
*/
function wp_blacklist_check($author, $email, $url, $comment, $user_ip, $user_agent) {
do_action('wp_blacklist_check', $author, $email, $url, $comment, $user_ip, $user_agent);
if ( preg_match_all('/&#(\d+);/', $comment . $author . $url, $chars) ) {
foreach ( (array) $chars[1] as $char ) {
// If it's an encoded char in the normal ASCII set, reject
if ( 38 == $char )
continue; // Unless it's &
if ( $char < 128 )
return true;
}
}
$mod_keys = trim( get_option('blacklist_keys') );
if ( '' == $mod_keys )
return false; // If moderation keys are empty
$words = explode("\n", $mod_keys );
foreach ( (array) $words as $word ) {
$word = trim($word);
// Skip empty lines
if ( empty($word) ) { continue; }
// Do some escaping magic so that '#' chars in the
// spam words don't break things:
$word = preg_quote($word, '#');
$pattern = "#$word#i";
if (
preg_match($pattern, $author)
|| preg_match($pattern, $email)
|| preg_match($pattern, $url)
|| preg_match($pattern, $comment)
|| preg_match($pattern, $user_ip)
|| preg_match($pattern, $user_agent)
)
return true;
}
return false;
}
/**
* Retrieve total comments for blog or single post.
*
* The properties of the returned object contain the 'moderated', 'approved',
* and spam comments for either the entire blog or single post. Those properties
* contain the amount of comments that match the status. The 'total_comments'
* property contains the integer of total comments.
*
* The comment stats are cached and then retrieved, if they already exist in the
* cache.
*
* @since 2.5.0
*
* @param int $post_id Optional. Post ID.
* @return object Comment stats.
*/
function wp_count_comments( $post_id = 0 ) {
global $wpdb;
$post_id = (int) $post_id;
$stats = apply_filters('wp_count_comments', array(), $post_id);
if ( !empty($stats) )
return $stats;
$count = wp_cache_get("comments-{$post_id}", 'counts');
if ( false !== $count )
return $count;
$where = '';
if( $post_id > 0 )
$where = $wpdb->prepare( "WHERE comment_post_ID = %d", $post_id );
$count = $wpdb->get_results( "SELECT comment_approved, COUNT( * ) AS num_comments FROM {$wpdb->comments} {$where} GROUP BY comment_approved", ARRAY_A );
$total = 0;
$approved = array('0' => 'moderated', '1' => 'approved', 'spam' => 'spam');
$known_types = array_keys( $approved );
foreach( (array) $count as $row_num => $row ) {
$total += $row['num_comments'];
if ( in_array( $row['comment_approved'], $known_types ) )
$stats[$approved[$row['comment_approved']]] = $row['num_comments'];
}
$stats['total_comments'] = $total;
foreach ( $approved as $key ) {
if ( empty($stats[$key]) )
$stats[$key] = 0;
}
$stats = (object) $stats;
wp_cache_set("comments-{$post_id}", $stats, 'counts');
return $stats;
}
/**
* Removes comment ID and maybe updates post comment count.
*
* The post comment count will be updated if the comment was approved and has a
* post ID available.
*
* @since 2.0.0
* @uses $wpdb
* @uses do_action() Calls 'delete_comment' hook on comment ID
* @uses do_action() Calls 'wp_set_comment_status' hook on comment ID with 'delete' set for the second parameter
* @uses wp_transition_comment_status() Passes new and old comment status along with $comment object
*
* @param int $comment_id Comment ID
* @return bool False if delete comment query failure, true on success.
*/
function wp_delete_comment($comment_id) {
global $wpdb;
do_action('delete_comment', $comment_id);
$comment = get_comment($comment_id);
if ( ! $wpdb->query( $wpdb->prepare("DELETE FROM $wpdb->comments WHERE comment_ID = %d LIMIT 1", $comment_id) ) )
return false;
$post_id = $comment->comment_post_ID;
if ( $post_id && $comment->comment_approved == 1 )
wp_update_comment_count($post_id);
clean_comment_cache($comment_id);
do_action('wp_set_comment_status', $comment_id, 'delete');
wp_transition_comment_status('delete', $comment->comment_approved, $comment);
return true;
}
/**
* The status of a comment by ID.
*
* @since 1.0.0
*
* @param int $comment_id Comment ID
* @return string|bool Status might be 'deleted', 'approved', 'unapproved', 'spam'. False on failure.
*/
function wp_get_comment_status($comment_id) {
$comment = get_comment($comment_id);
if ( !$comment )
return false;
$approved = $comment->comment_approved;
if ( $approved == NULL )
return 'deleted';
elseif ( $approved == '1' )
return 'approved';
elseif ( $approved == '0' )
return 'unapproved';
elseif ( $approved == 'spam' )
return 'spam';
else
return false;
}
/**
* Call hooks for when a comment status transition occurs.
*
* Calls hooks for comment status transitions. If the new comment status is not the same
* as the previous comment status, then two hooks will be ran, the first is
* 'transition_comment_status' with new status, old status, and comment data. The
* next action called is 'comment_OLDSTATUS_to_NEWSTATUS' the NEWSTATUS is the
* $new_status parameter and the OLDSTATUS is $old_status parameter; it has the
* comment data.
*
* The final action will run whether or not the comment statuses are the same. The
* action is named 'comment_NEWSTATUS_COMMENTTYPE', NEWSTATUS is from the $new_status
* parameter and COMMENTTYPE is comment_type comment data.
*
* @since 2.7.0
*
* @param string $new_status New comment status.
* @param string $old_status Previous comment status.
* @param object $comment Comment data.
*/
function wp_transition_comment_status($new_status, $old_status, $comment) {
// Translate raw statuses to human readable formats for the hooks
// This is not a complete list of comment status, it's only the ones that need to be renamed
$comment_statuses = array(
0 => 'unapproved',
'hold' => 'unapproved', // wp_set_comment_status() uses "hold"
1 => 'approved',
'approve' => 'approved', // wp_set_comment_status() uses "approve"
);
if ( isset($comment_statuses[$new_status]) ) $new_status = $comment_statuses[$new_status];
if ( isset($comment_statuses[$old_status]) ) $old_status = $comment_statuses[$old_status];
// Call the hooks
if ( $new_status != $old_status ) {
do_action('transition_comment_status', $new_status, $old_status, $comment);
do_action("comment_${old_status}_to_$new_status", $comment);
}
do_action("comment_${new_status}_$comment->comment_type", $comment->comment_ID, $comment);
}
/**
* Get current commenter's name, email, and URL.
*
* Expects cookies content to already be sanitized. User of this function might
* wish to recheck the returned array for validity.
*
* @see sanitize_comment_cookies() Use to sanitize cookies
*
* @since 2.0.4
*
* @return array Comment author, email, url respectively.
*/
function wp_get_current_commenter() {
// Cookies should already be sanitized.
$comment_author = '';
if ( isset($_COOKIE['comment_author_'.COOKIEHASH]) )
$comment_author = $_COOKIE['comment_author_'.COOKIEHASH];
$comment_author_email = '';
if ( isset($_COOKIE['comment_author_email_'.COOKIEHASH]) )
$comment_author_email = $_COOKIE['comment_author_email_'.COOKIEHASH];
$comment_author_url = '';
if ( isset($_COOKIE['comment_author_url_'.COOKIEHASH]) )
$comment_author_url = $_COOKIE['comment_author_url_'.COOKIEHASH];
return compact('comment_author', 'comment_author_email', 'comment_author_url');
}
/**
* Inserts a comment to the database.
*
* The available comment data key names are 'comment_author_IP', 'comment_date',
* 'comment_date_gmt', 'comment_parent', 'comment_approved', and 'user_id'.
*
* @since 2.0.0
* @uses $wpdb
*
* @param array $commentdata Contains information on the comment.
* @return int The new comment's ID.
*/
function wp_insert_comment($commentdata) {
global $wpdb;
extract(stripslashes_deep($commentdata), EXTR_SKIP);
if ( ! isset($comment_author_IP) )
$comment_author_IP = '';
if ( ! isset($comment_date) )
$comment_date = current_time('mysql');
if ( ! isset($comment_date_gmt) )
$comment_date_gmt = get_gmt_from_date($comment_date);
if ( ! isset($comment_parent) )
$comment_parent = 0;
if ( ! isset($comment_approved) )
$comment_approved = 1;
if ( ! isset($user_id) )
$user_id = 0;
if ( ! isset($comment_type) )
$comment_type = '';
$result = $wpdb->query( $wpdb->prepare("INSERT INTO $wpdb->comments
(comment_post_ID, comment_author, comment_author_email, comment_author_url, comment_author_IP, comment_date, comment_date_gmt, comment_content, comment_approved, comment_agent, comment_type, comment_parent, user_id)
VALUES (%d, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %d, %d)",
$comment_post_ID, $comment_author, $comment_author_email, $comment_author_url, $comment_author_IP, $comment_date, $comment_date_gmt, $comment_content, $comment_approved, $comment_agent, $comment_type, $comment_parent, $user_id) );
$id = (int) $wpdb->insert_id;
if ( $comment_approved == 1)
wp_update_comment_count($comment_post_ID);
return $id;
}
/**
* Filters and sanitizes comment data.
*
* Sets the comment data 'filtered' field to true when finished. This can be
* checked as to whether the comment should be filtered and to keep from
* filtering the same comment more than once.
*
* @since 2.0.0
* @uses apply_filters() Calls 'pre_user_id' hook on comment author's user ID
* @uses apply_filters() Calls 'pre_comment_user_agent' hook on comment author's user agent
* @uses apply_filters() Calls 'pre_comment_author_name' hook on comment author's name
* @uses apply_filters() Calls 'pre_comment_content' hook on the comment's content
* @uses apply_filters() Calls 'pre_comment_user_ip' hook on comment author's IP
* @uses apply_filters() Calls 'pre_comment_author_url' hook on comment author's URL
* @uses apply_filters() Calls 'pre_comment_author_email' hook on comment author's email address
*
* @param array $commentdata Contains information on the comment.
* @return array Parsed comment information.
*/
function wp_filter_comment($commentdata) {
$commentdata['user_id'] = apply_filters('pre_user_id', $commentdata['user_ID']);
$commentdata['comment_agent'] = apply_filters('pre_comment_user_agent', $commentdata['comment_agent']);
$commentdata['comment_author'] = apply_filters('pre_comment_author_name', $commentdata['comment_author']);
$commentdata['comment_content'] = apply_filters('pre_comment_content', $commentdata['comment_content']);
$commentdata['comment_author_IP'] = apply_filters('pre_comment_user_ip', $commentdata['comment_author_IP']);
$commentdata['comment_author_url'] = apply_filters('pre_comment_author_url', $commentdata['comment_author_url']);
$commentdata['comment_author_email'] = apply_filters('pre_comment_author_email', $commentdata['comment_author_email']);
$commentdata['filtered'] = true;
return $commentdata;
}
/**
* Whether comment should be blocked because of comment flood.
*
* @since 2.1.0
*
* @param bool $block Whether plugin has already blocked comment.
* @param int $time_lastcomment Timestamp for last comment.
* @param int $time_newcomment Timestamp for new comment.
* @return bool Whether comment should be blocked.
*/
function wp_throttle_comment_flood($block, $time_lastcomment, $time_newcomment) {
if ( $block ) // a plugin has already blocked... we'll let that decision stand
return $block;
if ( ($time_newcomment - $time_lastcomment) < 15 )
return true;
return false;
}
/**
* Adds a new comment to the database.
*
* Filters new comment to ensure that the fields are sanitized and valid before
* inserting comment into database. Calls 'comment_post' action with comment ID
* and whether comment is approved by WordPress. Also has 'preprocess_comment'
* filter for processing the comment data before the function handles it.
*
* @since 1.5.0
* @uses apply_filters() Calls 'preprocess_comment' hook on $commentdata parameter array before processing
* @uses do_action() Calls 'comment_post' hook on $comment_ID returned from adding the comment and if the comment was approved.
* @uses wp_filter_comment() Used to filter comment before adding comment.
* @uses wp_allow_comment() checks to see if comment is approved.
* @uses wp_insert_comment() Does the actual comment insertion to the database.
*
* @param array $commentdata Contains information on the comment.
* @return int The ID of the comment after adding.
*/
function wp_new_comment( $commentdata ) {
$commentdata = apply_filters('preprocess_comment', $commentdata);
$commentdata['comment_post_ID'] = (int) $commentdata['comment_post_ID'];
$commentdata['user_ID'] = (int) $commentdata['user_ID'];
$commentdata['comment_parent'] = absint($commentdata['comment_parent']);
$parent_status = ( 0 < $commentdata['comment_parent'] ) ? wp_get_comment_status($commentdata['comment_parent']) : '';
$commentdata['comment_parent'] = ( 'approved' == $parent_status || 'unapproved' == $parent_status ) ? $commentdata['comment_parent'] : 0;
$commentdata['comment_author_IP'] = preg_replace( '/[^0-9a-fA-F:., ]/', '',$_SERVER['REMOTE_ADDR'] );
$commentdata['comment_agent'] = $_SERVER['HTTP_USER_AGENT'];
$commentdata['comment_date'] = current_time('mysql');
$commentdata['comment_date_gmt'] = current_time('mysql', 1);
$commentdata = wp_filter_comment($commentdata);
$commentdata['comment_approved'] = wp_allow_comment($commentdata);
$comment_ID = wp_insert_comment($commentdata);
do_action('comment_post', $comment_ID, $commentdata['comment_approved']);
if ( 'spam' !== $commentdata['comment_approved'] ) { // If it's spam save it silently for later crunching
if ( '0' == $commentdata['comment_approved'] )
wp_notify_moderator($comment_ID);
$post = &get_post($commentdata['comment_post_ID']); // Don't notify if it's your own comment
if ( get_option('comments_notify') && $commentdata['comment_approved'] && $post->post_author != $commentdata['user_ID'] )
wp_notify_postauthor($comment_ID, $commentdata['comment_type']);
}
return $comment_ID;
}
/**
* Sets the status of a comment.
*
* The 'wp_set_comment_status' action is called after the comment is handled and
* will only be called, if the comment status is either 'hold', 'approve', or
* 'spam'. If the comment status is not in the list, then false is returned and
* if the status is 'delete', then the comment is deleted without calling the
* action.
*
* @since 1.0.0
* @uses wp_transition_comment_status() Passes new and old comment status along with $comment object
*
* @param int $comment_id Comment ID.
* @param string $comment_status New comment status, either 'hold', 'approve', 'spam', or 'delete'.
* @return bool False on failure or deletion and true on success.
*/
function wp_set_comment_status($comment_id, $comment_status) {
global $wpdb;
switch ( $comment_status ) {
case 'hold':
$query = $wpdb->prepare("UPDATE $wpdb->comments SET comment_approved='0' WHERE comment_ID = %d LIMIT 1", $comment_id);
break;
case 'approve':
$query = $wpdb->prepare("UPDATE $wpdb->comments SET comment_approved='1' WHERE comment_ID = %d LIMIT 1", $comment_id);
if ( get_option('comments_notify') ) {
$comment = get_comment($comment_id);
wp_notify_postauthor($comment_id, $comment->comment_type);
}
break;
case 'spam':
$query = $wpdb->prepare("UPDATE $wpdb->comments SET comment_approved='spam' WHERE comment_ID = %d LIMIT 1", $comment_id);
break;
case 'delete':
return wp_delete_comment($comment_id);
break;
default:
return false;
}
if ( !$wpdb->query($query) )
return false;
clean_comment_cache($comment_id);
$comment = get_comment($comment_id);
do_action('wp_set_comment_status', $comment_id, $comment_status);
wp_transition_comment_status($comment_status, $comment->comment_approved, $comment);
wp_update_comment_count($comment->comment_post_ID);
return true;
}
/**
* Updates an existing comment in the database.
*
* Filters the comment and makes sure certain fields are valid before updating.
*
* @since 2.0.0
* @uses $wpdb
* @uses wp_transition_comment_status() Passes new and old comment status along with $comment object
*
* @param array $commentarr Contains information on the comment.
* @return int Comment was updated if value is 1, or was not updated if value is 0.
*/
function wp_update_comment($commentarr) {
global $wpdb;
// First, get all of the original fields
$comment = get_comment($commentarr['comment_ID'], ARRAY_A);
// Escape data pulled from DB.
foreach ( (array) $comment as $key => $value )
$comment[$key] = $wpdb->escape($value);
// Merge old and new fields with new fields overwriting old ones.
$commentarr = array_merge($comment, $commentarr);
$commentarr = wp_filter_comment( $commentarr );
// Now extract the merged array.
extract(stripslashes_deep($commentarr), EXTR_SKIP);
$comment_content = apply_filters('comment_save_pre', $comment_content);
$comment_date_gmt = get_gmt_from_date($comment_date);
if ( !isset($comment_approved) )
$comment_approved = 1;
else if ( 'hold' == $comment_approved )
$comment_approved = 0;
else if ( 'approve' == $comment_approved )
$comment_approved = 1;
$wpdb->query( $wpdb->prepare("UPDATE $wpdb->comments SET
comment_content = %s,
comment_author = %s,
comment_author_email = %s,
comment_approved = %s,
comment_author_url = %s,
comment_date = %s,
comment_date_gmt = %s
WHERE comment_ID = %d",
$comment_content,
$comment_author,
$comment_author_email,
$comment_approved,
$comment_author_url,
$comment_date,
$comment_date_gmt,
$comment_ID) );
$rval = $wpdb->rows_affected;
clean_comment_cache($comment_ID);
wp_update_comment_count($comment_post_ID);
do_action('edit_comment', $comment_ID);
$comment = get_comment($comment_ID);
wp_transition_comment_status($comment_approved, $comment->comment_approved, $comment);
return $rval;
}
/**
* Whether to defer comment counting.
*
* When setting $defer to true, all post comment counts will not be updated
* until $defer is set to false. When $defer is set to false, then all
* previously deferred updated post comment counts will then be automatically
* updated without having to call wp_update_comment_count() after.
*
* @since 2.5.0
* @staticvar bool $_defer
*
* @param bool $defer
* @return unknown
*/
function wp_defer_comment_counting($defer=null) {
static $_defer = false;
if ( is_bool($defer) ) {
$_defer = $defer;
// flush any deferred counts
if ( !$defer )
wp_update_comment_count( null, true );
}
return $_defer;
}
/**
* Updates the comment count for post(s).
*
* When $do_deferred is false (is by default) and the comments have been set to
* be deferred, the post_id will be added to a queue, which will be updated at a
* later date and only updated once per post ID.
*
* If the comments have not be set up to be deferred, then the post will be
* updated. When $do_deferred is set to true, then all previous deferred post
* IDs will be updated along with the current $post_id.
*
* @since 2.1.0
* @see wp_update_comment_count_now() For what could cause a false return value
*
* @param int $post_id Post ID
* @param bool $do_deferred Whether to process previously deferred post comment counts
* @return bool True on success, false on failure
*/
function wp_update_comment_count($post_id, $do_deferred=false) {
static $_deferred = array();
if ( $do_deferred ) {
$_deferred = array_unique($_deferred);
foreach ( $_deferred as $i => $_post_id ) {
wp_update_comment_count_now($_post_id);
unset( $_deferred[$i] ); /** @todo Move this outside of the foreach and reset $_deferred to an array instead */
}
}
if ( wp_defer_comment_counting() ) {
$_deferred[] = $post_id;
return true;
}
elseif ( $post_id ) {
return wp_update_comment_count_now($post_id);
}
}
/**
* Updates the comment count for the post.
*
* @since 2.5.0
* @uses $wpdb
* @uses do_action() Calls 'wp_update_comment_count' hook on $post_id, $new, and $old
* @uses do_action() Calls 'edit_posts' hook on $post_id and $post
*
* @param int $post_id Post ID
* @return bool False on '0' $post_id or if post with ID does not exist. True on success.
*/
function wp_update_comment_count_now($post_id) {
global $wpdb;
$post_id = (int) $post_id;
if ( !$post_id )
return false;
if ( !$post = get_post($post_id) )
return false;
$old = (int) $post->comment_count;
$new = (int) $wpdb->get_var( $wpdb->prepare("SELECT COUNT(*) FROM $wpdb->comments WHERE comment_post_ID = %d AND comment_approved = '1'", $post_id) );
$wpdb->query( $wpdb->prepare("UPDATE $wpdb->posts SET comment_count = %d WHERE ID = %d", $new, $post_id) );
if ( 'page' == $post->post_type )
clean_page_cache( $post_id );
else
clean_post_cache( $post_id );
do_action('wp_update_comment_count', $post_id, $new, $old);
do_action('edit_post', $post_id, $post);
return true;
}
//
// Ping and trackback functions.
//
/**
* Finds a pingback server URI based on the given URL.
*
* Checks the HTML for the rel="pingback" link and x-pingback headers. It does
* a check for the x-pingback headers first and returns that, if available. The
* check for the rel="pingback" has more overhead than just the header.
*
* @since 1.5.0
*
* @param string $url URL to ping.
* @param int $deprecated Not Used.
* @return bool|string False on failure, string containing URI on success.
*/
function discover_pingback_server_uri($url, $deprecated = 2048) {
$pingback_str_dquote = 'rel="pingback"';
$pingback_str_squote = 'rel=\'pingback\'';
/** @todo Should use Filter Extension or custom preg_match instead. */
$parsed_url = parse_url($url);
if ( ! isset( $parsed_url['host'] ) ) // Not an URL. This should never happen.
return false;
$response = wp_remote_get( $url, array( 'timeout' => 2, 'httpversion' => '1.1' ) );
if ( is_wp_error( $response ) )
return false;
if ( isset( $response['headers']['x-pingback'] ) )
return $response['headers']['x-pingback'];
// Not an (x)html, sgml, or xml page, no use going further.
if ( isset( $response['headers']['content-type'] ) && preg_match('#(image|audio|video|model)/#is', $response['headers']['content-type']) )
return false;
$contents = $response['body'];
$pingback_link_offset_dquote = strpos($contents, $pingback_str_dquote);
$pingback_link_offset_squote = strpos($contents, $pingback_str_squote);
if ( $pingback_link_offset_dquote || $pingback_link_offset_squote ) {
$quote = ($pingback_link_offset_dquote) ? '"' : '\'';
$pingback_link_offset = ($quote=='"') ? $pingback_link_offset_dquote : $pingback_link_offset_squote;
$pingback_href_pos = @strpos($contents, 'href=', $pingback_link_offset);
$pingback_href_start = $pingback_href_pos+6;
$pingback_href_end = @strpos($contents, $quote, $pingback_href_start);
$pingback_server_url_len = $pingback_href_end - $pingback_href_start;
$pingback_server_url = substr($contents, $pingback_href_start, $pingback_server_url_len);
// We may find rel="pingback" but an incomplete pingback URL
if ( $pingback_server_url_len > 0 ) { // We got it!
return $pingback_server_url;
}
}
return false;
}
/**
* Perform all pingbacks, enclosures, trackbacks, and send to pingback services.
*
* @since 2.1.0
* @uses $wpdb
*/
function do_all_pings() {
global $wpdb;
// Do pingbacks
while ($ping = $wpdb->get_row("SELECT * FROM {$wpdb->posts}, {$wpdb->postmeta} WHERE {$wpdb->posts}.ID = {$wpdb->postmeta}.post_id AND {$wpdb->postmeta}.meta_key = '_pingme' LIMIT 1")) {
$wpdb->query("DELETE FROM {$wpdb->postmeta} WHERE post_id = {$ping->ID} AND meta_key = '_pingme';");
pingback($ping->post_content, $ping->ID);
}
// Do Enclosures
while ($enclosure = $wpdb->get_row("SELECT * FROM {$wpdb->posts}, {$wpdb->postmeta} WHERE {$wpdb->posts}.ID = {$wpdb->postmeta}.post_id AND {$wpdb->postmeta}.meta_key = '_encloseme' LIMIT 1")) {
$wpdb->query( $wpdb->prepare("DELETE FROM {$wpdb->postmeta} WHERE post_id = %d AND meta_key = '_encloseme';", $enclosure->ID) );
do_enclose($enclosure->post_content, $enclosure->ID);
}
// Do Trackbacks
$trackbacks = $wpdb->get_col("SELECT ID FROM $wpdb->posts WHERE to_ping <> '' AND post_status = 'publish'");
if ( is_array($trackbacks) )
foreach ( $trackbacks as $trackback )
do_trackbacks($trackback);
//Do Update Services/Generic Pings
generic_ping();
}
/**
* Perform trackbacks.
*
* @since 1.5.0
* @uses $wpdb
*
* @param int $post_id Post ID to do trackbacks on.
*/
function do_trackbacks($post_id) {
global $wpdb;
$post = $wpdb->get_row( $wpdb->prepare("SELECT * FROM $wpdb->posts WHERE ID = %d", $post_id) );
$to_ping = get_to_ping($post_id);
$pinged = get_pung($post_id);
if ( empty($to_ping) ) {
$wpdb->query( $wpdb->prepare("UPDATE $wpdb->posts SET to_ping = '' WHERE ID = %d", $post_id) );
return;
}
if ( empty($post->post_excerpt) )
$excerpt = apply_filters('the_content', $post->post_content);
else
$excerpt = apply_filters('the_excerpt', $post->post_excerpt);
$excerpt = str_replace(']]>', ']]>', $excerpt);
$excerpt = wp_html_excerpt($excerpt, 252) . '...';
$post_title = apply_filters('the_title', $post->post_title);
$post_title = strip_tags($post_title);
if ( $to_ping ) {
foreach ( (array) $to_ping as $tb_ping ) {
$tb_ping = trim($tb_ping);
if ( !in_array($tb_ping, $pinged) ) {
trackback($tb_ping, $post_title, $excerpt, $post_id);
$pinged[] = $tb_ping;
} else {
$wpdb->query( $wpdb->prepare("UPDATE $wpdb->posts SET to_ping = TRIM(REPLACE(to_ping, '$tb_ping', '')) WHERE ID = %d", $post_id) );
}
}
}
}
/**
* Sends pings to all of the ping site services.
*
* @since 1.2.0
*
* @param int $post_id Post ID. Not actually used.
* @return int Same as Post ID from parameter
*/
function generic_ping($post_id = 0) {
$services = get_option('ping_sites');
$services = explode("\n", $services);
foreach ( (array) $services as $service ) {
$service = trim($service);
if ( '' != $service )
weblog_ping($service);
}
return $post_id;
}
/**
* Pings back the links found in a post.
*
* @since 0.71
* @uses $wp_version
* @uses IXR_Client
*
* @param string $content Post content to check for links.
* @param int $post_ID Post ID.
*/
function pingback($content, $post_ID) {
global $wp_version;
include_once(ABSPATH . WPINC . '/class-IXR.php');
// original code by Mort (http://mort.mine.nu:8080)
$post_links = array();
$pung = get_pung($post_ID);
// Variables
$ltrs = '\w';
$gunk = '/#~:.?+=&%@!\-';
$punc = '.:?\-';
$any = $ltrs . $gunk . $punc;
// Step 1
// Parsing the post, external links (if any) are stored in the $post_links array
// This regexp comes straight from phpfreaks.com
// http://www.phpfreaks.com/quickcode/Extract_All_URLs_on_a_Page/15.php
preg_match_all("{\b http : [$any] +? (?= [$punc] * [^$any] | $)}x", $content, $post_links_temp);
// Step 2.
// Walking thru the links array
// first we get rid of links pointing to sites, not to specific files
// Example:
// http://dummy-weblog.org
// http://dummy-weblog.org/
// http://dummy-weblog.org/post.php
// We don't wanna ping first and second types, even if they have a valid Array('category', 'post_tag')
*
* @package WordPress
* @subpackage Taxonomy
* @since 2.3.0
*
* @uses $wp_taxonomies
*
* @param array|string|object $object Name of the type of taxonomy object, or an object (row from posts)
* @return array The names of all taxonomy of $object_type.
*/
function get_object_taxonomies($object) {
global $wp_taxonomies;
if ( is_object($object) ) {
if ( $object->post_type == 'attachment' )
return get_attachment_taxonomies($object);
$object = $object->post_type;
}
$object = (array) $object;
$taxonomies = array();
foreach ( (array) $wp_taxonomies as $taxonomy ) {
if ( array_intersect($object, (array) $taxonomy->object_type) )
$taxonomies[] = $taxonomy->name;
}
return $taxonomies;
}
/**
* Retrieves the taxonomy object of $taxonomy.
*
* The get_taxonomy function will first check that the parameter string given
* is a taxonomy object and if it is, it will return it.
*
* @package WordPress
* @subpackage Taxonomy
* @since 2.3.0
*
* @uses $wp_taxonomies
* @uses is_taxonomy() Checks whether taxonomy exists
*
* @param string $taxonomy Name of taxonomy object to return
* @return object|bool The Taxonomy Object or false if $taxonomy doesn't exist
*/
function get_taxonomy( $taxonomy ) {
global $wp_taxonomies;
if ( ! is_taxonomy($taxonomy) )
return false;
return $wp_taxonomies[$taxonomy];
}
/**
* Checks that the taxonomy name exists.
*
* @package WordPress
* @subpackage Taxonomy
* @since 2.3.0
*
* @uses $wp_taxonomies
*
* @param string $taxonomy Name of taxonomy object
* @return bool Whether the taxonomy exists or not.
*/
function is_taxonomy( $taxonomy ) {
global $wp_taxonomies;
return isset($wp_taxonomies[$taxonomy]);
}
/**
* Whether the taxonomy object is hierarchical.
*
* Checks to make sure that the taxonomy is an object first. Then Gets the
* object, and finally returns the hierarchical value in the object.
*
* A false return value might also mean that the taxonomy does not exist.
*
* @package WordPress
* @subpackage Taxonomy
* @since 2.3.0
*
* @uses is_taxonomy() Checks whether taxonomy exists
* @uses get_taxonomy() Used to get the taxonomy object
*
* @param string $taxonomy Name of taxonomy object
* @return bool Whether the taxonomy is hierarchical
*/
function is_taxonomy_hierarchical($taxonomy) {
if ( ! is_taxonomy($taxonomy) )
return false;
$taxonomy = get_taxonomy($taxonomy);
return $taxonomy->hierarchical;
}
/**
* Create or modify a taxonomy object. Do not use before init.
*
* A simple function for creating or modifying a taxonomy object based on the
* parameters given. The function will accept an array (third optional
* parameter), along with strings for the taxonomy name and another string for
* the object type.
*
* Nothing is returned, so expect error maybe or use is_taxonomy() to check
* whether taxonomy exists.
*
* Optional $args contents:
*
* hierarachical - has some defined purpose at other parts of the API and is a
* boolean value.
*
* update_count_callback - works much like a hook, in that it will be called
* when the count is updated.
*
* rewrite - false to prevent rewrite, or array('slug'=>$slug) to customize
* permastruct; default will use $taxonomy as slug.
*
* query_var - false to prevent queries, or string to customize query var
* (?$query_var=$term); default will use $taxonomy as query var.
*
* @package WordPress
* @subpackage Taxonomy
* @since 2.3.0
* @uses $wp_taxonomies Inserts new taxonomy object into the list
* @uses $wp_rewrite Adds rewrite tags and permastructs
* @uses $wp Adds query vars
*
* @param string $taxonomy Name of taxonomy object
* @param array|string $object_type Name of the object type for the taxonomy object.
* @param array|string $args See above description for the two keys values.
*/
function register_taxonomy( $taxonomy, $object_type, $args = array() ) {
global $wp_taxonomies, $wp_rewrite, $wp;
$defaults = array('hierarchical' => false, 'update_count_callback' => '', 'rewrite' => true, 'query_var' => true);
$args = wp_parse_args($args, $defaults);
if ( false !== $args['query_var'] && !empty($wp) ) {
if ( true === $args['query_var'] )
$args['query_var'] = $taxonomy;
$args['query_var'] = sanitize_title_with_dashes($args['query_var']);
$wp->add_query_var($args['query_var']);
}
if ( false !== $args['rewrite'] && !empty($wp_rewrite) ) {
if ( !is_array($args['rewrite']) )
$args['rewrite'] = array();
if ( !isset($args['rewrite']['slug']) )
$args['rewrite']['slug'] = sanitize_title_with_dashes($taxonomy);
$wp_rewrite->add_rewrite_tag("%$taxonomy%", '([^/]+)', $args['query_var'] ? "{$args['query_var']}=" : "taxonomy=$taxonomy&term=$term");
$wp_rewrite->add_permastruct($taxonomy, "{$args['rewrite']['slug']}/%$taxonomy%");
}
$args['name'] = $taxonomy;
$args['object_type'] = $object_type;
$wp_taxonomies[$taxonomy] = (object) $args;
}
//
// Term API
//
/**
* Retrieve object_ids of valid taxonomy and term.
*
* The strings of $taxonomies must exist before this function will continue. On
* failure of finding a valid taxonomy, it will return an WP_Error class, kind
* of like Exceptions in PHP 5, except you can't catch them. Even so, you can
* still test for the WP_Error class and get the error message.
*
* The $terms aren't checked the same as $taxonomies, but still need to exist
* for $object_ids to be returned.
*
* It is possible to change the order that object_ids is returned by either
* using PHP sort family functions or using the database by using $args with
* either ASC or DESC array. The value should be in the key named 'order'.
*
* @package WordPress
* @subpackage Taxonomy
* @since 2.3.0
*
* @uses $wpdb
* @uses wp_parse_args() Creates an array from string $args.
*
* @param string|array $terms String of term or array of string values 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 get_objects_in_term( $terms, $taxonomies, $args = array() ) {
global $wpdb;
if ( !is_array( $terms) )
$terms = array($terms);
if ( !is_array($taxonomies) )
$taxonomies = array($taxonomies);
foreach ( (array) $taxonomies as $taxonomy ) {
if ( ! is_taxonomy($taxonomy) )
return new WP_Error('invalid_taxonomy', __('Invalid Taxonomy'));
}
$defaults = array('order' => 'ASC');
$args = wp_parse_args( $args, $defaults );
extract($args, EXTR_SKIP);
$order = ( 'desc' == strtolower($order) ) ? 'DESC' : 'ASC';
$terms = array_map('intval', $terms);
$taxonomies = "'" . implode("', '", $taxonomies) . "'";
$terms = "'" . implode("', '", $terms) . "'";
$object_ids = $wpdb->get_col("SELECT tr.object_id FROM $wpdb->term_relationships AS tr INNER JOIN $wpdb->term_taxonomy AS tt ON tr.term_taxonomy_id = tt.term_taxonomy_id WHERE tt.taxonomy IN ($taxonomies) AND tt.term_id IN ($terms) ORDER BY tr.object_id $order");
if ( ! $object_ids )
return array();
return $object_ids;
}
/**
* Get all Term data from database by Term ID.
*
* The usage of the get_term function is to apply filters to a term object. It
* is possible to get a term object from the database before applying the
* filters.
*
* $term ID must be part of $taxonomy, to get from the database. Failure, might
* be able to be captured by the hooks. Failure would be the same value as $wpdb
* returns for the get_row method.
*
* There are two hooks, one is specifically for each term, named 'get_term', and
* the second is for the taxonomy name, 'term_$taxonomy'. Both hooks gets the
* term object, and the taxonomy name as parameters. Both hooks are expected to
* return a Term object.
*
* 'get_term' hook - Takes two parameters the term Object and the taxonomy name.
* Must return term object. Used in get_term() as a catch-all filter for every
* $term.
*
* 'get_$taxonomy' hook - Takes two parameters the term Object and the taxonomy
* name. Must return term object. $taxonomy will be the taxonomy name, so for
* example, if 'category', it would be 'get_category' as the filter name. Useful
* for custom taxonomies or plugging into default taxonomies.
*
* @package WordPress
* @subpackage Taxonomy
* @since 2.3.0
*
* @uses $wpdb
* @uses sanitize_term() Cleanses the term based on $filter context before returning.
* @see sanitize_term_field() The $context param lists the available values for get_term_by() $filter param.
*
* @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 &get_term($term, $taxonomy, $output = OBJECT, $filter = 'raw') {
global $wpdb;
if ( empty($term) ) {
$error = new WP_Error('invalid_term', __('Empty Term'));
return $error;
}
if ( ! is_taxonomy($taxonomy) ) {
$error = new WP_Error('invalid_taxonomy', __('Invalid Taxonomy'));
return $error;
}
if ( is_object($term) && empty($term->filter) ) {
wp_cache_add($term->term_id, $term, $taxonomy);
$_term = $term;
} else {
if ( is_object($term) )
$term = $term->term_id;
$term = (int) $term;
if ( ! $_term = wp_cache_get($term, $taxonomy) ) {
$_term = $wpdb->get_row( $wpdb->prepare( "SELECT t.*, tt.* FROM $wpdb->terms AS t INNER JOIN $wpdb->term_taxonomy AS tt ON t.term_id = tt.term_id WHERE tt.taxonomy = %s AND t.term_id = %s LIMIT 1", $taxonomy, $term) );
wp_cache_add($term, $_term, $taxonomy);
}
}
$_term = apply_filters('get_term', $_term, $taxonomy);
$_term = apply_filters("get_$taxonomy", $_term, $taxonomy);
$_term = sanitize_term($_term, $taxonomy, $filter);
if ( $output == OBJECT ) {
return $_term;
} elseif ( $output == ARRAY_A ) {
$__term = get_object_vars($_term);
return $__term;
} elseif ( $output == ARRAY_N ) {
$__term = array_values(get_object_vars($_term));
return $__term;
} else {
return $_term;
}
}
/**
* Get all Term data from database by Term field and data.
*
* Warning: $value is not escaped for 'name' $field. You must do it yourself, if
* required.
*
* The default $field is 'id', therefore it is possible to also use null for
* field, but not recommended that you do so.
*
* If $value does not exist, the return value will be false. If $taxonomy exists
* and $field and $value combinations exist, the Term will be returned.
*
* @package WordPress
* @subpackage Taxonomy
* @since 2.3.0
*
* @uses $wpdb
* @uses sanitize_term() Cleanses the term based on $filter context before returning.
* @see sanitize_term_field() The $context param lists the available values for get_term_by() $filter param.
*
* @param string $field Either 'slug', 'name', or '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 get_term_by($field, $value, $taxonomy, $output = OBJECT, $filter = 'raw') {
global $wpdb;
if ( ! is_taxonomy($taxonomy) )
return false;
if ( 'slug' == $field ) {
$field = 't.slug';
$value = sanitize_title($value);
if ( empty($value) )
return false;
} else if ( 'name' == $field ) {
// Assume already escaped
$value = stripslashes($value);
$field = 't.name';
} else {
$field = 't.term_id';
$value = (int) $value;
}
$term = $wpdb->get_row( $wpdb->prepare( "SELECT t.*, tt.* FROM $wpdb->terms AS t INNER JOIN $wpdb->term_taxonomy AS tt ON t.term_id = tt.term_id WHERE tt.taxonomy = %s AND $field = %s LIMIT 1", $taxonomy, $value) );
if ( !$term )
return false;
wp_cache_add($term->term_id, $term, $taxonomy);
$term = sanitize_term($term, $taxonomy, $filter);
if ( $output == OBJECT ) {
return $term;
} elseif ( $output == ARRAY_A ) {
return get_object_vars($term);
} elseif ( $output == ARRAY_N ) {
return array_values(get_object_vars($term));
} else {
return $term;
}
}
/**
* Merge all term children into a single array.
*
* This recursive function will merge all of the children of $term into the same
* array. Only useful for taxonomies which are hierarchical.
*
* Will return an empty array if $term does not exist in $taxonomy.
*
* @package WordPress
* @subpackage Taxonomy
* @since 2.3.0
*
* @uses $wpdb
* @uses _get_term_hierarchy()
* @uses get_term_children() Used to get the children of both $taxonomy and the parent $term
*
* @param string $term Name of Term to get children
* @param string $taxonomy Taxonomy Name
* @return array|WP_Error List of Term Objects. WP_Error returned if $taxonomy does not exist
*/
function get_term_children( $term, $taxonomy ) {
if ( ! is_taxonomy($taxonomy) )
return new WP_Error('invalid_taxonomy', __('Invalid Taxonomy'));
$terms = _get_term_hierarchy($taxonomy);
if ( ! isset($terms[$term]) )
return array();
$children = $terms[$term];
foreach ( (array) $terms[$term] as $child ) {
if ( isset($terms[$child]) )
$children = array_merge($children, get_term_children($child, $taxonomy));
}
return $children;
}
/**
* Get sanitized Term field.
*
* Does checks for $term, based on the $taxonomy. The function is for contextual
* reasons and for simplicity of usage. See sanitize_term_field() for more
* information.
*
* @package WordPress
* @subpackage Taxonomy
* @since 2.3.0
*
* @uses sanitize_term_field() Passes the return value in sanitize_term_field on success.
*
* @param string $field Term field to fetch
* @param int $term Term ID
* @param string $taxonomy Taxonomy Name
* @param string $context Optional, default is display. Look at sanitize_term_field() for available options.
* @return mixed Will return an empty string if $term is not an object or if $field is not set in $term.
*/
function get_term_field( $field, $term, $taxonomy, $context = 'display' ) {
$term = (int) $term;
$term = get_term( $term, $taxonomy );
if ( is_wp_error($term) )
return $term;
if ( !is_object($term) )
return '';
if ( !isset($term->$field) )
return '';
return sanitize_term_field($field, $term->$field, $term->term_id, $taxonomy, $context);
}
/**
* Sanitizes Term for editing.
*
* Return value is sanitize_term() and usage is for sanitizing the term for
* editing. Function is for contextual and simplicity.
*
* @package WordPress
* @subpackage Taxonomy
* @since 2.3.0
*
* @uses sanitize_term() Passes the return value on success
*
* @param int|object $id Term ID or Object
* @param string $taxonomy Taxonomy Name
* @return mixed|null|WP_Error Will return empty string if $term is not an object.
*/
function get_term_to_edit( $id, $taxonomy ) {
$term = get_term( $id, $taxonomy );
if ( is_wp_error($term) )
return $term;
if ( !is_object($term) )
return '';
return sanitize_term($term, $taxonomy, 'edit');
}
/**
* Retrieve the terms in a given taxonomy or list of taxonomies.
*
* You can fully inject any customizations to the query before it is sent, as
* well as control the output with a filter.
*
* The 'get_terms' filter will be called when the cache has the term and will
* pass the found term along with the array of $taxonomies and array of $args.
* This filter is also called before the array of terms is passed and will pass
* the array of terms, along with the $taxonomies and $args.
*
* The 'list_terms_exclusions' filter passes the compiled exclusions along with
* the $args.
*
* The list of arguments that $args can contain, which will overwrite the defaults:
*
* orderby - Default is 'name'. Can be name, count, or nothing (will use
* term_id).
*
* order - Default is ASC. Can use DESC.
*
* hide_empty - Default is true. Will not return empty terms, which means
* terms whose count is 0 according to the given taxonomy.
*
* exclude - Default is an empty string. A comma- or space-delimited string
* of term ids to exclude from the return array. If 'include' is non-empty,
* 'exclude' is ignored.
*
* exclude_tree - A comma- or space-delimited string of term ids to exclude
* from the return array, along with all of their descendant terms according to
* the primary taxonomy. If 'include' is non-empty, 'exclude_tree' is ignored.
*
* include - Default is an empty string. A comma- or space-delimited string
* of term ids to include in the return array.
*
* number - The maximum number of terms to return. Default is empty.
*
* offset - The number by which to offset the terms query.
*
* fields - Default is 'all', which returns an array of term objects.
* If 'fields' is 'ids' or 'names', returns an array of
* integers or strings, respectively.
*
* slug - Returns terms whose "slug" matches this value. Default is empty string.
*
* hierarchical - Whether to include terms that have non-empty descendants
* (even if 'hide_empty' is set to true).
*
* search - Returned terms' names will contain the value of 'search',
* case-insensitive. Default is an empty string.
*
* name__like - Returned terms' names will begin with the value of 'name__like',
* case-insensitive. Default is empty string.
*
* The argument 'pad_counts', if set to true will include the quantity of a term's
* children in the quantity of each term's "count" object variable.
*
* The 'get' argument, if set to 'all' instead of its default empty string,
* returns terms regardless of ancestry or whether the terms are empty.
*
* The 'child_of' argument, when used, should be set to the integer of a term ID. Its default
* is 0. If set to a non-zero value, all returned terms will be descendants
* of that term according to the given taxonomy. Hence 'child_of' is set to 0
* if more than one taxonomy is passed in $taxonomies, because multiple taxonomies
* make term ancestry ambiguous.
*
* The 'parent' argument, when used, should be set to the integer of a term ID. Its default is
* the empty string '', which has a different meaning from the integer 0.
* If set to an integer value, all returned terms will have as an immediate
* ancestor the term whose ID is specified by that integer according to the given taxonomy.
* The 'parent' argument is different from 'child_of' in that a term X is considered a 'parent'
* of term Y only if term X is the father of term Y, not its grandfather or great-grandfather, etc.
*
* @package WordPress
* @subpackage Taxonomy
* @since 2.3.0
*
* @uses $wpdb
* @uses wp_parse_args() Merges the defaults with those defined by $args and allows for strings.
*
* @param string|array 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 &get_terms($taxonomies, $args = '') {
global $wpdb;
$empty_array = array();
$single_taxonomy = false;
if ( !is_array($taxonomies) ) {
$single_taxonomy = true;
$taxonomies = array($taxonomies);
}
foreach ( (array) $taxonomies as $taxonomy ) {
if ( ! is_taxonomy($taxonomy) )
return new WP_Error('invalid_taxonomy', __('Invalid Taxonomy'));
}
$in_taxonomies = "'" . implode("', '", $taxonomies) . "'";
$defaults = array('orderby' => 'name', 'order' => 'ASC',
'hide_empty' => true, 'exclude' => '', 'exclude_tree' => '', 'include' => '',
'number' => '', 'fields' => 'all', 'slug' => '', 'parent' => '',
'hierarchical' => true, 'child_of' => 0, 'get' => '', 'name__like' => '',
'pad_counts' => false, 'offset' => '', 'search' => '');
$args = wp_parse_args( $args, $defaults );
$args['number'] = absint( $args['number'] );
$args['offset'] = absint( $args['offset'] );
if ( !$single_taxonomy || !is_taxonomy_hierarchical($taxonomies[0]) ||
'' != $args['parent'] ) {
$args['child_of'] = 0;
$args['hierarchical'] = false;
$args['pad_counts'] = false;
}
if ( 'all' == $args['get'] ) {
$args['child_of'] = 0;
$args['hide_empty'] = 0;
$args['hierarchical'] = false;
$args['pad_counts'] = false;
}
extract($args, EXTR_SKIP);
if ( $child_of ) {
$hierarchy = _get_term_hierarchy($taxonomies[0]);
if ( !isset($hierarchy[$child_of]) )
return $empty_array;
}
if ( $parent ) {
$hierarchy = _get_term_hierarchy($taxonomies[0]);
if ( !isset($hierarchy[$parent]) )
return $empty_array;
}
// $args can be whatever, only use the args defined in defaults to compute the key
$filter_key = ( has_filter('list_terms_exclusions') ) ? serialize($GLOBALS['wp_filter']['list_terms_exclusions']) : '';
$key = md5( serialize( compact(array_keys($defaults)) ) . serialize( $taxonomies ) . $filter_key );
$last_changed = wp_cache_get('last_changed', 'terms');
if ( !$last_changed ) {
$last_changed = time();
wp_cache_set('last_changed', $last_changed, 'terms');
}
$cache_key = "get_terms:$key:$last_changed";
if ( $cache = wp_cache_get( $cache_key, 'terms' ) ) {
$terms = apply_filters('get_terms', $cache, $taxonomies, $args);
return $terms;
}
if ( 'count' == $orderby )
$orderby = 'tt.count';
else if ( 'name' == $orderby )
$orderby = 't.name';
else if ( 'slug' == $orderby )
$orderby = 't.slug';
else if ( 'term_group' == $orderby )
$orderby = 't.term_group';
else
$orderby = 't.term_id';
$where = '';
$inclusions = '';
if ( !empty($include) ) {
$exclude = '';
$exclude_tree = '';
$interms = preg_split('/[\s,]+/',$include);
if ( count($interms) ) {
foreach ( (array) $interms as $interm ) {
if (empty($inclusions))
$inclusions = ' AND ( t.term_id = ' . intval($interm) . ' ';
else
$inclusions .= ' OR t.term_id = ' . intval($interm) . ' ';
}
}
}
if ( !empty($inclusions) )
$inclusions .= ')';
$where .= $inclusions;
$exclusions = '';
if ( ! empty( $exclude_tree ) ) {
$excluded_trunks = preg_split('/[\s,]+/',$exclude_tree);
foreach( (array) $excluded_trunks as $extrunk ) {
$excluded_children = (array) get_terms($taxonomies[0], array('child_of' => intval($extrunk), 'fields' => 'ids'));
$excluded_children[] = $extrunk;
foreach( (array) $excluded_children as $exterm ) {
if ( empty($exclusions) )
$exclusions = ' AND ( t.term_id <> ' . intval($exterm) . ' ';
else
$exclusions .= ' AND t.term_id <> ' . intval($exterm) . ' ';
}
}
}
if ( !empty($exclude) ) {
$exterms = preg_split('/[\s,]+/',$exclude);
if ( count($exterms) ) {
foreach ( (array) $exterms as $exterm ) {
if ( empty($exclusions) )
$exclusions = ' AND ( t.term_id <> ' . intval($exterm) . ' ';
else
$exclusions .= ' AND t.term_id <> ' . intval($exterm) . ' ';
}
}
}
if ( !empty($exclusions) )
$exclusions .= ')';
$exclusions = apply_filters('list_terms_exclusions', $exclusions, $args );
$where .= $exclusions;
if ( !empty($slug) ) {
$slug = sanitize_title($slug);
$where .= " AND t.slug = '$slug'";
}
if ( !empty($name__like) )
$where .= " AND t.name LIKE '{$name__like}%'";
if ( '' != $parent ) {
$parent = (int) $parent;
$where .= " AND tt.parent = '$parent'";
}
if ( $hide_empty && !$hierarchical )
$where .= ' AND tt.count > 0';
// don't limit the query results when we have to descend the family tree
if ( ! empty($number) && ! $hierarchical && empty( $child_of ) && '' == $parent ) {
if( $offset )
$limit = 'LIMIT ' . $offset . ',' . $number;
else
$limit = 'LIMIT ' . $number;
} else
$limit = '';
if ( !empty($search) ) {
$search = like_escape($search);
$where .= " AND (t.name LIKE '%$search%')";
}
$select_this = '';
if ( 'all' == $fields )
$select_this = 't.*, tt.*';
else if ( 'ids' == $fields )
$select_this = 't.term_id, tt.parent, tt.count';
else if ( 'names' == $fields )
$select_this = 't.term_id, tt.parent, tt.count, t.name';
$query = "SELECT $select_this FROM $wpdb->terms AS t INNER JOIN $wpdb->term_taxonomy AS tt ON t.term_id = tt.term_id WHERE tt.taxonomy IN ($in_taxonomies) $where ORDER BY $orderby $order $limit";
$terms = $wpdb->get_results($query);
if ( 'all' == $fields ) {
update_term_cache($terms);
}
if ( empty($terms) ) {
$cache[ $key ] = array();
wp_cache_set( 'get_terms', $cache, 'terms' );
$terms = apply_filters('get_terms', array(), $taxonomies, $args);
return $terms;
}
if ( $child_of ) {
$children = _get_term_hierarchy($taxonomies[0]);
if ( ! empty($children) )
$terms = & _get_term_children($child_of, $terms, $taxonomies[0]);
}
// Update term counts to include children.
if ( $pad_counts && 'all' == $fields )
_pad_term_counts($terms, $taxonomies[0]);
// Make sure we show empty categories that have children.
if ( $hierarchical && $hide_empty && is_array($terms) ) {
foreach ( $terms as $k => $term ) {
if ( ! $term->count ) {
$children = _get_term_children($term->term_id, $terms, $taxonomies[0]);
if( is_array($children) )
foreach ( $children as $child )
if ( $child->count )
continue 2;
// It really is empty
unset($terms[$k]);
}
}
}
reset ( $terms );
$_terms = array();
if ( 'ids' == $fields ) {
while ( $term = array_shift($terms) )
$_terms[] = $term->term_id;
$terms = $_terms;
} elseif ( 'names' == $fields ) {
while ( $term = array_shift($terms) )
$_terms[] = $term->name;
$terms = $_terms;
}
if ( 0 < $number && intval(@count($terms)) > $number ) {
$terms = array_slice($terms, $offset, $number);
}
wp_cache_add( $cache_key, $terms, 'terms' );
$terms = apply_filters('get_terms', $terms, $taxonomies, $args);
return $terms;
}
/**
* Check if Term exists.
*
* Returns the index of a defined term, or 0 (false) if the term doesn't exist.
*
* @package WordPress
* @subpackage Taxonomy
* @since 2.3.0
*
* @uses $wpdb
*
* @param int|string $term The term to check
* @param string $taxonomy The taxonomy name to use
* @return mixed Get the term id or Term Object, if exists.
*/
function is_term($term, $taxonomy = '') {
global $wpdb;
$select = "SELECT term_id FROM $wpdb->terms as t WHERE ";
$tax_select = "SELECT tt.term_id, tt.term_taxonomy_id FROM $wpdb->terms AS t INNER JOIN $wpdb->term_taxonomy as tt ON tt.term_id = t.term_id WHERE ";
if ( is_int($term) ) {
if ( 0 == $term )
return 0;
$where = 't.term_id = %d';
if ( !empty($taxonomy) )
return $wpdb->get_row( $wpdb->prepare( $tax_select . $where . " AND tt.taxonomy = %s", $term, $taxonomy ), ARRAY_A );
else
return $wpdb->get_var( $wpdb->prepare( $select . $where, $term ) );
}
if ( '' === $slug = sanitize_title($term) )
return 0;
$where = 't.slug = %s';
$else_where = 't.name = %s';
if ( !empty($taxonomy) ) {
if ( $result = $wpdb->get_row( $wpdb->prepare("SELECT tt.term_id, tt.term_taxonomy_id FROM $wpdb->terms AS t INNER JOIN $wpdb->term_taxonomy as tt ON tt.term_id = t.term_id WHERE $where AND tt.taxonomy = %s", $slug, $taxonomy), ARRAY_A) )
return $result;
return $wpdb->get_row( $wpdb->prepare("SELECT tt.term_id, tt.term_taxonomy_id FROM $wpdb->terms AS t INNER JOIN $wpdb->term_taxonomy as tt ON tt.term_id = t.term_id WHERE $else_where AND tt.taxonomy = %s", $term, $taxonomy), ARRAY_A);
}
if ( $result = $wpdb->get_var( $wpdb->prepare("SELECT term_id FROM $wpdb->terms as t WHERE $where", $slug) ) )
return $result;
return $wpdb->get_var( $wpdb->prepare("SELECT term_id FROM $wpdb->terms as t WHERE $else_where", $term) );
}
/**
* Sanitize Term all fields.
*
* Relys on sanitize_term_field() to sanitize the term. The difference is that
* this function will sanitize all fields. The context is based
* on sanitize_term_field().
*
* The $term is expected to be either an array or an object.
*
* @package WordPress
* @subpackage Taxonomy
* @since 2.3.0
*
* @uses sanitize_term_field Used to sanitize all fields in a term
*
* @param array|object $term The term to check
* @param string $taxonomy The taxonomy name to use
* @param string $context Default is 'display'.
* @return array|object Term with all fields sanitized
*/
function sanitize_term($term, $taxonomy, $context = 'display') {
if ( 'raw' == $context )
return $term;
$fields = array('term_id', 'name', 'description', 'slug', 'count', 'parent', 'term_group');
$do_object = false;
if ( is_object($term) )
$do_object = true;
$term_id = $do_object ? $term->term_id : (isset($term['term_id']) ? $term['term_id'] : 0);
foreach ( (array) $fields as $field ) {
if ( $do_object ) {
if ( isset($term->$field) )
$term->$field = sanitize_term_field($field, $term->$field, $term_id, $taxonomy, $context);
} else {
if ( isset($term[$field]) )
$term[$field] = sanitize_term_field($field, $term[$field], $term_id, $taxonomy, $context);
}
}
if ( $do_object )
$term->filter = $context;
else
$term['filter'] = $context;
return $term;
}
/**
* Cleanse the field value in the term based on the context.
*
* Passing a term field value through the function should be assumed to have
* cleansed the value for whatever context the term field is going to be used.
*
* If no context or an unsupported context is given, then default filters will
* be applied.
*
* There are enough filters for each context to support a custom filtering
* without creating your own filter function. Simply create a function that
* hooks into the filter you need.
*
* @package WordPress
* @subpackage Taxonomy
* @since 2.3.0
*
* @uses $wpdb
*
* @param string $field Term field to sanitize
* @param string $value Search for this term value
* @param int $term_id Term ID
* @param string $taxonomy Taxonomy Name
* @param string $context Either edit, db, display, attribute, or js.
* @return mixed sanitized field
*/
function sanitize_term_field($field, $value, $term_id, $taxonomy, $context) {
if ( 'parent' == $field || 'term_id' == $field || 'count' == $field || 'term_group' == $field ) {
$value = (int) $value;
if ( $value < 0 )
$value = 0;
}
if ( 'raw' == $context )
return $value;
if ( 'edit' == $context ) {
$value = apply_filters("edit_term_$field", $value, $term_id, $taxonomy);
$value = apply_filters("edit_${taxonomy}_$field", $value, $term_id);
if ( 'description' == $field )
$value = format_to_edit($value);
else
$value = attribute_escape($value);
} else if ( 'db' == $context ) {
$value = apply_filters("pre_term_$field", $value, $taxonomy);
$value = apply_filters("pre_${taxonomy}_$field", $value);
// Back compat filters
if ( 'slug' == $field )
$value = apply_filters('pre_category_nicename', $value);
} else if ( 'rss' == $context ) {
$value = apply_filters("term_${field}_rss", $value, $taxonomy);
$value = apply_filters("${taxonomy}_${field}_rss", $value);
} else {
// Use display filters by default.
$value = apply_filters("term_$field", $value, $term_id, $taxonomy, $context);
$value = apply_filters("${taxonomy}_$field", $value, $term_id, $context);
}
if ( 'attribute' == $context )
$value = attribute_escape($value);
else if ( 'js' == $context )
$value = js_escape($value);
return $value;
}
/**
* Count how many terms are in Taxonomy.
*
* Default $args is 'ignore_empty' which can be 'ignore_empty=true'
* or array('ignore_empty' => true);.
*
* @package WordPress
* @subpackage Taxonomy
* @since 2.3.0
*
* @uses $wpdb
* @uses wp_parse_args() Turns strings into arrays and merges defaults into an array.
*
* @param string $taxonomy Taxonomy name
* @param array|string $args Overwrite defaults
* @return int How many terms are in $taxonomy
*/
function wp_count_terms( $taxonomy, $args = array() ) {
global $wpdb;
$defaults = array('ignore_empty' => false);
$args = wp_parse_args($args, $defaults);
extract($args, EXTR_SKIP);
$where = '';
if ( $ignore_empty )
$where = 'AND count > 0';
return $wpdb->get_var( $wpdb->prepare("SELECT COUNT(*) FROM $wpdb->term_taxonomy WHERE taxonomy = %s $where", $taxonomy) );
}
/**
* Will unlink the term from the taxonomy.
*
* Will remove the term's relationship to the taxonomy, not the term or taxonomy
* itself. The term and taxonomy will still exist. Will require the term's
* object ID to perform the operation.
*
* @package WordPress
* @subpackage Taxonomy
* @since 2.3.0
* @uses $wpdb
*
* @param int $object_id The term Object Id that refers to the term
* @param string|array $taxonomy List of Taxonomy Names or single Taxonomy name.
*/
function wp_delete_object_term_relationships( $object_id, $taxonomies ) {
global $wpdb;
$object_id = (int) $object_id;
if ( !is_array($taxonomies) )
$taxonomies = array($taxonomies);
foreach ( (array) $taxonomies as $taxonomy ) {
$tt_ids = wp_get_object_terms($object_id, $taxonomy, 'fields=tt_ids');
$in_tt_ids = "'" . implode("', '", $tt_ids) . "'";
$wpdb->query( $wpdb->prepare("DELETE FROM $wpdb->term_relationships WHERE object_id = %d AND term_taxonomy_id IN ($in_tt_ids)", $object_id) );
wp_update_term_count($tt_ids, $taxonomy);
}
}
/**
* Removes a term from the database.
*
* If the term is a parent of other terms, then the children will be updated to
* that term's parent.
*
* The $args 'default' will only override the terms found, if there is only one
* term found. Any other and the found terms are used.
*
* @package WordPress
* @subpackage Taxonomy
* @since 2.3.0
*
* @uses $wpdb
* @uses do_action() Calls both 'delete_term' and 'delete_$taxonomy' action
* hooks, passing term object, term id. 'delete_term' gets an additional
* parameter with the $taxonomy parameter.
*
* @param int $term 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 wp_delete_term( $term, $taxonomy, $args = array() ) {
global $wpdb;
$term = (int) $term;
if ( ! $ids = is_term($term, $taxonomy) )
return false;
if ( is_wp_error( $ids ) )
return $ids;
$tt_id = $ids['term_taxonomy_id'];
$defaults = array();
$args = wp_parse_args($args, $defaults);
extract($args, EXTR_SKIP);
if ( isset($default) ) {
$default = (int) $default;
if ( ! is_term($default, $taxonomy) )
unset($default);
}
// Update children to point to new parent
if ( is_taxonomy_hierarchical($taxonomy) ) {
$term_obj = get_term($term, $taxonomy);
if ( is_wp_error( $term_obj ) )
return $term_obj;
$parent = $term_obj->parent;
$wpdb->update( $wpdb->term_taxonomy, compact( 'parent' ), array( 'parent' => $term_obj->term_id) + compact( 'taxonomy' ) );
}
$objects = $wpdb->get_col( $wpdb->prepare( "SELECT object_id FROM $wpdb->term_relationships WHERE term_taxonomy_id = %d", $tt_id ) );
foreach ( (array) $objects as $object ) {
$terms = wp_get_object_terms($object, $taxonomy, 'fields=ids');
if ( 1 == count($terms) && isset($default) )
$terms = array($default);
else
$terms = array_diff($terms, array($term));
$terms = array_map('intval', $terms);
wp_set_object_terms($object, $terms, $taxonomy);
}
$wpdb->query( $wpdb->prepare( "DELETE FROM $wpdb->term_taxonomy WHERE term_taxonomy_id = %d", $tt_id ) );
// Delete the term if no taxonomies use it.
if ( !$wpdb->get_var( $wpdb->prepare( "SELECT COUNT(*) FROM $wpdb->term_taxonomy WHERE term_id = %d", $term) ) )
$wpdb->query( $wpdb->prepare( "DELETE FROM $wpdb->terms WHERE term_id = %d", $term) );
clean_term_cache($term, $taxonomy);
do_action('delete_term', $term, $tt_id, $taxonomy);
do_action("delete_$taxonomy", $term, $tt_id);
return true;
}
/**
* Retrieves the terms associated with the given object(s), in the supplied taxonomies.
*
* The following information has to do the $args parameter and for what can be
* contained in the string or array of that parameter, if it exists.
*
* The first argument is called, 'orderby' and has the default value of 'name'.
* The other value that is supported is 'count'.
*
* The second argument is called, 'order' and has the default value of 'ASC'.
* The only other value that will be acceptable is 'DESC'.
*
* The final argument supported is called, 'fields' and has the default value of
* 'all'. There are multiple other options that can be used instead. Supported
* values are as follows: 'all', 'ids', 'names', and finally
* 'all_with_object_id'.
*
* The fields argument also decides what will be returned. If 'all' or
* 'all_with_object_id' is choosen or the default kept intact, then all matching
* terms objects will be returned. If either 'ids' or 'names' is used, then an
* array of all matching term ids or term names will be returned respectively.
*
* @package WordPress
* @subpackage Taxonomy
* @since 2.3.0
* @uses $wpdb
*
* @param int|array $object_id The id 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 $taxonomy does not exist.
*/
function wp_get_object_terms($object_ids, $taxonomies, $args = array()) {
global $wpdb;
if ( !is_array($taxonomies) )
$taxonomies = array($taxonomies);
foreach ( (array) $taxonomies as $taxonomy ) {
if ( ! is_taxonomy($taxonomy) )
return new WP_Error('invalid_taxonomy', __('Invalid Taxonomy'));
}
if ( !is_array($object_ids) )
$object_ids = array($object_ids);
$object_ids = array_map('intval', $object_ids);
$defaults = array('orderby' => 'name', 'order' => 'ASC', 'fields' => 'all');
$args = wp_parse_args( $args, $defaults );
$terms = array();
if ( count($taxonomies) > 1 ) {
foreach ( $taxonomies as $index => $taxonomy ) {
$t = get_taxonomy($taxonomy);
if ( isset($t->args) && is_array($t->args) && $args != array_merge($args, $t->args) ) {
unset($taxonomies[$index]);
$terms = array_merge($terms, wp_get_object_terms($object_ids, $taxonomy, array_merge($args, $t->args)));
}
}
} else {
$t = get_taxonomy($taxonomies[0]);
if ( isset($t->args) && is_array($t->args) )
$args = array_merge($args, $t->args);
}
extract($args, EXTR_SKIP);
if ( 'count' == $orderby )
$orderby = 'tt.count';
else if ( 'name' == $orderby )
$orderby = 't.name';
else if ( 'slug' == $orderby )
$orderby = 't.slug';
else if ( 'term_group' == $orderby )
$orderby = 't.term_group';
else if ( 'term_order' == $orderby )
$orderby = 'tr.term_order';
else
$orderby = 't.term_id';
$taxonomies = "'" . implode("', '", $taxonomies) . "'";
$object_ids = implode(', ', $object_ids);
$select_this = '';
if ( 'all' == $fields )
$select_this = 't.*, tt.*';
else if ( 'ids' == $fields )
$select_this = 't.term_id';
else if ( 'names' == $fields )
$select_this = 't.name';
else if ( 'all_with_object_id' == $fields )
$select_this = 't.*, tt.*, tr.object_id';
$query = "SELECT $select_this FROM $wpdb->terms AS t INNER JOIN $wpdb->term_taxonomy AS tt ON tt.term_id = t.term_id INNER JOIN $wpdb->term_relationships AS tr ON tr.term_taxonomy_id = tt.term_taxonomy_id WHERE tt.taxonomy IN ($taxonomies) AND tr.object_id IN ($object_ids) ORDER BY $orderby $order";
if ( 'all' == $fields || 'all_with_object_id' == $fields ) {
$terms = array_merge($terms, $wpdb->get_results($query));
update_term_cache($terms);
} else if ( 'ids' == $fields || 'names' == $fields ) {
$terms = array_merge($terms, $wpdb->get_col($query));
} else if ( 'tt_ids' == $fields ) {
$terms = $wpdb->get_col("SELECT tr.term_taxonomy_id FROM $wpdb->term_relationships AS tr INNER JOIN $wpdb->term_taxonomy AS tt ON tr.term_taxonomy_id = tt.term_taxonomy_id WHERE tr.object_id IN ($object_ids) AND tt.taxonomy IN ($taxonomies) ORDER BY tr.term_taxonomy_id $order");
}
if ( ! $terms )
return array();
return $terms;
}
/**
* Adds a new term to the database. Optionally marks it as an alias of an existing term.
*
* Error handling is assigned for the nonexistance of the $taxonomy and $term
* parameters before inserting. If both the term id and taxonomy exist
* previously, then an array will be returned that contains the term id and the
* contents of what is returned. The keys of the array are 'term_id' and
* 'term_taxonomy_id' containing numeric values.
*
* It is assumed that the term does not yet exist or the above will apply. The
* term will be first added to the term table and then related to the taxonomy
* if everything is well. If everything is correct, then several actions will be
* run prior to a filter and then several actions will be run after the filter
* is run.
*
* The arguments decide how the term is handled based on the $args parameter.
* The following is a list of the available overrides and the defaults.
*
* 'alias_of'. There is no default, but if added, expected is the slug that the
* term will be an alias of. Expected to be a string.
*
* 'description'. There is no default. If exists, will be added to the database
* along with the term. Expected to be a string.
*
* 'parent'. Expected to be numeric and default is 0 (zero). Will assign value
* of 'parent' to the term.
*
* 'slug'. Expected to be a string. There is no default.
*
* If 'slug' argument exists then the slug will be checked to see if it is not
* a valid term. If that check succeeds (it is not a valid term), then it is
* added and the term id is given. If it fails, then a check is made to whether
* the taxonomy is hierarchical and the parent argument is not empty. If the
* second check succeeds, the term will be inserted and the term id will be
* given.
*
* @package WordPress
* @subpackage Taxonomy
* @since 2.3.0
* @uses $wpdb
*
* @uses do_action() Calls 'create_term' hook with the term id and taxonomy id as parameters.
* @uses do_action() Calls 'create_$taxonomy' hook with term id and taxonomy id as parameters.
* @uses apply_filters() Calls 'term_id_filter' hook with term id and taxonomy id as parameters.
* @uses do_action() Calls 'created_term' hook with the term id and taxonomy id as parameters.
* @uses do_action() Calls 'created_$taxonomy' hook with term id and taxonomy id as parameters.
*
* @param int|string $term The term to add or update.
* @param string $taxonomy The taxonomy to which to add the term
* @param array|string $args Change the values of the inserted term
* @return array|WP_Error The Term ID and Term Taxonomy ID
*/
function wp_insert_term( $term, $taxonomy, $args = array() ) {
global $wpdb;
if ( ! is_taxonomy($taxonomy) )
return new WP_Error('invalid_taxonomy', __('Invalid taxonomy'));
if ( is_int($term) && 0 == $term )
return new WP_Error('invalid_term_id', __('Invalid term ID'));
if ( '' == trim($term) )
return new WP_Error('empty_term_name', __('A name is required for this term'));
$defaults = array( 'alias_of' => '', 'description' => '', 'parent' => 0, 'slug' => '');
$args = wp_parse_args($args, $defaults);
$args['name'] = $term;
$args['taxonomy'] = $taxonomy;
$args = sanitize_term($args, $taxonomy, 'db');
extract($args, EXTR_SKIP);
// expected_slashed ($name)
$name = stripslashes($name);
$description = stripslashes($description);
if ( empty($slug) )
$slug = sanitize_title($name);
$term_group = 0;
if ( $alias_of ) {
$alias = $wpdb->get_row( $wpdb->prepare( "SELECT term_id, term_group FROM $wpdb->terms WHERE slug = %s", $alias_of) );
if ( $alias->term_group ) {
// The alias we want is already in a group, so let's use that one.
$term_group = $alias->term_group;
} else {
// The alias isn't in a group, so let's create a new one and firstly add the alias term to it.
$term_group = $wpdb->get_var("SELECT MAX(term_group) FROM $wpdb->terms") + 1;
$wpdb->query( $wpdb->prepare( "UPDATE $wpdb->terms SET term_group = %d WHERE term_id = %d", $term_group, $alias->term_id ) );
}
}
if ( ! $term_id = is_term($slug) ) {
if ( false === $wpdb->insert( $wpdb->terms, compact( 'name', 'slug', 'term_group' ) ) )
return new WP_Error('db_insert_error', __('Could not insert term into the database'), $wpdb->last_error);
$term_id = (int) $wpdb->insert_id;
} else if ( is_taxonomy_hierarchical($taxonomy) && !empty($parent) ) {
// If the taxonomy supports hierarchy and the term has a parent, make the slug unique
// by incorporating parent slugs.
$slug = wp_unique_term_slug($slug, (object) $args);
if ( false === $wpdb->insert( $wpdb->terms, compact( 'name', 'slug', 'term_group' ) ) )
return new WP_Error('db_insert_error', __('Could not insert term into the database'), $wpdb->last_error);
$term_id = (int) $wpdb->insert_id;
}
if ( empty($slug) ) {
$slug = sanitize_title($slug, $term_id);
$wpdb->update( $wpdb->terms, compact( 'slug' ), compact( 'term_id' ) );
}
$tt_id = $wpdb->get_var( $wpdb->prepare( "SELECT tt.term_taxonomy_id FROM $wpdb->term_taxonomy AS tt INNER JOIN $wpdb->terms AS t ON tt.term_id = t.term_id WHERE tt.taxonomy = %s AND t.term_id = %d", $taxonomy, $term_id ) );
if ( !empty($tt_id) )
return array('term_id' => $term_id, 'term_taxonomy_id' => $tt_id);
$wpdb->insert( $wpdb->term_taxonomy, compact( 'term_id', 'taxonomy', 'description', 'parent') + array( 'count' => 0 ) );
$tt_id = (int) $wpdb->insert_id;
do_action("create_term", $term_id, $tt_id);
do_action("create_$taxonomy", $term_id, $tt_id);
$term_id = apply_filters('term_id_filter', $term_id, $tt_id);
clean_term_cache($term_id, $taxonomy);
do_action("created_term", $term_id, $tt_id);
do_action("created_$taxonomy", $term_id, $tt_id);
return array('term_id' => $term_id, 'term_taxonomy_id' => $tt_id);
}
/**
* Create Term and Taxonomy Relationships.
*
* Relates an object (post, link etc) to a term and taxonomy type. Creates the
* term and taxonomy relationship if it doesn't already exist. Creates a term if
* it doesn't exist (using the slug).
*
* A relationship means that the term is grouped in or belongs to the taxonomy.
* A term has no meaning until it is given context by defining which taxonomy it
* exists under.
*
* @package WordPress
* @subpackage Taxonomy
* @since 2.3.0
* @uses $wpdb
*
* @param int $object_id The object to relate to.
* @param array|int|string $term The slug or id of the term.
* @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 wp_set_object_terms($object_id, $terms, $taxonomy, $append = false) {
global $wpdb;
$object_id = (int) $object_id;
if ( ! is_taxonomy($taxonomy) )
return new WP_Error('invalid_taxonomy', __('Invalid Taxonomy'));
if ( !is_array($terms) )
$terms = array($terms);
if ( ! $append )
$old_tt_ids = wp_get_object_terms($object_id, $taxonomy, 'fields=tt_ids');
$tt_ids = array();
$term_ids = array();
foreach ( (array) $terms as $term) {
if ( !strlen(trim($term)) )
continue;
if ( !$term_info = is_term($term, $taxonomy) )
$term_info = wp_insert_term($term, $taxonomy);
if ( is_wp_error($term_info) )
return $term_info;
$term_ids[] = $term_info['term_id'];
$tt_id = $term_info['term_taxonomy_id'];
$tt_ids[] = $tt_id;
if ( $wpdb->get_var( $wpdb->prepare( "SELECT term_taxonomy_id FROM $wpdb->term_relationships WHERE object_id = %d AND term_taxonomy_id = %d", $object_id, $tt_id ) ) )
continue;
$wpdb->insert( $wpdb->term_relationships, array( 'object_id' => $object_id, 'term_taxonomy_id' => $tt_id ) );
}
wp_update_term_count($tt_ids, $taxonomy);
if ( ! $append ) {
$delete_terms = array_diff($old_tt_ids, $tt_ids);
if ( $delete_terms ) {
$in_delete_terms = "'" . implode("', '", $delete_terms) . "'";
$wpdb->query( $wpdb->prepare("DELETE FROM $wpdb->term_relationships WHERE object_id = %d AND term_taxonomy_id IN ($in_delete_terms)", $object_id) );
wp_update_term_count($delete_terms, $taxonomy);
}
}
$t = get_taxonomy($taxonomy);
if ( ! $append && isset($t->sort) && $t->sort ) {
$values = array();
$term_order = 0;
$final_tt_ids = wp_get_object_terms($object_id, $taxonomy, 'fields=tt_ids');
foreach ( $tt_ids as $tt_id )
if ( in_array($tt_id, $final_tt_ids) )
$values[] = $wpdb->prepare( "(%d, %d, %d)", $object_id, $tt_id, ++$term_order);
if ( $values )
$wpdb->query("INSERT INTO $wpdb->term_relationships (object_id, term_taxonomy_id, term_order) VALUES " . join(',', $values) . " ON DUPLICATE KEY UPDATE term_order = VALUES(term_order)");
}
return $tt_ids;
}
/**
* Will make slug unique, if it isn't already.
*
* The $slug has to be unique global to every taxonomy, meaning that one
* taxonomy term can't have a matching slug with another taxonomy term. Each
* slug has to be globally unique for every taxonomy.
*
* The way this works is that if the taxonomy that the term belongs to is
* heirarchical and has a parent, it will append that parent to the $slug.
*
* If that still doesn't return an unique slug, then it try to append a number
* until it finds a number that is truely unique.
*
* The only purpose for $term is for appending a parent, if one exists.
*
* @package WordPress
* @subpackage Taxonomy
* @since 2.3.0
* @uses $wpdb
*
* @param string $slug The string that will be tried for a unique slug
* @param object $term The term object that the $slug will belong too
* @return string Will return a true unique slug.
*/
function wp_unique_term_slug($slug, $term) {
global $wpdb;
// If the taxonomy supports hierarchy and the term has a parent, make the slug unique
// by incorporating parent slugs.
if ( is_taxonomy_hierarchical($term->taxonomy) && !empty($term->parent) ) {
$the_parent = $term->parent;
while ( ! empty($the_parent) ) {
$parent_term = get_term($the_parent, $term->taxonomy);
if ( is_wp_error($parent_term) || empty($parent_term) )
break;
$slug .= '-' . $parent_term->slug;
if ( empty($parent_term->parent) )
break;
$the_parent = $parent_term->parent;
}
}
// If we didn't get a unique slug, try appending a number to make it unique.
if ( !empty($args['term_id']) )
$query = $wpdb->prepare( "SELECT slug FROM $wpdb->terms WHERE slug = %s AND term_id != %d", $slug, $args['term_id'] );
else
$query = $wpdb->prepare( "SELECT slug FROM $wpdb->terms WHERE slug = %s", $slug );
if ( $wpdb->get_var( $query ) ) {
$num = 2;
do {
$alt_slug = $slug . "-$num";
$num++;
$slug_check = $wpdb->get_var( $wpdb->prepare( "SELECT slug FROM $wpdb->terms WHERE slug = %s", $alt_slug ) );
} while ( $slug_check );
$slug = $alt_slug;
}
return $slug;
}
/**
* Update term based on arguments provided.
*
* The $args will indiscriminately override all values with the same field name.
* Care must be taken to not override important information need to update or
* update will fail (or perhaps create a new term, neither would be acceptable).
*
* Defaults will set 'alias_of', 'description', 'parent', and 'slug' if not
* defined in $args already.
*
* 'alias_of' will create a term group, if it doesn't already exist, and update
* it for the $term.
*
* If the 'slug' argument in $args is missing, then the 'name' in $args will be
* used. It should also be noted that if you set 'slug' and it isn't unique then
* a WP_Error will be passed back. If you don't pass any slug, then a unique one
* will be created for you.
*
* For what can be overrode in $args, check the term scheme can contain and stay
* away from the term keys.
*
* @package WordPress
* @subpackage Taxonomy
* @since 2.3.0
*
* @uses $wpdb
* @uses do_action() Will call both 'edit_term' and 'edit_$taxonomy' twice.
* @uses apply_filters() Will call the 'term_id_filter' filter and pass the term
* id and taxonomy id.
*
* @param int $term 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 wp_update_term( $term, $taxonomy, $args = array() ) {
global $wpdb;
if ( ! is_taxonomy($taxonomy) )
return new WP_Error('invalid_taxonomy', __('Invalid taxonomy'));
$term_id = (int) $term;
// First, get all of the original args
$term = get_term ($term_id, $taxonomy, ARRAY_A);
// Escape data pulled from DB.
$term = add_magic_quotes($term);
// Merge old and new args with new args overwriting old ones.
$args = array_merge($term, $args);
$defaults = array( 'alias_of' => '', 'description' => '', 'parent' => 0, 'slug' => '');
$args = wp_parse_args($args, $defaults);
$args = sanitize_term($args, $taxonomy, 'db');
extract($args, EXTR_SKIP);
// expected_slashed ($name)
$name = stripslashes($name);
$description = stripslashes($description);
if ( '' == trim($name) )
return new WP_Error('empty_term_name', __('A name is required for this term'));
$empty_slug = false;
if ( empty($slug) ) {
$empty_slug = true;
$slug = sanitize_title($name);
}
if ( $alias_of ) {
$alias = $wpdb->get_row( $wpdb->prepare( "SELECT term_id, term_group FROM $wpdb->terms WHERE slug = %s", $alias_of) );
if ( $alias->term_group ) {
// The alias we want is already in a group, so let's use that one.
$term_group = $alias->term_group;
} else {
// The alias isn't in a group, so let's create a new one and firstly add the alias term to it.
$term_group = $wpdb->get_var("SELECT MAX(term_group) FROM $wpdb->terms") + 1;
$wpdb->update( $wpdb->terms, compact('term_group'), array( 'term_id' => $alias->term_id ) );
}
}
// Check for duplicate slug
$id = $wpdb->get_var( $wpdb->prepare( "SELECT term_id FROM $wpdb->terms WHERE slug = %s", $slug ) );
if ( $id && ($id != $term_id) ) {
// If an empty slug was passed or the parent changed, reset the slug to something unique.
// Otherwise, bail.
if ( $empty_slug || ( $parent != $term->parent) )
$slug = wp_unique_term_slug($slug, (object) $args);
else
return new WP_Error('duplicate_term_slug', sprintf(__('The slug "%s" is already in use by another term'), $slug));
}
$wpdb->update($wpdb->terms, compact( 'name', 'slug', 'term_group' ), compact( 'term_id' ) );
if ( empty($slug) ) {
$slug = sanitize_title($name, $term_id);
$wpdb->update( $wpdb->terms, compact( 'slug' ), compact( 'term_id' ) );
}
$tt_id = $wpdb->get_var( $wpdb->prepare( "SELECT tt.term_taxonomy_id FROM $wpdb->term_taxonomy AS tt INNER JOIN $wpdb->terms AS t ON tt.term_id = t.term_id WHERE tt.taxonomy = %s AND t.term_id = %d", $taxonomy, $term_id) );
$wpdb->update( $wpdb->term_taxonomy, compact( 'term_id', 'taxonomy', 'description', 'parent' ), array( 'term_taxonomy_id' => $tt_id ) );
do_action("edit_term", $term_id, $tt_id);
do_action("edit_$taxonomy", $term_id, $tt_id);
$term_id = apply_filters('term_id_filter', $term_id, $tt_id);
clean_term_cache($term_id, $taxonomy);
do_action("edited_term", $term_id, $tt_id);
do_action("edited_$taxonomy", $term_id, $tt_id);
return array('term_id' => $term_id, 'term_taxonomy_id' => $tt_id);
}
/**
* Enable or disable term counting.
*
* @since 2.5.0
*
* @param bool $defer Optional. Enable if true, disable if false.
* @return bool Whether term counting is enabled or disabled.
*/
function wp_defer_term_counting($defer=null) {
static $_defer = false;
if ( is_bool($defer) ) {
$_defer = $defer;
// flush any deferred counts
if ( !$defer )
wp_update_term_count( null, null, true );
}
return $_defer;
}
/**
* Updates the amount of terms in taxonomy.
*
* If there is a taxonomy callback applyed, then it will be called for updating
* the count.
*
* The default action is to count what the amount of terms have the relationship
* of term ID. Once that is done, then update the database.
*
* @package WordPress
* @subpackage Taxonomy
* @since 2.3.0
* @uses $wpdb
*
* @param int|array $terms The term_taxonomy_id of the terms
* @param string $taxonomy The context of the term.
* @return bool If no terms will return false, and if successful will return true.
*/
function wp_update_term_count( $terms, $taxonomy, $do_deferred=false ) {
static $_deferred = array();
if ( $do_deferred ) {
foreach ( (array) array_keys($_deferred) as $tax ) {
wp_update_term_count_now( $_deferred[$tax], $tax );
unset( $_deferred[$tax] );
}
}
if ( empty($terms) )
return false;
if ( !is_array($terms) )
$terms = array($terms);
if ( wp_defer_term_counting() ) {
if ( !isset($_deferred[$taxonomy]) )
$_deferred[$taxonomy] = array();
$_deferred[$taxonomy] = array_unique( array_merge($_deferred[$taxonomy], $terms) );
return true;
}
return wp_update_term_count_now( $terms, $taxonomy );
}
/**
* Perform term count update immediately.
*
* @since 2.5.0
*
* @param array $terms The term_taxonomy_id of terms to update.
* @param string $taxonomy The context of the term.
* @return bool Always true when complete.
*/
function wp_update_term_count_now( $terms, $taxonomy ) {
global $wpdb;
$terms = array_map('intval', $terms);
$taxonomy = get_taxonomy($taxonomy);
if ( !empty($taxonomy->update_count_callback) ) {
call_user_func($taxonomy->update_count_callback, $terms);
} else {
// Default count updater
foreach ( (array) $terms as $term) {
$count = $wpdb->get_var( $wpdb->prepare( "SELECT COUNT(*) FROM $wpdb->term_relationships WHERE term_taxonomy_id = %d", $term) );
$wpdb->update( $wpdb->term_taxonomy, compact( 'count' ), array( 'term_taxonomy_id' => $term ) );
}
}
clean_term_cache($terms);
return true;
}
//
// Cache
//
/**
* Removes the taxonomy relationship to terms from the cache.
*
* Will remove the entire taxonomy relationship containing term $object_id. The
* term IDs have to exist within the taxonomy $object_type for the deletion to
* take place.
*
* @package WordPress
* @subpackage Taxonomy
* @since 2.3.0
*
* @see get_object_taxonomies() for more on $object_type
* @uses do_action() Will call action hook named, 'clean_object_term_cache' after completion.
* Passes, function params in same order.
*
* @param int|array $object_ids Single or list of term object ID(s)
* @param array|string $object_type The taxonomy object type
*/
function clean_object_term_cache($object_ids, $object_type) {
if ( !is_array($object_ids) )
$object_ids = array($object_ids);
foreach ( $object_ids as $id )
foreach ( get_object_taxonomies($object_type) as $taxonomy )
wp_cache_delete($id, "{$taxonomy}_relationships");
do_action('clean_object_term_cache', $object_ids, $object_type);
}
/**
* Will remove all of the term ids from the cache.
*
* @package WordPress
* @subpackage Taxonomy
* @since 2.3.0
* @uses $wpdb
*
* @param int|array $ids Single or list of Term IDs
* @param string $taxonomy Can be empty and will assume tt_ids, else will use for context.
*/
function clean_term_cache($ids, $taxonomy = '') {
global $wpdb;
static $cleaned = array();
if ( !is_array($ids) )
$ids = array($ids);
$taxonomies = array();
// If no taxonomy, assume tt_ids.
if ( empty($taxonomy) ) {
$tt_ids = implode(', ', $ids);
$terms = $wpdb->get_results("SELECT term_id, taxonomy FROM $wpdb->term_taxonomy WHERE term_taxonomy_id IN ($tt_ids)");
foreach ( (array) $terms as $term ) {
$taxonomies[] = $term->taxonomy;
wp_cache_delete($term->term_id, $term->taxonomy);
}
$taxonomies = array_unique($taxonomies);
} else {
foreach ( $ids as $id ) {
wp_cache_delete($id, $taxonomy);
}
$taxonomies = array($taxonomy);
}
foreach ( $taxonomies as $taxonomy ) {
if ( isset($cleaned[$taxonomy]) )
continue;
$cleaned[$taxonomy] = true;
wp_cache_delete('all_ids', $taxonomy);
wp_cache_delete('get', $taxonomy);
delete_option("{$taxonomy}_children");
}
wp_cache_set('last_changed', time(), 'terms');
do_action('clean_term_cache', $ids, $taxonomy);
}
/**
* Retrieves the taxonomy relationship to the term object id.
*
* @package WordPress
* @subpackage Taxonomy
* @since 2.3.0
*
* @uses wp_cache_get() Retrieves taxonomy relationship from cache
*
* @param int|array $id Term object ID
* @param string $taxonomy Taxonomy Name
* @return bool|array Empty array if $terms found, but not $taxonomy. False if nothing is in cache for $taxonomy and $id.
*/
function &get_object_term_cache($id, $taxonomy) {
$cache = wp_cache_get($id, "{$taxonomy}_relationships");
return $cache;
}
/**
* Updates the cache for Term ID(s).
*
* Will only update the cache for terms not already cached.
*
* The $object_ids expects that the ids be separated by commas, if it is a
* string.
*
* It should be noted that update_object_term_cache() is very time extensive. It
* is advised that the function is not called very often or at least not for a
* lot of terms that exist in a lot of taxonomies. The amount of time increases
* for each term and it also increases for each taxonomy the term belongs to.
*
* @package WordPress
* @subpackage Taxonomy
* @since 2.3.0
* @uses wp_get_object_terms() Used to get terms from the database to update
*
* @param string|array $object_ids Single or list of term object ID(s)
* @param array|string $object_type The taxonomy object type
* @return null|bool Null value is given with empty $object_ids. False if
*/
function update_object_term_cache($object_ids, $object_type) {
if ( empty($object_ids) )
return;
if ( !is_array($object_ids) )
$object_ids = explode(',', $object_ids);
$object_ids = array_map('intval', $object_ids);
$taxonomies = get_object_taxonomies($object_type);
$ids = array();
foreach ( (array) $object_ids as $id ) {
foreach ( $taxonomies as $taxonomy ) {
if ( false === wp_cache_get($id, "{$taxonomy}_relationships") ) {
$ids[] = $id;
break;
}
}
}
if ( empty( $ids ) )
return false;
$terms = wp_get_object_terms($ids, $taxonomies, 'fields=all_with_object_id');
$object_terms = array();
foreach ( (array) $terms as $term )
$object_terms[$term->object_id][$term->taxonomy][$term->term_id] = $term;
foreach ( $ids as $id ) {
foreach ( $taxonomies as $taxonomy ) {
if ( ! isset($object_terms[$id][$taxonomy]) ) {
if ( !isset($object_terms[$id]) )
$object_terms[$id] = array();
$object_terms[$id][$taxonomy] = array();
}
}
}
foreach ( $object_terms as $id => $value ) {
foreach ( $value as $taxonomy => $terms ) {
wp_cache_set($id, $terms, "{$taxonomy}_relationships");
}
}
}
/**
* Updates Terms to Taxonomy in cache.
*
* @package WordPress
* @subpackage Taxonomy
* @since 2.3.0
*
* @param array $terms List of Term objects to change
* @param string $taxonomy Optional. Update Term to this taxonomy in cache
*/
function update_term_cache($terms, $taxonomy = '') {
foreach ( (array) $terms as $term ) {
$term_taxonomy = $taxonomy;
if ( empty($term_taxonomy) )
$term_taxonomy = $term->taxonomy;
wp_cache_add($term->term_id, $term, $term_taxonomy);
}
}
//
// Private
//
/**
* Retrieves children of taxonomy.
*
* @package WordPress
* @subpackage Taxonomy
* @access private
* @since 2.3.0
*
* @uses update_option() Stores all of the children in "$taxonomy_children"
* option. That is the name of the taxonomy, immediately followed by '_children'.
*
* @param string $taxonomy Taxonomy Name
* @return array Empty if $taxonomy isn't hierarachical or returns children.
*/
function _get_term_hierarchy($taxonomy) {
if ( !is_taxonomy_hierarchical($taxonomy) )
return array();
$children = get_option("{$taxonomy}_children");
if ( is_array($children) )
return $children;
$children = array();
$terms = get_terms($taxonomy, 'get=all');
foreach ( $terms as $term ) {
if ( $term->parent > 0 )
$children[$term->parent][] = $term->term_id;
}
update_option("{$taxonomy}_children", $children);
return $children;
}
/**
* Get the subset of $terms that are descendants of $term_id.
*
* If $terms is an array of objects, then _get_term_children returns an array of objects.
* If $terms is an array of IDs, then _get_term_children returns an array of IDs.
*
* @package WordPress
* @subpackage Taxonomy
* @access private
* @since 2.3.0
*
* @param int $term_id The ancestor term: all returned terms should be descendants of $term_id.
* @param array $terms The set of terms---either an array of term objects or term IDs---from which those that are descendants of $term_id will be chosen.
* @param string $taxonomy The taxonomy which determines the hierarchy of the terms.
* @return array The subset of $terms that are descendants of $term_id.
*/
function &_get_term_children($term_id, $terms, $taxonomy) {
$empty_array = array();
if ( empty($terms) )
return $empty_array;
$term_list = array();
$has_children = _get_term_hierarchy($taxonomy);
if ( ( 0 != $term_id ) && ! isset($has_children[$term_id]) )
return $empty_array;
foreach ( (array) $terms as $term ) {
$use_id = false;
if ( !is_object($term) ) {
$term = get_term($term, $taxonomy);
if ( is_wp_error( $term ) )
return $term;
$use_id = true;
}
if ( $term->term_id == $term_id )
continue;
if ( $term->parent == $term_id ) {
if ( $use_id )
$term_list[] = $term->term_id;
else
$term_list[] = $term;
if ( !isset($has_children[$term->term_id]) )
continue;
if ( $children = _get_term_children($term->term_id, $terms, $taxonomy) )
$term_list = array_merge($term_list, $children);
}
}
return $term_list;
}
/**
* Add count of children to parent count.
*
* Recalculates term counts by including items from child terms. Assumes all
* relevant children are already in the $terms argument.
*
* @package WordPress
* @subpackage Taxonomy
* @access private
* @since 2.3.0
* @uses $wpdb
*
* @param array $terms List of Term IDs
* @param string $taxonomy Term Context
* @return null Will break from function if conditions are not met.
*/
function _pad_term_counts(&$terms, $taxonomy) {
global $wpdb;
// This function only works for post categories.
if ( 'category' != $taxonomy )
return;
$term_hier = _get_term_hierarchy($taxonomy);
if ( empty($term_hier) )
return;
$term_items = array();
foreach ( (array) $terms as $key => $term ) {
$terms_by_id[$term->term_id] = & $terms[$key];
$term_ids[$term->term_taxonomy_id] = $term->term_id;
}
// Get the object and term ids and stick them in a lookup table
$results = $wpdb->get_results("SELECT object_id, term_taxonomy_id FROM $wpdb->term_relationships INNER JOIN $wpdb->posts ON object_id = ID WHERE term_taxonomy_id IN (".join(',', array_keys($term_ids)).") AND post_type = 'post' AND post_status = 'publish'");
foreach ( $results as $row ) {
$id = $term_ids[$row->term_taxonomy_id];
$term_items[$id][$row->object_id] = isset($term_items[$id][$row->object_id]) ? ++$term_items[$id][$row->object_id] : 1;
}
// Touch every ancestor's lookup row for each post in each term
foreach ( $term_ids as $term_id ) {
$child = $term_id;
while ( $parent = $terms_by_id[$child]->parent ) {
if ( !empty($term_items[$term_id]) )
foreach ( $term_items[$term_id] as $item_id => $touches ) {
$term_items[$parent][$item_id] = isset($term_items[$parent][$item_id]) ? ++$term_items[$parent][$item_id]: 1;
}
$child = $parent;
}
}
// Transfer the touched cells
foreach ( (array) $term_items as $id => $items )
if ( isset($terms_by_id[$id]) )
$terms_by_id[$id]->count = count($items);
}
//
// Default callbacks
//
/**
* Will update term count based on posts.
*
* Private function for the default callback for post_tag and category
* taxonomies.
*
* @package WordPress
* @subpackage Taxonomy
* @access private
* @since 2.3.0
* @uses $wpdb
*
* @param array $terms List of Term taxonomy IDs
*/
function _update_post_term_count( $terms ) {
global $wpdb;
foreach ( (array) $terms as $term ) {
$count = $wpdb->get_var( $wpdb->prepare( "SELECT COUNT(*) FROM $wpdb->term_relationships, $wpdb->posts WHERE $wpdb->posts.ID = $wpdb->term_relationships.object_id AND post_status = 'publish' AND post_type = 'post' AND term_taxonomy_id = %d", $term ) );
$wpdb->update( $wpdb->term_taxonomy, compact( 'count' ), array( 'term_taxonomy_id' => $term ) );
}
}
/**
* Generates a permalink for a taxonomy term archive.
*
* @since 2.5.0
*
* @param object|int|string $term
* @param string $taxonomy
* @return string HTML link to taxonomy term archive
*/
function get_term_link( $term, $taxonomy ) {
global $wp_rewrite;
// use legacy functions for core taxonomies until they are fully plugged in
if ( $taxonomy == 'category' )
return get_category_link($term);
if ( $taxonomy == 'post_tag' )
return get_tag_link($term);
$termlink = $wp_rewrite->get_extra_permastruct($taxonomy);
if ( !is_object($term) ) {
if ( is_int($term) ) {
$term = &get_term($term, $taxonomy);
} else {
$term = &get_term_by('slug', $term, $taxonomy);
}
}
if ( is_wp_error( $term ) )
return $term;
$slug = $term->slug;
if ( empty($termlink) ) {
$file = get_option('home') . '/';
$t = get_taxonomy($taxonomy);
if ( $t->query_var )
$termlink = "$file?$t->query_var=$slug";
else
$termlink = "$file?taxonomy=$taxonomy&term=$slug";
} else {
$termlink = str_replace("%$taxonomy%", $slug, $termlink);
$termlink = get_option('home') . user_trailingslashit($termlink, 'category');
}
return apply_filters('term_link', $termlink, $term, $taxonomy);
}
/**
* Display the taxonomies of a post with available options.
*
* This function can be used within the loop to display the taxonomies for a
* post without specifying the Post ID. You can also use it outside the Loop to
* display the taxonomies for a specific post.
*
* The available defaults are:
* 'post' : default is 0. The post ID to get taxonomies of.
* 'before' : default is empty string. Display before taxonomies list.
* 'sep' : default is empty string. Separate every taxonomy with value in this.
* 'after' : default is empty string. Display this after the taxonomies list.
*
* @since 2.5.0
* @uses get_the_taxonomies()
*
* @param array $args Override the defaults.
*/
function the_taxonomies($args = array()) {
$defaults = array(
'post' => 0,
'before' => '',
'sep' => ' ',
'after' => '',
);
$r = wp_parse_args( $args, $defaults );
extract( $r, EXTR_SKIP );
echo $before . join($sep, get_the_taxonomies($post)) . $after;
}
/**
* Retrieve all taxonomies associated with a post.
*
* This function can be used within the loop. It will also return an array of
* the taxonomies with links to the taxonomy and name.
*
* @since 2.5.0
*
* @param int $post Optional. Post ID or will use Global Post ID (in loop).
* @return array
*/
function get_the_taxonomies($post = 0) {
if ( is_int($post) )
$post =& get_post($post);
elseif ( !is_object($post) )
$post =& $GLOBALS['post'];
$taxonomies = array();
if ( !$post )
return $taxonomies;
$template = apply_filters('taxonomy_template', '%s: %l.');
foreach ( get_object_taxonomies($post) as $taxonomy ) {
$t = (array) get_taxonomy($taxonomy);
if ( empty($t['label']) )
$t['label'] = $taxonomy;
if ( empty($t['args']) )
$t['args'] = array();
if ( empty($t['template']) )
$t['template'] = $template;
$terms = get_object_term_cache($post->ID, $taxonomy);
if ( empty($terms) )
$terms = wp_get_object_terms($post->ID, $taxonomy, $t['args']);
$links = array();
foreach ( $terms as $term )
$links[] = "$term->name ";
if ( $links )
$taxonomies[$taxonomy] = wp_sprintf($t['template'], $t['label'], $links, $terms);
}
return $taxonomies;
}
/**
* Retrieve all taxonomies of a post with just the names.
*
* @since 2.5.0
* @uses get_object_taxonomies()
*
* @param int $post Optional. Post ID
* @return array
*/
function get_post_taxonomies($post = 0) {
$post =& get_post($post);
return get_object_taxonomies($post);
}
/**
* Determine if the given object is associated with any of the given terms.
*
* The given terms are checked against the object's terms' term_ids, names and slugs.
* Terms given as integers will only be checked against the object's terms' term_ids.
* If no terms are given, determines if object is associated with any terms in the given taxonomy.
*
* @since 2.7.0
* @uses get_object_term_cache()
* @uses wp_get_object_terms()
*
* @param int $object_id. ID of the object (post ID, link ID, ...)
* @param string $taxonomy. Single taxonomy name
* @param int|string|array $terms Optional. Term term_id, name, slug or array of said
* @return bool|WP_Error. WP_Error on input error.
*/
function is_object_in_term( $object_id, $taxonomy, $terms = null ) {
if ( !$object_id = (int) $object_id )
return new WP_Error( 'invalid_object', __( 'Invalid object ID' ) );
$object_terms = get_object_term_cache( $object_id, $taxonomy );
if ( empty( $object_terms ) )
$object_terms = wp_get_object_terms( $object_id, $taxonomy );
if ( is_wp_error( $object_terms ) )
return $object_terms;
if ( empty( $object_terms ) )
return false;
if ( empty( $terms ) )
return ( !empty( $object_terms ) );
$terms = (array) $terms;
if ( $ints = array_filter( $terms, 'is_int' ) )
$strs = array_diff( $terms, $ints );
else
$strs =& $terms;
foreach ( $object_terms as $object_term ) {
if ( $ints && in_array( $object_term->term_id, $ints ) ) return true; // If int, check against term_id
if ( $strs ) {
if ( in_array( $object_term->term_id, $strs ) ) return true;
if ( in_array( $object_term->name, $strs ) ) return true;
if ( in_array( $object_term->slug, $strs ) ) return true;
}
}
return false;
}
?>
waterwise-wp/wp-includes/general-template.php 0000644 0001033 0000041 00000172556 11126465001 021515 0 ustar robert www-data
' . __('Search for:') . '
';
echo apply_filters('get_search_form', $form);
}
/**
* Display the Log In/Out link.
*
* Displays a link, which allows the user to navigate to the Log In page to log in
* or log out depending on whether or not they are currently logged in.
*
* @since 1.5.0
* @uses apply_filters() Calls 'loginout' hook on HTML link content.
*/
function wp_loginout() {
if ( ! is_user_logged_in() )
$link = '' . __('Log in') . ' ';
else
$link = '' . __('Log out') . ' ';
echo apply_filters('loginout', $link);
}
/**
* Returns the Log Out URL.
*
* Returns the URL that allows the user to log out of the site
*
* @since 2.7
* @uses wp_nonce_url() To protect against CSRF
* @uses site_url() To generate the log in URL
*
* @param string $redirect Path to redirect to on logout.
*/
function wp_logout_url($redirect = '') {
if ( strlen($redirect) )
$redirect = "&redirect_to=$redirect";
return wp_nonce_url( site_url("wp-login.php?action=logout$redirect", 'login'), 'log-out' );
}
/**
* Returns the Log In URL.
*
* Returns the URL that allows the user to log in to the site
*
* @since 2.7
* @uses site_url() To generate the log in URL
*
* @param string $redirect Path to redirect to on login.
*/
function wp_login_url($redirect = '') {
if ( strlen($redirect) )
$redirect = "?redirect_to=$redirect";
return site_url("wp-login.php$redirect", 'login');
}
/**
* Display the Registration or Admin link.
*
* Display a link which allows the user to navigate to the registration page if
* not logged in and registration is enabled or to the dashboard if logged in.
*
* @since 1.5.0
* @uses apply_filters() Calls 'register' hook on register / admin link content.
*
* @param string $before Text to output before the link (defaults to ).
* @param string $after Text to output after the link (defaults to ).
*/
function wp_register( $before = '', $after = ' ' ) {
if ( ! is_user_logged_in() ) {
if ( get_option('users_can_register') )
$link = $before . '' . __('Register') . ' ' . $after;
else
$link = '';
} else {
$link = $before . '' . __('Site Admin') . ' ' . $after;
}
echo apply_filters('register', $link);
}
/**
* Theme container function for the 'wp_meta' action.
*
* The 'wp_meta' action can have several purposes, depending on how you use it,
* but one purpose might have been to allow for theme switching.
*
* @since 1.5.0
* @link http://trac.wordpress.org/ticket/1458 Explanation of 'wp_meta' action.
* @uses do_action() Calls 'wp_meta' hook.
*/
function wp_meta() {
do_action('wp_meta');
}
/**
* Display information about the blog.
*
* @see get_bloginfo() For possible values for the parameter.
* @since 0.71
*
* @param string $show What to display.
*/
function bloginfo($show='') {
echo get_bloginfo($show, 'display');
}
/**
* Retrieve information about the blog.
*
* Some show parameter values are deprecated and will be removed in future
* versions. Care should be taken to check the function contents and know what
* the deprecated blog info options are. Options without "// DEPRECATED" are
* the preferred and recommended ways to get the information.
*
* The possible values for the 'show' parameter are listed below.
*
* url - Blog URI to homepage. wpurl - Blog URI path to WordPress.description - Secondary title
*
* The feed URL options can be retrieved from 'rdf_url' (RSS 0.91),
* 'rss_url' (RSS 1.0), 'rss2_url' (RSS 2.0), or 'atom_url' (Atom feed). The
* comment feeds can be retrieved from the 'comments_atom_url' (Atom comment
* feed) or 'comments_rss2_url' (RSS 2.0 comment feed).
*
* There are many other options and you should check the function contents:
* {@source 32 37}
*
* @since 0.71
*
* @param string $show Blog info to retrieve.
* @param string $filter How to filter what is retrieved.
* @return string Mostly string values, might be empty.
*/
function get_bloginfo($show = '', $filter = 'raw') {
switch($show) {
case 'url' :
case 'home' : // DEPRECATED
case 'siteurl' : // DEPRECATED
$output = get_option('home');
break;
case 'wpurl' :
$output = get_option('siteurl');
break;
case 'description':
$output = get_option('blogdescription');
break;
case 'rdf_url':
$output = get_feed_link('rdf');
break;
case 'rss_url':
$output = get_feed_link('rss');
break;
case 'rss2_url':
$output = get_feed_link('rss2');
break;
case 'atom_url':
$output = get_feed_link('atom');
break;
case 'comments_atom_url':
$output = get_feed_link('comments_atom');
break;
case 'comments_rss2_url':
$output = get_feed_link('comments_rss2');
break;
case 'pingback_url':
$output = get_option('siteurl') .'/xmlrpc.php';
break;
case 'stylesheet_url':
$output = get_stylesheet_uri();
break;
case 'stylesheet_directory':
$output = get_stylesheet_directory_uri();
break;
case 'template_directory':
case 'template_url':
$output = get_template_directory_uri();
break;
case 'admin_email':
$output = get_option('admin_email');
break;
case 'charset':
$output = get_option('blog_charset');
if ('' == $output) $output = 'UTF-8';
break;
case 'html_type' :
$output = get_option('html_type');
break;
case 'version':
global $wp_version;
$output = $wp_version;
break;
case 'language':
$output = get_locale();
$output = str_replace('_', '-', $output);
break;
case 'text_direction':
global $wp_locale;
$output = $wp_locale->text_direction;
break;
case 'name':
default:
$output = get_option('blogname');
break;
}
$url = true;
if (strpos($show, 'url') === false &&
strpos($show, 'directory') === false &&
strpos($show, 'home') === false)
$url = false;
if ( 'display' == $filter ) {
if ( $url )
$output = apply_filters('bloginfo_url', $output, $show);
else
$output = apply_filters('bloginfo', $output, $show);
}
return $output;
}
/**
* Display or retrieve page title for all areas of blog.
*
* By default, the page title will display the separator before the page title,
* so that the blog title will be before the page title. This is not good for
* title display, since the blog title shows up on most tabs and not what is
* important, which is the page that the user is looking at.
*
* There are also SEO benefits to having the blog title after or to the 'right'
* or the page title. However, it is mostly common sense to have the blog title
* to the right with most browsers supporting tabs. You can achieve this by
* using the seplocation parameter and setting the value to 'right'. This change
* was introduced around 2.5.0, in case backwards compatibility of themes is
* important.
*
* @since 1.0.0
*
* @param string $sep Optional, default is '»'. How to separate the various items within the page title.
* @param bool $display Optional, default is true. Whether to display or retrieve title.
* @param string $seplocation Optional. Direction to display title, 'right'.
* @return string|null String on retrieve, null when displaying.
*/
function wp_title($sep = '»', $display = true, $seplocation = '') {
global $wpdb, $wp_locale, $wp_query;
$cat = get_query_var('cat');
$tag = get_query_var('tag_id');
$category_name = get_query_var('category_name');
$author = get_query_var('author');
$author_name = get_query_var('author_name');
$m = get_query_var('m');
$year = get_query_var('year');
$monthnum = get_query_var('monthnum');
$day = get_query_var('day');
$title = '';
$t_sep = '%WP_TITILE_SEP%'; // Temporary separator, for accurate flipping, if necessary
// If there's a category
if ( !empty($cat) ) {
// category exclusion
if ( !stristr($cat,'-') )
$title = apply_filters('single_cat_title', get_the_category_by_ID($cat));
} elseif ( !empty($category_name) ) {
if ( stristr($category_name,'/') ) {
$category_name = explode('/',$category_name);
if ( $category_name[count($category_name)-1] )
$category_name = $category_name[count($category_name)-1]; // no trailing slash
else
$category_name = $category_name[count($category_name)-2]; // there was a trailling slash
}
$cat = get_term_by('slug', $category_name, 'category', OBJECT, 'display');
if ( $cat )
$title = apply_filters('single_cat_title', $cat->name);
}
if ( !empty($tag) ) {
$tag = get_term($tag, 'post_tag', OBJECT, 'display');
if ( is_wp_error( $tag ) )
return $tag;
if ( ! empty($tag->name) )
$title = apply_filters('single_tag_title', $tag->name);
}
// If there's an author
if ( !empty($author) ) {
$title = get_userdata($author);
$title = $title->display_name;
}
if ( !empty($author_name) ) {
// We do a direct query here because we don't cache by nicename.
$title = $wpdb->get_var($wpdb->prepare("SELECT display_name FROM $wpdb->users WHERE user_nicename = %s", $author_name));
}
// If there's a month
if ( !empty($m) ) {
$my_year = substr($m, 0, 4);
$my_month = $wp_locale->get_month(substr($m, 4, 2));
$my_day = intval(substr($m, 6, 2));
$title = "$my_year" . ($my_month ? "$t_sep$my_month" : "") . ($my_day ? "$t_sep$my_day" : "");
}
if ( !empty($year) ) {
$title = $year;
if ( !empty($monthnum) )
$title .= "$t_sep" . $wp_locale->get_month($monthnum);
if ( !empty($day) )
$title .= "$t_sep" . zeroise($day, 2);
}
// If there is a post
if ( is_single() || ( is_page() && !is_front_page() ) ) {
$post = $wp_query->get_queried_object();
$title = strip_tags( apply_filters( 'single_post_title', $post->post_title ) );
}
// If there's a taxonomy
if ( is_tax() ) {
$taxonomy = get_query_var( 'taxonomy' );
$tax = get_taxonomy( $taxonomy );
$tax = $tax->label;
$term = $wp_query->get_queried_object();
$term = $term->name;
$title = "$tax$t_sep$term";
}
if ( is_404() ) {
$title = __('Page not found');
}
$prefix = '';
if ( !empty($title) )
$prefix = " $sep ";
// Determines position of the separator and direction of the breadcrumb
if ( 'right' == $seplocation ) { // sep on right, so reverse the order
$title_array = explode( $t_sep, $title );
$title_array = array_reverse( $title_array );
$title = implode( " $sep ", $title_array ) . $prefix;
} else {
$title_array = explode( $t_sep, $title );
$title = $prefix . implode( " $sep ", $title_array );
}
$title = apply_filters('wp_title', $title, $sep, $seplocation);
// Send it out
if ( $display )
echo $title;
else
return $title;
}
/**
* Display or retrieve page title for post.
*
* This is optimized for single.php template file for displaying the post title.
* Only useful for posts, does not support pages for example.
*
* It does not support placing the separator after the title, but by leaving the
* prefix parameter empty, you can set the title separator manually. The prefix
* does not automatically place a space between the prefix, so if there should
* be a space, the parameter value will need to have it at the end.
*
* @since 0.71
* @uses $wpdb
*
* @param string $prefix Optional. What to display before the title.
* @param bool $display Optional, default is true. Whether to display or retrieve title.
* @return string|null Title when retrieving, null when displaying or failure.
*/
function single_post_title($prefix = '', $display = true) {
global $wpdb;
$p = get_query_var('p');
$name = get_query_var('name');
if ( intval($p) || '' != $name ) {
if ( !$p )
$p = $wpdb->get_var($wpdb->prepare("SELECT ID FROM $wpdb->posts WHERE post_name = %s", $name));
$post = & get_post($p);
$title = $post->post_title;
$title = apply_filters('single_post_title', $title);
if ( $display )
echo $prefix.strip_tags($title);
else
return strip_tags($title);
}
}
/**
* Display or retrieve page title for category archive.
*
* This is useful for category template file or files, because it is optimized
* for category page title and with less overhead than {@link wp_title()}.
*
* It does not support placing the separator after the title, but by leaving the
* prefix parameter empty, you can set the title separator manually. The prefix
* does not automatically place a space between the prefix, so if there should
* be a space, the parameter value will need to have it at the end.
*
* @since 0.71
*
* @param string $prefix Optional. What to display before the title.
* @param bool $display Optional, default is true. Whether to display or retrieve title.
* @return string|null Title when retrieving, null when displaying or failure.
*/
function single_cat_title($prefix = '', $display = true ) {
$cat = intval( get_query_var('cat') );
if ( !empty($cat) && !(strtoupper($cat) == 'ALL') ) {
$my_cat_name = apply_filters('single_cat_title', get_the_category_by_ID($cat));
if ( !empty($my_cat_name) ) {
if ( $display )
echo $prefix.strip_tags($my_cat_name);
else
return strip_tags($my_cat_name);
}
} else if ( is_tag() ) {
return single_tag_title($prefix, $display);
}
}
/**
* Display or retrieve page title for tag post archive.
*
* Useful for tag template files for displaying the tag page title. It has less
* overhead than {@link wp_title()}, because of its limited implementation.
*
* It does not support placing the separator after the title, but by leaving the
* prefix parameter empty, you can set the title separator manually. The prefix
* does not automatically place a space between the prefix, so if there should
* be a space, the parameter value will need to have it at the end.
*
* @since 2.3.0
*
* @param string $prefix Optional. What to display before the title.
* @param bool $display Optional, default is true. Whether to display or retrieve title.
* @return string|null Title when retrieving, null when displaying or failure.
*/
function single_tag_title($prefix = '', $display = true ) {
if ( !is_tag() )
return;
$tag_id = intval( get_query_var('tag_id') );
if ( !empty($tag_id) ) {
$my_tag = &get_term($tag_id, 'post_tag', OBJECT, 'display');
if ( is_wp_error( $my_tag ) )
return false;
$my_tag_name = apply_filters('single_tag_title', $my_tag->name);
if ( !empty($my_tag_name) ) {
if ( $display )
echo $prefix . $my_tag_name;
else
return $my_tag_name;
}
}
}
/**
* Display or retrieve page title for post archive based on date.
*
* Useful for when the template only needs to display the month and year, if
* either are available. Optimized for just this purpose, so if it is all that
* is needed, should be better than {@link wp_title()}.
*
* It does not support placing the separator after the title, but by leaving the
* prefix parameter empty, you can set the title separator manually. The prefix
* does not automatically place a space between the prefix, so if there should
* be a space, the parameter value will need to have it at the end.
*
* @since 0.71
*
* @param string $prefix Optional. What to display before the title.
* @param bool $display Optional, default is true. Whether to display or retrieve title.
* @return string|null Title when retrieving, null when displaying or failure.
*/
function single_month_title($prefix = '', $display = true ) {
global $wp_locale;
$m = get_query_var('m');
$year = get_query_var('year');
$monthnum = get_query_var('monthnum');
if ( !empty($monthnum) && !empty($year) ) {
$my_year = $year;
$my_month = $wp_locale->get_month($monthnum);
} elseif ( !empty($m) ) {
$my_year = substr($m, 0, 4);
$my_month = $wp_locale->get_month(substr($m, 4, 2));
}
if ( empty($my_month) )
return false;
$result = $prefix . $my_month . $prefix . $my_year;
if ( !$display )
return $result;
echo $result;
}
/**
* Retrieve archive link content based on predefined or custom code.
*
* The format can be one of four styles. The 'link' for head element, 'option'
* for use in the select element, 'html' for use in list (either ol or ul HTML
* elements). Custom content is also supported using the before and after
* parameters.
*
* The 'link' format uses the link HTML element with the archives
* relationship. The before and after parameters are not used. The text
* parameter is used to describe the link.
*
* The 'option' format uses the option HTML element for use in select element.
* The value is the url parameter and the before and after parameters are used
* between the text description.
*
* The 'html' format, which is the default, uses the li HTML element for use in
* the list HTML elements. The before parameter is before the link and the after
* parameter is after the closing link.
*
* The custom format uses the before parameter before the link ('a' HTML
* element) and the after parameter after the closing link tag. If the above
* three values for the format are not used, then custom format is assumed.
*
* @since 1.0.0
* @author Orien
* @link http://icecode.com/ link navigation hack by Orien
*
* @param string $url URL to archive.
* @param string $text Archive text description.
* @param string $format Optional, default is 'html'. Can be 'link', 'option', 'html', or custom.
* @param string $before Optional.
* @param string $after Optional.
* @return string HTML link content for archive.
*/
function get_archives_link($url, $text, $format = 'html', $before = '', $after = '') {
$text = wptexturize($text);
$title_text = attribute_escape($text);
$url = clean_url($url);
if ('link' == $format)
$link_html = "\t $before $text $after \n";
elseif ('html' == $format)
$link_html = "\t$before$text $after \n";
else // custom
$link_html = "\t$before $text $after\n";
$link_html = apply_filters( "get_archives_link", $link_html );
return $link_html;
}
/**
* Display archive links based on type and format.
*
* The 'type' argument offers a few choices and by default will display monthly
* archive links. The other options for values are 'daily', 'weekly', 'monthly',
* 'yearly', 'postbypost' or 'alpha'. Both 'postbypost' and 'alpha' display the
* same archive link list, the difference between the two is that 'alpha'
* will order by post title and 'postbypost' will order by post date.
*
* The date archives will logically display dates with links to the archive post
* page. The 'postbypost' and 'alpha' values for 'type' argument will display
* the post titles.
*
* The 'limit' argument will only display a limited amount of links, specified
* by the 'limit' integer value. By default, there is no limit. The
* 'show_post_count' argument will show how many posts are within the archive.
* By default, the 'show_post_count' argument is set to false.
*
* For the 'format', 'before', and 'after' arguments, see {@link
* get_archives_link()}. The values of these arguments have to do with that
* function.
*
* @since 1.2.0
*
* @param string|array $args Optional. Override defaults.
*/
function wp_get_archives($args = '') {
global $wpdb, $wp_locale;
$defaults = array(
'type' => 'monthly', 'limit' => '',
'format' => 'html', 'before' => '',
'after' => '', 'show_post_count' => false,
'echo' => 1
);
$r = wp_parse_args( $args, $defaults );
extract( $r, EXTR_SKIP );
if ( '' == $type )
$type = 'monthly';
if ( '' != $limit ) {
$limit = absint($limit);
$limit = ' LIMIT '.$limit;
}
// this is what will separate dates on weekly archive links
$archive_week_separator = '–';
// over-ride general date format ? 0 = no: use the date format set in Options, 1 = yes: over-ride
$archive_date_format_over_ride = 0;
// options for daily archive (only if you over-ride the general date format)
$archive_day_date_format = 'Y/m/d';
// options for weekly archive (only if you over-ride the general date format)
$archive_week_start_date_format = 'Y/m/d';
$archive_week_end_date_format = 'Y/m/d';
if ( !$archive_date_format_over_ride ) {
$archive_day_date_format = get_option('date_format');
$archive_week_start_date_format = get_option('date_format');
$archive_week_end_date_format = get_option('date_format');
}
//filters
$where = apply_filters('getarchives_where', "WHERE post_type = 'post' AND post_status = 'publish'", $r );
$join = apply_filters('getarchives_join', "", $r);
$output = '';
if ( 'monthly' == $type ) {
$query = "SELECT DISTINCT YEAR(post_date) AS `year`, MONTH(post_date) AS `month`, count(ID) as posts FROM $wpdb->posts $join $where GROUP BY YEAR(post_date), MONTH(post_date) ORDER BY post_date DESC $limit";
$key = md5($query);
$cache = wp_cache_get( 'wp_get_archives' , 'general');
if ( !isset( $cache[ $key ] ) ) {
$arcresults = $wpdb->get_results($query);
$cache[ $key ] = $arcresults;
wp_cache_add( 'wp_get_archives', $cache, 'general' );
} else {
$arcresults = $cache[ $key ];
}
if ( $arcresults ) {
$afterafter = $after;
foreach ( (array) $arcresults as $arcresult ) {
$url = get_month_link( $arcresult->year, $arcresult->month );
$text = sprintf(__('%1$s %2$d'), $wp_locale->get_month($arcresult->month), $arcresult->year);
if ( $show_post_count )
$after = ' ('.$arcresult->posts.')' . $afterafter;
$output .= get_archives_link($url, $text, $format, $before, $after);
}
}
} elseif ('yearly' == $type) {
$query = "SELECT DISTINCT YEAR(post_date) AS `year`, count(ID) as posts FROM $wpdb->posts $join $where GROUP BY YEAR(post_date) ORDER BY post_date DESC $limit";
$key = md5($query);
$cache = wp_cache_get( 'wp_get_archives' , 'general');
if ( !isset( $cache[ $key ] ) ) {
$arcresults = $wpdb->get_results($query);
$cache[ $key ] = $arcresults;
wp_cache_add( 'wp_get_archives', $cache, 'general' );
} else {
$arcresults = $cache[ $key ];
}
if ($arcresults) {
$afterafter = $after;
foreach ( (array) $arcresults as $arcresult) {
$url = get_year_link($arcresult->year);
$text = sprintf('%d', $arcresult->year);
if ($show_post_count)
$after = ' ('.$arcresult->posts.')' . $afterafter;
$output .= get_archives_link($url, $text, $format, $before, $after);
}
}
} elseif ( 'daily' == $type ) {
$query = "SELECT DISTINCT YEAR(post_date) AS `year`, MONTH(post_date) AS `month`, DAYOFMONTH(post_date) AS `dayofmonth`, count(ID) as posts FROM $wpdb->posts $join $where GROUP BY YEAR(post_date), MONTH(post_date), DAYOFMONTH(post_date) ORDER BY post_date DESC $limit";
$key = md5($query);
$cache = wp_cache_get( 'wp_get_archives' , 'general');
if ( !isset( $cache[ $key ] ) ) {
$arcresults = $wpdb->get_results($query);
$cache[ $key ] = $arcresults;
wp_cache_add( 'wp_get_archives', $cache, 'general' );
} else {
$arcresults = $cache[ $key ];
}
if ( $arcresults ) {
$afterafter = $after;
foreach ( (array) $arcresults as $arcresult ) {
$url = get_day_link($arcresult->year, $arcresult->month, $arcresult->dayofmonth);
$date = sprintf('%1$d-%2$02d-%3$02d 00:00:00', $arcresult->year, $arcresult->month, $arcresult->dayofmonth);
$text = mysql2date($archive_day_date_format, $date);
if ($show_post_count)
$after = ' ('.$arcresult->posts.')'.$afterafter;
$output .= get_archives_link($url, $text, $format, $before, $after);
}
}
} elseif ( 'weekly' == $type ) {
$start_of_week = get_option('start_of_week');
$query = "SELECT DISTINCT WEEK(post_date, $start_of_week) AS `week`, YEAR(post_date) AS yr, DATE_FORMAT(post_date, '%Y-%m-%d') AS yyyymmdd, count(ID) as posts FROM $wpdb->posts $join $where GROUP BY WEEK(post_date, $start_of_week), YEAR(post_date) ORDER BY post_date DESC $limit";
$key = md5($query);
$cache = wp_cache_get( 'wp_get_archives' , 'general');
if ( !isset( $cache[ $key ] ) ) {
$arcresults = $wpdb->get_results($query);
$cache[ $key ] = $arcresults;
wp_cache_add( 'wp_get_archives', $cache, 'general' );
} else {
$arcresults = $cache[ $key ];
}
$arc_w_last = '';
$afterafter = $after;
if ( $arcresults ) {
foreach ( (array) $arcresults as $arcresult ) {
if ( $arcresult->week != $arc_w_last ) {
$arc_year = $arcresult->yr;
$arc_w_last = $arcresult->week;
$arc_week = get_weekstartend($arcresult->yyyymmdd, get_option('start_of_week'));
$arc_week_start = date_i18n($archive_week_start_date_format, $arc_week['start']);
$arc_week_end = date_i18n($archive_week_end_date_format, $arc_week['end']);
$url = sprintf('%1$s/%2$s%3$sm%4$s%5$s%6$sw%7$s%8$d', get_option('home'), '', '?', '=', $arc_year, '&', '=', $arcresult->week);
$text = $arc_week_start . $archive_week_separator . $arc_week_end;
if ($show_post_count)
$after = ' ('.$arcresult->posts.')'.$afterafter;
$output .= get_archives_link($url, $text, $format, $before, $after);
}
}
}
} elseif ( ( 'postbypost' == $type ) || ('alpha' == $type) ) {
$orderby = ('alpha' == $type) ? "post_title ASC " : "post_date DESC ";
$query = "SELECT * FROM $wpdb->posts $join $where ORDER BY $orderby $limit";
$key = md5($query);
$cache = wp_cache_get( 'wp_get_archives' , 'general');
if ( !isset( $cache[ $key ] ) ) {
$arcresults = $wpdb->get_results($query);
$cache[ $key ] = $arcresults;
wp_cache_add( 'wp_get_archives', $cache, 'general' );
} else {
$arcresults = $cache[ $key ];
}
if ( $arcresults ) {
foreach ( (array) $arcresults as $arcresult ) {
if ( $arcresult->post_date != '0000-00-00 00:00:00' ) {
$url = get_permalink($arcresult);
$arc_title = $arcresult->post_title;
if ( $arc_title )
$text = strip_tags(apply_filters('the_title', $arc_title));
else
$text = $arcresult->ID;
$output .= get_archives_link($url, $text, $format, $before, $after);
}
}
}
}
if ( $echo )
echo $output;
else
return $output;
}
/**
* Get number of days since the start of the week.
*
* @since 1.5.0
* @usedby get_calendar()
*
* @param int $num Number of day.
* @return int Days since the start of the week.
*/
function calendar_week_mod($num) {
$base = 7;
return ($num - $base*floor($num/$base));
}
/**
* Display calendar with days that have posts as links.
*
* The calendar is cached, which will be retrieved, if it exists. If there are
* no posts for the month, then it will not be displayed.
*
* @since 1.0.0
*
* @param bool $initial Optional, default is true. Use initial calendar names.
*/
function get_calendar($initial = true) {
global $wpdb, $m, $monthnum, $year, $wp_locale, $posts;
$key = md5( $m . $monthnum . $year );
if ( $cache = wp_cache_get( 'get_calendar', 'calendar' ) ) {
if ( isset( $cache[ $key ] ) ) {
echo $cache[ $key ];
return;
}
}
ob_start();
// Quick check. If we have no posts at all, abort!
if ( !$posts ) {
$gotsome = $wpdb->get_var("SELECT ID from $wpdb->posts WHERE post_type = 'post' AND post_status = 'publish' ORDER BY post_date DESC LIMIT 1");
if ( !$gotsome )
return;
}
if ( isset($_GET['w']) )
$w = ''.intval($_GET['w']);
// week_begins = 0 stands for Sunday
$week_begins = intval(get_option('start_of_week'));
// Let's figure out when we are
if ( !empty($monthnum) && !empty($year) ) {
$thismonth = ''.zeroise(intval($monthnum), 2);
$thisyear = ''.intval($year);
} elseif ( !empty($w) ) {
// We need to get the month from MySQL
$thisyear = ''.intval(substr($m, 0, 4));
$d = (($w - 1) * 7) + 6; //it seems MySQL's weeks disagree with PHP's
$thismonth = $wpdb->get_var("SELECT DATE_FORMAT((DATE_ADD('${thisyear}0101', INTERVAL $d DAY) ), '%m')");
} elseif ( !empty($m) ) {
$thisyear = ''.intval(substr($m, 0, 4));
if ( strlen($m) < 6 )
$thismonth = '01';
else
$thismonth = ''.zeroise(intval(substr($m, 4, 2)), 2);
} else {
$thisyear = gmdate('Y', current_time('timestamp'));
$thismonth = gmdate('m', current_time('timestamp'));
}
$unixmonth = mktime(0, 0 , 0, $thismonth, 1, $thisyear);
// Get the next and previous month and year with at least one post
$previous = $wpdb->get_row("SELECT DISTINCT MONTH(post_date) AS month, YEAR(post_date) AS year
FROM $wpdb->posts
WHERE post_date < '$thisyear-$thismonth-01'
AND post_type = 'post' AND post_status = 'publish'
ORDER BY post_date DESC
LIMIT 1");
$next = $wpdb->get_row("SELECT DISTINCT MONTH(post_date) AS month, YEAR(post_date) AS year
FROM $wpdb->posts
WHERE post_date > '$thisyear-$thismonth-01'
AND MONTH( post_date ) != MONTH( '$thisyear-$thismonth-01' )
AND post_type = 'post' AND post_status = 'publish'
ORDER BY post_date ASC
LIMIT 1");
echo '
' . sprintf(_c('%1$s %2$s|Used as a calendar caption'), $wp_locale->get_month($thismonth), date('Y', $unixmonth)) . '
';
$myweek = array();
for ( $wdcount=0; $wdcount<=6; $wdcount++ ) {
$myweek[] = $wp_locale->get_weekday(($wdcount+$week_begins)%7);
}
foreach ( $myweek as $wd ) {
$day_name = (true == $initial) ? $wp_locale->get_weekday_initial($wd) : $wp_locale->get_weekday_abbrev($wd);
echo "\n\t\t$day_name ";
}
echo '
';
if ( $previous ) {
echo "\n\t\t".'« ' . $wp_locale->get_month_abbrev($wp_locale->get_month($previous->month)) . ' ';
}
echo "\n\t\t".' ';
if ( $next ) {
echo "\n\t\t".'' . $wp_locale->get_month_abbrev($wp_locale->get_month($next->month)) . ' » ';
}
echo '
';
// Get days with posts
$dayswithposts = $wpdb->get_results("SELECT DISTINCT DAYOFMONTH(post_date)
FROM $wpdb->posts WHERE MONTH(post_date) = '$thismonth'
AND YEAR(post_date) = '$thisyear'
AND post_type = 'post' AND post_status = 'publish'
AND post_date < '" . current_time('mysql') . '\'', ARRAY_N);
if ( $dayswithposts ) {
foreach ( (array) $dayswithposts as $daywith ) {
$daywithpost[] = $daywith[0];
}
} else {
$daywithpost = array();
}
if (strpos($_SERVER['HTTP_USER_AGENT'], 'MSIE') !== false || strpos(strtolower($_SERVER['HTTP_USER_AGENT']), 'camino') !== false || strpos(strtolower($_SERVER['HTTP_USER_AGENT']), 'safari') !== false)
$ak_title_separator = "\n";
else
$ak_title_separator = ', ';
$ak_titles_for_day = array();
$ak_post_titles = $wpdb->get_results("SELECT post_title, DAYOFMONTH(post_date) as dom "
."FROM $wpdb->posts "
."WHERE YEAR(post_date) = '$thisyear' "
."AND MONTH(post_date) = '$thismonth' "
."AND post_date < '".current_time('mysql')."' "
."AND post_type = 'post' AND post_status = 'publish'"
);
if ( $ak_post_titles ) {
foreach ( (array) $ak_post_titles as $ak_post_title ) {
$post_title = apply_filters( "the_title", $ak_post_title->post_title );
$post_title = str_replace('"', '"', wptexturize( $post_title ));
if ( empty($ak_titles_for_day['day_'.$ak_post_title->dom]) )
$ak_titles_for_day['day_'.$ak_post_title->dom] = '';
if ( empty($ak_titles_for_day["$ak_post_title->dom"]) ) // first one
$ak_titles_for_day["$ak_post_title->dom"] = $post_title;
else
$ak_titles_for_day["$ak_post_title->dom"] .= $ak_title_separator . $post_title;
}
}
// See how much we should pad in the beginning
$pad = calendar_week_mod(date('w', $unixmonth)-$week_begins);
if ( 0 != $pad )
echo "\n\t\t".' ';
$daysinmonth = intval(date('t', $unixmonth));
for ( $day = 1; $day <= $daysinmonth; ++$day ) {
if ( isset($newrow) && $newrow )
echo "\n\t \n\t\n\t\t";
$newrow = false;
if ( $day == gmdate('j', (time() + (get_option('gmt_offset') * 3600))) && $thismonth == gmdate('m', time()+(get_option('gmt_offset') * 3600)) && $thisyear == gmdate('Y', time()+(get_option('gmt_offset') * 3600)) )
echo '';
else
echo ' ';
if ( in_array($day, $daywithpost) ) // any posts today?
echo '$day ";
else
echo $day;
echo ' ';
if ( 6 == calendar_week_mod(date('w', mktime(0, 0 , 0, $thismonth, $day, $thisyear))-$week_begins) )
$newrow = true;
}
$pad = 7 - calendar_week_mod(date('w', mktime(0, 0 , 0, $thismonth, $day, $thisyear))-$week_begins);
if ( $pad != 0 && $pad != 7 )
echo "\n\t\t".' ';
echo "\n\t \n\t \n\t
";
$output = ob_get_contents();
ob_end_clean();
echo $output;
$cache[ $key ] = $output;
wp_cache_set( 'get_calendar', $cache, 'calendar' );
}
/**
* Purge the cached results of get_calendar.
*
* @see get_calendar
* @since 2.1.0
*/
function delete_get_calendar_cache() {
wp_cache_delete( 'get_calendar', 'calendar' );
}
add_action( 'save_post', 'delete_get_calendar_cache' );
add_action( 'delete_post', 'delete_get_calendar_cache' );
add_action( 'update_option_start_of_week', 'delete_get_calendar_cache' );
add_action( 'update_option_gmt_offset', 'delete_get_calendar_cache' );
add_action( 'update_option_start_of_week', 'delete_get_calendar_cache' );
/**
* Display all of the allowed tags in HTML format with attributes.
*
* This is useful for displaying in the comment area, which elements and
* attributes are supported. As well as any plugins which want to display it.
*
* @since 1.0.1
* @uses $allowedtags
*
* @return string HTML allowed tags entity encoded.
*/
function allowed_tags() {
global $allowedtags;
$allowed = '';
foreach ( (array) $allowedtags as $tag => $attributes ) {
$allowed .= '<'.$tag;
if ( 0 < count($attributes) ) {
foreach ( $attributes as $attribute => $limits ) {
$allowed .= ' '.$attribute.'=""';
}
}
$allowed .= '> ';
}
return htmlentities($allowed);
}
/***** Date/Time tags *****/
/**
* Outputs the date in iso8601 format for xml files.
*
* @since 1.0.0
*/
function the_date_xml() {
global $post;
echo mysql2date('Y-m-d', $post->post_date);
}
/**
* Display or Retrieve the date the post was written.
*
* Will only output the date if the current post's date is different from the
* previous one output.
*
* @since 0.71
*
* @param string $d Optional. PHP date format defaults to the date_format option if not specified.
* @param string $before Optional. Output before the date.
* @param string $after Optional. Output after the date.
* @param bool $echo Optional, default is display. Whether to echo the date or return it.
* @return string|null Null if displaying, string if retrieving.
*/
function the_date($d='', $before='', $after='', $echo = true) {
global $post, $day, $previousday;
$the_date = '';
if ( $day != $previousday ) {
$the_date .= $before;
if ( $d=='' )
$the_date .= mysql2date(get_option('date_format'), $post->post_date);
else
$the_date .= mysql2date($d, $post->post_date);
$the_date .= $after;
$previousday = $day;
}
$the_date = apply_filters('the_date', $the_date, $d, $before, $after);
if ( $echo )
echo $the_date;
else
return $the_date;
}
/**
* Display the date on which the post was last modified.
*
* @since 2.1.0
*
* @param string $d Optional. PHP date format.
* @return string
*/
function the_modified_date($d = '') {
echo apply_filters('the_modified_date', get_the_modified_date($d), $d);
}
/**
* Retrieve the date on which the post was last modified.
*
* @since 2.1.0
*
* @param string $d Optional. PHP date format. Defaults to the "date_format" option
* @return string
*/
function get_the_modified_date($d = '') {
if ( '' == $d )
$the_time = get_post_modified_time(get_option('date_format'));
else
$the_time = get_post_modified_time($d);
return apply_filters('get_the_modified_date', $the_time, $d);
}
/**
* Display the time at which the post was written.
*
* @since 0.71
*
* @param string $d Either 'G', 'U', or php date format.
*/
function the_time( $d = '' ) {
echo apply_filters('the_time', get_the_time( $d ), $d);
}
/**
* Retrieve the time at which the post was written.
*
* @since 1.5.0
*
* @param string $d Either 'G', 'U', or php date format defaults to the value specified in the time_format option.
* @param int|object $post Optional post ID or object. Default is global $post object.
* @return string
*/
function get_the_time( $d = '', $post = null ) {
$post = get_post($post);
if ( '' == $d )
$the_time = get_post_time(get_option('time_format'), false, $post);
else
$the_time = get_post_time($d, false, $post);
return apply_filters('get_the_time', $the_time, $d, $post);
}
/**
* Retrieve the time at which the post was written.
*
* @since 2.0.0
*
* @param string $d Either 'G', 'U', or php date format.
* @param bool $gmt Whether of not to return the gmt time.
* @param int|object $post Optional post ID or object. Default is global $post object.
* @return string
*/
function get_post_time( $d = 'U', $gmt = false, $post = null ) { // returns timestamp
$post = get_post($post);
if ( $gmt )
$time = $post->post_date_gmt;
else
$time = $post->post_date;
$time = mysql2date($d, $time);
return apply_filters('get_post_time', $time, $d, $gmt);
}
/**
* Display the time at which the post was last modified.
*
* @since 2.0.0
*
* @param string $d Either 'G', 'U', or php date format defaults to the value specified in the time_format option.
*/
function the_modified_time($d = '') {
echo apply_filters('the_modified_time', get_the_modified_time($d), $d);
}
/**
* Retrieve the time at which the post was last modified.
*
* @since 2.0.0
*
* @param string $d Either 'G', 'U', or php date format defaults to the value specified in the time_format option.
* @return string
*/
function get_the_modified_time($d = '') {
if ( '' == $d )
$the_time = get_post_modified_time(get_option('time_format'));
else
$the_time = get_post_modified_time($d);
return apply_filters('get_the_modified_time', $the_time, $d);
}
/**
* Retrieve the time at which the post was last modified.
*
* @since 2.0.0
*
* @param string $d Either 'G', 'U', or php date format.
* @param bool $gmt Whether of not to return the gmt time.
* @return string Returns timestamp
*/
function get_post_modified_time( $d = 'U', $gmt = false ) {
global $post;
if ( $gmt )
$time = $post->post_modified_gmt;
else
$time = $post->post_modified;
$time = mysql2date($d, $time);
return apply_filters('get_the_modified_time', $time, $d, $gmt);
}
/**
* Display the weekday on which the post was written.
*
* @since 0.71
* @uses $wp_locale
* @uses $post
*/
function the_weekday() {
global $wp_locale, $post;
$the_weekday = $wp_locale->get_weekday(mysql2date('w', $post->post_date));
$the_weekday = apply_filters('the_weekday', $the_weekday);
echo $the_weekday;
}
/**
* Display the weekday on which the post was written.
*
* Will only output the weekday if the current post's weekday is different from
* the previous one output.
*
* @since 0.71
*
* @param string $before output before the date.
* @param string $after output after the date.
*/
function the_weekday_date($before='',$after='') {
global $wp_locale, $post, $day, $previousweekday;
$the_weekday_date = '';
if ( $day != $previousweekday ) {
$the_weekday_date .= $before;
$the_weekday_date .= $wp_locale->get_weekday(mysql2date('w', $post->post_date));
$the_weekday_date .= $after;
$previousweekday = $day;
}
$the_weekday_date = apply_filters('the_weekday_date', $the_weekday_date, $before, $after);
echo $the_weekday_date;
}
/**
* Fire the wp_head action
*
* @since 1.2.0
* @uses do_action() Calls 'wp_head' hook.
*/
function wp_head() {
do_action('wp_head');
}
/**
* Fire the wp_footer action
*
* @since 1.5.1
* @uses do_action() Calls 'wp_footer' hook.
*/
function wp_footer() {
do_action('wp_footer');
}
/**
* Display the link to the Really Simple Discovery service endpoint.
*
* @link http://archipelago.phrasewise.com/rsd
* @since 2.0.0
*/
function rsd_link() {
echo '
\n");
$the_editor_content = apply_filters('the_editor_content', $content);
printf($the_editor, $the_editor_content);
?>
'%_%', // http://example.com/all_posts.php%_% : %_% is replaced by format (below)
'format' => '?page=%#%', // ?page=%#% : %#% is replaced by the page number
'total' => 1,
'current' => 0,
'show_all' => false,
'prev_next' => true,
'prev_text' => __('« Previous'),
'next_text' => __('Next »'),
'end_size' => 1,
'mid_size' => 2,
'type' => 'plain',
'add_args' => false, // array of query args to add
'add_fragment' => ''
);
$args = wp_parse_args( $args, $defaults );
extract($args, EXTR_SKIP);
// Who knows what else people pass in $args
$total = (int) $total;
if ( $total < 2 )
return;
$current = (int) $current;
$end_size = 0 < (int) $end_size ? (int) $end_size : 1; // Out of bounds? Make it the default.
$mid_size = 0 <= (int) $mid_size ? (int) $mid_size : 2;
$add_args = is_array($add_args) ? $add_args : false;
$r = '';
$page_links = array();
$n = 0;
$dots = false;
if ( $prev_next && $current && 1 < $current ) :
$link = str_replace('%_%', 2 == $current ? '' : $format, $base);
$link = str_replace('%#%', $current - 1, $link);
if ( $add_args )
$link = add_query_arg( $add_args, $link );
$link .= $add_fragment;
$page_links[] = "$prev_text ";
endif;
for ( $n = 1; $n <= $total; $n++ ) :
$n_display = number_format_i18n($n);
if ( $n == $current ) :
$page_links[] = "$n_display ";
$dots = true;
else :
if ( $show_all || ( $n <= $end_size || ( $current && $n >= $current - $mid_size && $n <= $current + $mid_size ) || $n > $total - $end_size ) ) :
$link = str_replace('%_%', 1 == $n ? '' : $format, $base);
$link = str_replace('%#%', $n, $link);
if ( $add_args )
$link = add_query_arg( $add_args, $link );
$link .= $add_fragment;
$page_links[] = "$n_display ";
$dots = true;
elseif ( $dots && !$show_all ) :
$page_links[] = "... ";
$dots = false;
endif;
endif;
endfor;
if ( $prev_next && $current && ( $current < $total || -1 == $total ) ) :
$link = str_replace('%_%', $format, $base);
$link = str_replace('%#%', $current + 1, $link);
if ( $add_args )
$link = add_query_arg( $add_args, $link );
$link .= $add_fragment;
$page_links[] = "$next_text ";
endif;
switch ( $type ) :
case 'array' :
return $page_links;
break;
case 'list' :
$r .= "\n\t";
$r .= join(" \n\t", $page_links);
$r .= " \n \n";
break;
default :
$r = join("\n", $page_links);
break;
endswitch;
return $r;
}
/**
* Registers an admin colour scheme css file.
*
* Allows a plugin to register a new admin colour scheme. For example:
*
* wp_admin_css_color('classic', __('Classic'), admin_url("css/colors-classic.css"),
* array('#07273E', '#14568A', '#D54E21', '#2683AE'));
*
*
* @since 2.5.0
*
* @param string $key The unique key for this theme.
* @param string $name The name of the theme.
* @param string $url The url of the css file containing the colour scheme.
* @param array @colors An array of CSS color definitions which are used to give the user a feel for the theme.
*/
function wp_admin_css_color($key, $name, $url, $colors = array()) {
global $_wp_admin_css_colors;
if ( !isset($_wp_admin_css_colors) )
$_wp_admin_css_colors = array();
$_wp_admin_css_colors[$key] = (object) array('name' => $name, 'url' => $url, 'colors' => $colors);
}
/**
* Display the URL of a WordPress admin CSS file.
*
* @see WP_Styles::_css_href and its style_loader_src filter.
*
* @since 2.3.0
*
* @param string $file file relative to wp-admin/ without its ".css" extension.
*/
function wp_admin_css_uri( $file = 'wp-admin' ) {
if ( defined('WP_INSTALLING') ) {
$_file = "./$file.css";
} else {
$_file = admin_url("$file.css");
}
$_file = add_query_arg( 'version', get_bloginfo( 'version' ), $_file );
return apply_filters( 'wp_admin_css_uri', $_file, $file );
}
/**
* Enqueues or directly prints a stylesheet link to the specified CSS file.
*
* "Intelligently" decides to enqueue or to print the CSS file. If the
* 'wp_print_styles' action has *not* yet been called, the CSS file will be
* enqueued. If the wp_print_styles action *has* been called, the CSS link will
* be printed. Printing may be forced by passing TRUE as the $force_echo
* (second) parameter.
*
* For backward compatibility with WordPress 2.3 calling method: If the $file
* (first) parameter does not correspond to a registered CSS file, we assume
* $file is a file relative to wp-admin/ without its ".css" extension. A
* stylesheet link to that generated URL is printed.
*
* @package WordPress
* @since 2.3.0
* @uses $wp_styles WordPress Styles Object
*
* @param string $file Style handle name or file name (without ".css" extension) relative to wp-admin/
* @param bool $force_echo Optional. Force the stylesheet link to be printed rather than enqueued.
*/
function wp_admin_css( $file = 'wp-admin', $force_echo = false ) {
global $wp_styles;
if ( !is_a($wp_styles, 'WP_Styles') )
$wp_styles = new WP_Styles();
// For backward compatibility
$handle = 0 === strpos( $file, 'css/' ) ? substr( $file, 4 ) : $file;
if ( $wp_styles->query( $handle ) ) {
if ( $force_echo || did_action( 'wp_print_styles' ) ) // we already printed the style queue. Print this one immediately
wp_print_styles( $handle );
else // Add to style queue
wp_enqueue_style( $handle );
return;
}
echo apply_filters( 'wp_admin_css', "WordPress ';
break;
case 'rss2':
$gen = 'http://wordpress.org/?v=' . get_bloginfo_rss( 'version' ) . ' ';
break;
case 'rdf':
$gen = ' 