diff --git a/composer.json b/composer.json new file mode 100644 index 0000000..7879971 --- /dev/null +++ b/composer.json @@ -0,0 +1,5 @@ +{ + "require" : { + "bartfeenstra/cldr" : "1.x-dev" + } +} diff --git a/composer.lock b/composer.lock new file mode 100644 index 0000000..02c2c94 --- /dev/null +++ b/composer.lock @@ -0,0 +1,53 @@ +{ + "hash": "efbf03aac3d4242abb29fbb9c39d2e09", + "packages": [ + { + "name": "bartfeenstra/cldr", + "version": "1.x-dev", + "source": { + "type": "git", + "url": "https://github.com/bartfeenstra/cldr", + "reference": "dbb0b14b88fb79a43d47750dfca2e248efbdcecd" + }, + "dist": { + "type": "zip", + "url": "https://github.com/bartfeenstra/cldr/archive/dbb0b14b88fb79a43d47750dfca2e248efbdcecd.zip", + "reference": "dbb0b14b88fb79a43d47750dfca2e248efbdcecd", + "shasum": "" + }, + "require": { + "php": ">=5.3.0" + }, + "require-dev": { + "phpunit/phpunit": "3.7.*" + }, + "time": "2012-12-09 14:51:07", + "type": "library", + "installation-source": "dist", + "autoload": { + "psr-0": { + "BartFeenstra": "src" + } + }, + "license": [ + "MIT" + ], + "authors": [ + { + "name": "Bart Feenstra", + "email": "bart@mynameisbart.com", + "homepage": "http://mynameisbart.com", + "role": "Developer" + } + ] + } + ], + "packages-dev": null, + "aliases": [ + + ], + "minimum-stability": "stable", + "stability-flags": { + "bartfeenstra/cldr": 20 + } +} diff --git a/currency.module b/currency.module index 39c640c..6165b07 100644 --- a/currency.module +++ b/currency.module @@ -5,6 +5,8 @@ * Provides currency information and allows users to add custom currencies. */ +require_once __DIR__ . '/vendor/autoload.php'; + /** * Indicates a currency's sign/code should be displayed before the amount. */ diff --git a/vendor/autoload.php b/vendor/autoload.php new file mode 100644 index 0000000..1a19585 --- /dev/null +++ b/vendor/autoload.php @@ -0,0 +1,7 @@ +=5.3.0" + }, + "require-dev" : { + "phpunit/phpunit" : "3.7.*" + } +} \ No newline at end of file diff --git a/vendor/bartfeenstra/cldr/src/BartFeenstra/CLDR/CurrencyFormatter.php b/vendor/bartfeenstra/cldr/src/BartFeenstra/CLDR/CurrencyFormatter.php new file mode 100644 index 0000000..87ffce7 --- /dev/null +++ b/vendor/bartfeenstra/cldr/src/BartFeenstra/CLDR/CurrencyFormatter.php @@ -0,0 +1,41 @@ +symbol_replacements[self::SYMBOL_SPECIAL_CURRENCY] = $currency_sign; + + return parent::format($number); + } +} diff --git a/vendor/bartfeenstra/cldr/src/BartFeenstra/CLDR/DecimalFormatter.php b/vendor/bartfeenstra/cldr/src/BartFeenstra/CLDR/DecimalFormatter.php new file mode 100644 index 0000000..2146b89 --- /dev/null +++ b/vendor/bartfeenstra/cldr/src/BartFeenstra/CLDR/DecimalFormatter.php @@ -0,0 +1,138 @@ +pattern = $pattern; + $this->symbol_replacements = $symbol_replacements; + $symbols = $this->patternSymbolsSplit($this->patternSymbols($pattern), self::SYMBOL_PATTERN_SEPARATOR, TRUE); + // If there is no negative pattern, add a default. + if ($symbols[self::NEGATIVE] === FALSE) { + $pattern .= ';-' . $pattern; + $symbols = $this->patternSymbolsSplit($this->patternSymbols($pattern), self::SYMBOL_PATTERN_SEPARATOR, TRUE); + } + foreach ($symbols as $sign_symbols) { + if (empty($sign_symbols)) { + throw new \InvalidArgumentException('Empty number pattern.'); + } + } + $this->symbols = array( + $this->patternSymbolsSplit($symbols[self::POSITIVE], self::SYMBOL_SPECIAL_DECIMAL_SEPARATOR), + $this->patternSymbolsSplit($symbols[self::NEGATIVE], self::SYMBOL_SPECIAL_DECIMAL_SEPARATOR), + ); + } + + /** + * Overrides parent::format(). + * + * A decimal is formatted by splitting it into two integers: the major + * and minor unit. They are formatted individually and then joined together. + * + * @param float|string $number + */ + public function format($number) { + if ((float) $number != $number) { + throw new \InvalidArgumentException('Number has no valid float value.'); + } + $sign = (int) ($number < 0); + + // Split the number in major and minor units, and make sure there is a + // minor unit at all. + $number = explode('.', abs($number)); + $number += array( + self::MINOR => '', + ); + + $digits = array( + str_split($number[self::MAJOR]), + strlen($number[self::MINOR]) ? str_split($number[self::MINOR]) : array(), + ); + + $symbols = $this->cloneNumberPatternSymbols($this->symbols[$sign]); + $this->process($symbols[$sign][self::MAJOR], $digits[self::MAJOR]); + // Integer formatting defaults from right to left, but minor units should + // be formatted from left to right, so reverse all data and results. + $this->process(array_reverse($symbols[$sign][self::MINOR]), array_reverse($digits[self::MINOR])); + foreach ($symbols[$sign][self::MINOR] as $symbol) { + if (!is_null($symbol->replacement)) { + $symbol->replacement = strrev($symbol->replacement); + } + } + + // Prepare the output string. + $output = array( + self::MAJOR => '', + self::MINOR => '', + ); + foreach ($symbols[$sign] as $fragment => $fragment_symbols) { + $this->replacePlaceholders($fragment_symbols); + foreach ($fragment_symbols as $symbol) { + $output[$fragment] .= !is_null($symbol->replacement) ? $symbol->replacement : $symbol->symbol; + } + } + + return $output[self::MAJOR] . $this->getReplacement(self::SYMBOL_SPECIAL_DECIMAL_SEPARATOR) . $output[self::MINOR]; + } + + /** + * Clones this formatter's NumberPatternSymbol objects. + * + * @return array + * An array identical to $this->symbols. + */ + function cloneNumberPatternSymbols() { + $clone = array( + self::POSITIVE => array( + self::MAJOR => array(), + self::MINOR => array(), + ), + self::NEGATIVE => array( + self::MAJOR => array(), + self::MINOR => array(), + ), + ); + foreach ($this->symbols as $sign => $sign_symbols) { + foreach ($sign_symbols as $fragment => $fragment_symbols) { + foreach ($fragment_symbols as $symbol) { + $clone[$sign][$fragment][] = clone $symbol; + } + } + } + + return $clone; + } +} diff --git a/vendor/bartfeenstra/cldr/src/BartFeenstra/CLDR/IntegerFormatter.php b/vendor/bartfeenstra/cldr/src/BartFeenstra/CLDR/IntegerFormatter.php new file mode 100644 index 0000000..a3ba832 --- /dev/null +++ b/vendor/bartfeenstra/cldr/src/BartFeenstra/CLDR/IntegerFormatter.php @@ -0,0 +1,468 @@ +pattern. + * + * @var array + * Keys are any of the self::SYMBOL_SPECIAL_* constants, values are those + * constants' replacements. + */ + public $symbol_replacements = array(); + + /** + * Implements __construct(). + * + * @param string $pattern + * A Unicode CLDR number pattern, without short number support. + * See http://cldr.unicode.org/translation/number-patterns. + * @param array $symbol_replacements + * Keys are one of the self::SYMBOL_SPECIAL_* constants, values are their + * replacements. + */ + function __construct($pattern, array $symbol_replacements = array()) { + $this->pattern = $pattern; + $this->symbol_replacements = $symbol_replacements; + $this->symbols = $this->patternSymbolsSplit($this->patternSymbols($pattern), self::SYMBOL_PATTERN_SEPARATOR, TRUE); + // If there is no negative pattern, add a default. + if ($this->symbols[self::NEGATIVE] === FALSE) { + $pattern .= ';-' . $pattern; + $this->symbols = $this->patternSymbolsSplit($this->patternSymbols($pattern), self::SYMBOL_PATTERN_SEPARATOR, TRUE); + } + foreach ($this->symbols as $sign_symbols) { + if (empty($sign_symbols)) { + throw new \InvalidArgumentException('Empty number pattern.'); + } + } + } + + /** + * Implements __clone(). + */ + function __clone() { + $this->symbols = $this->cloneNumberPatternSymbols($this->symbols); + } + + /** + * Converts a number pattern to an array of NumberPatternSymbol objects. + * + * @throws \RuntimeException + * + * @param string $pattern + * + * @return array + */ + function patternSymbols($pattern) { + // Convert the pattern to NumberPatternSymbol objects. + $symbols = array(); + foreach ($this->str_split($pattern) as $position => $symbol) { + $symbols[] = new NumberPatternSymbol($symbol, $position); + } + + // Loop through the NumberPatternSymbol objects and mark escaped symbols. + foreach ($symbols as $i => $symbol) { + // Check if the previous character is an unused escape symbol for this + // symbol. + if (isset($symbols[$i - 1]) && $symbols[$i - 1]->symbol == self::SYMBOL_ESCAPE && !$symbols[$i - 1]->escaped && !$symbols[$i - 1]->escapes_other_symbol + // Check if the next character is an escape symbol for this symbol. + && isset($symbols[$i + 1]) && $symbols[$i + 1]->symbol == self::SYMBOL_ESCAPE && !$symbols[$i + 1]->escaped && !$symbols[$i + 1]->escapes_other_symbol) { + $symbol->escaped = TRUE; + $symbols[$i - 1]->escapes_other_symbol = TRUE; + $symbols[$i + 1]->escapes_other_symbol = TRUE; + } + } + + // Find illegal escape symbols, e.g. escape symbols that do not escape + // other symbols and are not escaped themselves. + foreach ($symbols as $symbol) { + if ($symbol->symbol == self::SYMBOL_ESCAPE && !$symbol->escaped && !$symbol->escapes_other_symbol) { + throw new \RunTimeException("Invalid escape symbol (') in pattern " . $pattern . "at position $symbol->position."); + } + } + + // Remove escape symbols from the array, because we have transferred their + // meaning to other symbols' NumberPatternSymbol objects. + foreach ($symbols as $i => $symbol) { + if ($symbol->escapes_other_symbol) { + unset($symbols[$i]); + } + } + + // Reset the array keys so they make sense again. + return array_values($symbols); + } + + /** + * Splits a pattern into two fragments. + * + * @throws \InvalidArgumentException + * @throws \RuntimeException + * + * @param array $symbols + * An array of NumberPatternSymbol objects. + * @param string $separator + * @param boolean $optional_right_fragment + * Whether the symbols on the right side of the separator, and, because of + * that, the separator itself are optional. + * + * @return array + * An array of NumberPatternSymbol objects. + */ + protected function patternSymbolsSplit(array $symbols, $separator, $optional_right_fragment = FALSE) { + $separator_position = NULL; + foreach ($symbols as $position => $symbol) { + if (!($symbol instanceof NumberPatternSymbol)) { + throw new \InvalidArgumentException(); + } + if ($symbol->symbol === $separator && !$symbol->escaped) { + if (is_null($separator_position)) { + $separator_position = $position; + } + else { + throw new \RunTimeException("Illegal separator ($separator) at position $symbol->position."); + } + } + } + + if (!$separator_position) { + if ($optional_right_fragment) { + return array($symbols, FALSE); + } + throw new \RunTimeException("Missing separator ($separator)."); + } + else { + return array( + array_slice($symbols, 0, $separator_position), + array_slice($symbols, $separator_position + 1), + ); + } + } + + /** + * Splits a string in a unicode-safe way. + * + * @see str_split() + * + * @param string + * + * @return array|false + */ + static function str_split($string, $split_length = 1) { + if ($split_length < 1) { + return FALSE; + } + preg_match_all('/.{1,' . $split_length . '}/u', $string, $matches); + return $matches[0]; + } + + /** + * Reverses a string in a unicode-safe way. + * + * @see strrev() + * + * @param string + * + * @return string + */ + static function strrev($string) { + return implode(array_reverse(self::str_split($string))); + } + + /** + * Gets a replacement symbol for a placeholder. + * + * @param string $symbol + * One of the self::SYMBOL_SPECIAL_* constants. + * + * @return string + */ + function getReplacement($symbol) { + return isset($this->symbol_replacements[$symbol]) ? $this->symbol_replacements[$symbol] : $symbol; + } + + /** + * Checks if a symbol is a special. + * + * @param NumberPatternSymbol $symbol + * @param array $is + * An array of self::SYMBOL_* constants, one of which the symbol should + * match. + * + * @return boolean + */ + function symbolIsSpecial(NumberPatternSymbol $symbol, array $is) { + return !$symbol->escaped && in_array($symbol->symbol, $is, TRUE); + } + + /** + * Replaces placeholders. + * + * @param array $symbols + * An array of NumberPatternSymbol objects which are altered. + * @param array $placeholders + * Characters that should be matched by a NumberPatternSymbol object. + */ + function replacePlaceholders(array $symbols, array $placeholders = array()) { + $placeholders += array( + self::SYMBOL_SPECIAL_GROUPING_SEPARATOR, + self::SYMBOL_SPECIAL_INFINITY, + self::SYMBOL_SPECIAL_MINUS, + self::SYMBOL_SPECIAL_NAN, + self::SYMBOL_SPECIAL_PLUS, + ); + $replacements = array(); + foreach (array_unique($placeholders) as $placeholder) { + $replacements[$placeholder] = $this->getReplacement($placeholder); + } + foreach ($symbols as $symbol) { + foreach ($replacements as $placeholder => $replacement) { + if (!$symbol->replacement && $symbol->symbol == $placeholder) { + $symbol->replacement = $replacement; + } + } + } + } + + /** + * Formats a number. + * + * @param integer|string $number + * + * @return string + */ + public function format($number) { + if ((int) $number != $number) { + throw new \InvalidArgumentException('Number has no valid integer value.'); + } + $sign = (int) ($number < 0); + $number = abs($number); + $digits = str_split($number); + $symbols = $this->cloneNumberPatternSymbols($this->symbols[$sign]); + $this->process($symbols[$sign], $digits); + $this->replacePlaceholders($symbols[$sign]); + $output = ''; + foreach ($symbols[$sign] as $symbol) { + $output .= !is_null($symbol->replacement) ? $symbol->replacement : $symbol->symbol; + } + + return $output; + } + + /** + * Process the pattern's symbols using a number. + * + * @param array $symbols + * An array of NumberPatternSymbol objects that is altered. + * @param array $digits + * The number's digits to use for $symbols. + * + * @return array + * $symbols, but optionally some symbols removed or added. + */ + protected function process(array &$symbols, array $digits) { + // Reverse all data, because we want to process numbers away from the + // decimal separator. + $symbols = array_reverse($symbols); + $digits = array_reverse($digits); + + $last_digit_placeholder_i = 0; + $last_optional_digit_placeholder_i = 0; + foreach ($symbols as $i => $symbol) { + if ($this->symbolIsSpecial($symbol, array(self::SYMBOL_DIGIT, self::SYMBOL_DIGIT_OPTIONAL))) { + $last_digit_placeholder_i = $i; + } + if ($this->symbolIsSpecial($symbol, array(self::SYMBOL_DIGIT_OPTIONAL))) { + $last_optional_digit_placeholder_i = $i; + } + } + $last_grouping_size = 0; + $current_grouping_size = 0; + $last_digit_i = 0; + foreach ($symbols as $i => $symbol) { + // Replace placeholders, but only if we still have digits left to replace + // them with. + if ($digits && $this->symbolIsSpecial($symbol, array(self::SYMBOL_DIGIT, self::SYMBOL_DIGIT_OPTIONAL))) { + // This is the last placeholder, so replace it with all remaining digits. + if ($i == $last_digit_placeholder_i) { + // If the pattern uses groupings, group remaining digits before + // adding them. + if ($last_grouping_size) { + // Make sure the current grouping is full. + while ($current_grouping_size < $last_grouping_size) { + $symbol->replacement = array_shift($digits) . $symbol->replacement; + $current_grouping_size++; + } + // If there are still digits left, add them as new groupings. + if ($digits) { + $chunks = $this->str_split(implode($digits), $last_grouping_size); + foreach (array_reverse($chunks) as $chunk) { + array_splice($symbols, $i + 1, 0, array(new NumberPatternSymbol(strrev($chunk)))); + array_splice($symbols, $i + 1, 0, array(new NumberPatternSymbol(self::SYMBOL_SPECIAL_GROUPING_SEPARATOR))); + } + // We processed all digits, so clear the array. + $digits = array(); + } + } + // The pattern does not use groupings, so add all digits without + // formatting. + else { + $symbol->replacement = strrev(implode($digits)); + } + } + // This is not the last placeholder, so replace it with a single digit. + else { + $symbol->replacement = array_shift($digits); + $current_grouping_size++; + } + $last_digit_i = $i; + } + // Keep track of the last grouping size. + elseif ($this->symbolIsSpecial($symbol, array(self::SYMBOL_SPECIAL_GROUPING_SEPARATOR))) { + $last_grouping_size = $current_grouping_size; + $current_grouping_size = 0; + } + } + + // Removes the last optional digit placeholder and everything between that + // symbol and the last inserted digit. + while ($last_optional_digit_placeholder_i > $last_digit_i) { + unset($symbols[$last_optional_digit_placeholder_i]); + $last_optional_digit_placeholder_i--; + } + + // Put the symbols back in the order we received them in. + $symbols = array_reverse($symbols); + } + + /** + * Clones this formatter's NumberPatternSymbol objects. + * + * @return array + * An array identical to $this->symbols. + */ + function cloneNumberPatternSymbols() { + $clone = array( + self::POSITIVE => array(), + self::NEGATIVE => array(), + ); + foreach ($this->symbols as $sign => $sign_symbols) { + foreach ($sign_symbols as $symbol) { + $clone[$sign][] = clone $symbol; + } + } + + return $clone; + } +} diff --git a/vendor/bartfeenstra/cldr/src/BartFeenstra/CLDR/NumberPatternSymbol.php b/vendor/bartfeenstra/cldr/src/BartFeenstra/CLDR/NumberPatternSymbol.php new file mode 100644 index 0000000..cb56be8 --- /dev/null +++ b/vendor/bartfeenstra/cldr/src/BartFeenstra/CLDR/NumberPatternSymbol.php @@ -0,0 +1,58 @@ +symbol = $symbol; + $this->position = $position; + $this->escaped = $escaped; + } +} \ No newline at end of file diff --git a/vendor/bartfeenstra/cldr/src/BartFeenstra/CLDR/PercentageFormatter.php b/vendor/bartfeenstra/cldr/src/BartFeenstra/CLDR/PercentageFormatter.php new file mode 100644 index 0000000..9717c76 --- /dev/null +++ b/vendor/bartfeenstra/cldr/src/BartFeenstra/CLDR/PercentageFormatter.php @@ -0,0 +1,38 @@ +format($number, $currency_sign); + $this->assertSame($result, $result_expected, 'BartFeenstra\CLDR\CurrencyFormatter::format() formats amount ' . $number . ' as ' . $result_expected . ' using pattern ' . $formatter->pattern . ' (result was ' . $result . ').'); + } +} diff --git a/vendor/bartfeenstra/cldr/src/BartFeenstra/Tests/CLDR/DecimalFormatterTest.php b/vendor/bartfeenstra/cldr/src/BartFeenstra/Tests/CLDR/DecimalFormatterTest.php new file mode 100644 index 0000000..049816d --- /dev/null +++ b/vendor/bartfeenstra/cldr/src/BartFeenstra/Tests/CLDR/DecimalFormatterTest.php @@ -0,0 +1,162 @@ + '.', + )); + $formatter_clone = clone $formatter; + $symbols = $formatter->get('symbols'); + $symbols[DecimalFormatter::POSITIVE][DecimalFormatter::MAJOR][0]->symbol = 'AAA'; + $symbols_clone = $formatter_clone->get('symbols'); + $this->assertNotSame($symbols[DecimalFormatter::POSITIVE][DecimalFormatter::MAJOR][0]->symbol, $symbols_clone[DecimalFormatter::POSITIVE][DecimalFormatter::MAJOR][0]->symbol, 'When a DecimalFormatter is cloned, so are its NumberPatternSymbol elements.'); + } + + /** + * Tests number pattern validation. + */ + function testPatternValidation() { + // Test validating valid number patterns. + $patterns_valid = array( + 'foo.00;bar.00', + ); + foreach ($patterns_valid as $pattern) { + try { + new DecimalFormatter($pattern); + $valid = TRUE; + } + catch (\Exception $e) { + $valid = FALSE; + } + $this->assertTrue($valid, 'BartFeenstra\CLDR\DecimalFormatter::__construct() does not throw an exception for valid pattern ' . $pattern . '.'); + } + + // Test validating invalid number patterns. + $patterns_invalid = array( + // An empty pattern. + '', + // No decimal separator. + 'foo', + 'foo:bar', + // Empty negative pattern. + 'foo.00;', + // Empty positive pattern. + ';bar.00', + ); + foreach ($patterns_invalid as $pattern) { + try { + new DecimalFormatter($pattern); + $valid = TRUE; + } + catch (\Exception $e) { + $valid = FALSE; + } + $this->assertFalse($valid, 'BartFeenstra\CLDR\DecimalFormatter::__construct() throws an exception for invalid pattern ' . $pattern . '.'); + } + } + + /** + * Test amount formatting. + * + * @depends testPatternValidation + */ + function testFormat() { + $numbers = array(123456789, -12345678.9, 1234567.89, -123456.789); + $patterns = array( + // Test inconsistent group sizes and a custom negative pattern. + array( + 'formatter' => new DecimalFormatter('#,##0.00;#,##0.00-', array( + DecimalFormatter::SYMBOL_SPECIAL_DECIMAL_SEPARATOR => ',', + DecimalFormatter::SYMBOL_SPECIAL_GROUPING_SEPARATOR => '.', + )), + 'results' => array( + '123.456.789,00', + '12.345.678,90-', + '1.234.567,89', + '123.456,789-', + ), + ), + // Test without grouping separators, a default negative pattern, no + // decimals, and a pattern that is shorter than the numbers. + array( + 'formatter' => new DecimalFormatter('#0.', array( + DecimalFormatter::SYMBOL_SPECIAL_DECIMAL_SEPARATOR => ',', + DecimalFormatter::SYMBOL_SPECIAL_GROUPING_SEPARATOR => '', + )), + 'results' => array( + '123456789,', + '-12345678,', + '1234567,', + '-123456,', + ), + ), + // Test identical decimal and grouping separators, identical positive + // and negative patterns, and redundant hashes and grouping separators. + array( + 'formatter' => new DecimalFormatter('###,###,###,##0.00;###,###,###,##0.00', array( + DecimalFormatter::SYMBOL_SPECIAL_DECIMAL_SEPARATOR => '.', + DecimalFormatter::SYMBOL_SPECIAL_GROUPING_SEPARATOR => '.', + )), + 'results' => array( + '123.456.789.00', + '12.345.678.90', + '1.234.567.89', + '123.456.789', + ), + ), + // Test some unusual character combinations and positions, and an + // empty decimal separator. + array( + 'formatter' => new DecimalFormatter("####000/@##0.00--;-####000/@##0.00--", array( + DecimalFormatter::SYMBOL_SPECIAL_DECIMAL_SEPARATOR => '', + DecimalFormatter::SYMBOL_SPECIAL_GROUPING_SEPARATOR => '.', + )), + 'results' => array( + '123456/@78900--', + '-12345/@67890--', + '1234/@56789--', + '-123/@456789--', + ), + ), + // Test character escaping. + array( + 'formatter' => new DecimalFormatter("##'#'.00", array( + DecimalFormatter::SYMBOL_SPECIAL_DECIMAL_SEPARATOR => ',', + DecimalFormatter::SYMBOL_SPECIAL_GROUPING_SEPARATOR => '.', + )), + 'results' => array( + '123456789#,00', + '-12345678#,90', + '1234567#,89', + '-123456#,789', + ), + ), + ); + foreach ($patterns as $pattern_info) { + foreach ($numbers as $i => $number) { + $formatter = $pattern_info['formatter']; + $result_expected = $pattern_info['results'][$i]; + $result = $formatter->format($number); + $this->assertSame($result, $result_expected, 'BartFeenstra\CLDR\DecimalFormatter::format() formats amount ' . $number . ' as ' . $result_expected . ' using pattern ' . $formatter->pattern . ' (result was ' . $result . ').'); + } + } + } +} diff --git a/vendor/bartfeenstra/cldr/src/BartFeenstra/Tests/CLDR/IntegerFormatterTest.php b/vendor/bartfeenstra/cldr/src/BartFeenstra/Tests/CLDR/IntegerFormatterTest.php new file mode 100644 index 0000000..14a6fe0 --- /dev/null +++ b/vendor/bartfeenstra/cldr/src/BartFeenstra/Tests/CLDR/IntegerFormatterTest.php @@ -0,0 +1,80 @@ + '.', + )); + $formatter_clone = clone $formatter; + $symbols = $formatter->get('symbols'); + $symbols[IntegerFormatter::POSITIVE][0]->symbol = 'AAA'; + $symbols_clone = $formatter_clone->get('symbols'); + $this->assertNotSame($symbols[IntegerFormatter::POSITIVE][0]->symbol, $symbols_clone[IntegerFormatter::POSITIVE][0]->symbol, 'When an IntegerFormatter is cloned, so are its NumberPatternSymbol elements.'); + } + + /** + * Test amount formatting. + */ + function testFormat() { + $numbers = array(123456789123456789, -123456789123456789); + $patterns = array( + // Test using the decimal separator as a non-special symbol and a custom + // negative pattern. + array( + 'formatter' => new IntegerFormatter('#,##0.00;#,##0.00-', array( + IntegerFormatter::SYMBOL_SPECIAL_GROUPING_SEPARATOR => '.', + )), + 'results' => array( + '123.45678.91234.567.89', + '123.45678.91234.567.89-', + ), + ), + // Test without grouping separators and a default negative pattern. + array( + 'formatter' => new IntegerFormatter('#0.00', array( + IntegerFormatter::SYMBOL_SPECIAL_GROUPING_SEPARATOR => '', + )), + 'results' => array( + '1234567891234567.89', + '-1234567891234567.89', + ), + ), + // Test redundant hashes and escaped hashes.. + array( + 'formatter' => new IntegerFormatter("###,###,###,###,###,###,#'#'##", array( + IntegerFormatter::SYMBOL_SPECIAL_GROUPING_SEPARATOR => '#', + )), + 'results' => array( + '123#456#789#123#456#7#89', + '-123#456#789#123#456#7#89', + ), + ), + ); + foreach ($patterns as $pattern_info) { + foreach ($numbers as $i => $number) { + $formatter = $pattern_info['formatter']; + $result_expected = $pattern_info['results'][$i]; + $result = $formatter->format($number); + $this->assertSame($result, $result_expected, 'BartFeenstra\CLDR\IntegerFormatter::format() formats amount ' . $number . ' as ' . $result_expected . ' using pattern ' . $formatter->pattern . ' (result was ' . $result . ').'); + } + } + } +} diff --git a/vendor/bartfeenstra/cldr/src/BartFeenstra/Tests/CLDR/PercentageFormatterTest.php b/vendor/bartfeenstra/cldr/src/BartFeenstra/Tests/CLDR/PercentageFormatterTest.php new file mode 100644 index 0000000..cfa4493 --- /dev/null +++ b/vendor/bartfeenstra/cldr/src/BartFeenstra/Tests/CLDR/PercentageFormatterTest.php @@ -0,0 +1,29 @@ +format($number); + $this->assertSame($result, $result_expected, 'BartFeenstra\CLDR\PercentageFormatter::format() formats amount ' . $number . ' as ' . $result_expected . ' using pattern ' . $formatter->pattern . ' (result was ' . $result . ').'); + } +} diff --git a/vendor/bartfeenstra/cldr/src/BartFeenstra/Tests/CLDR/TestDecimalFormatter.php b/vendor/bartfeenstra/cldr/src/BartFeenstra/Tests/CLDR/TestDecimalFormatter.php new file mode 100644 index 0000000..949908b --- /dev/null +++ b/vendor/bartfeenstra/cldr/src/BartFeenstra/Tests/CLDR/TestDecimalFormatter.php @@ -0,0 +1,27 @@ +$name; + } +} diff --git a/vendor/bartfeenstra/cldr/src/BartFeenstra/Tests/CLDR/TestIntegerFormatter.php b/vendor/bartfeenstra/cldr/src/BartFeenstra/Tests/CLDR/TestIntegerFormatter.php new file mode 100644 index 0000000..0d0fec4 --- /dev/null +++ b/vendor/bartfeenstra/cldr/src/BartFeenstra/Tests/CLDR/TestIntegerFormatter.php @@ -0,0 +1,27 @@ +$name; + } +} diff --git a/vendor/composer/ClassLoader.php b/vendor/composer/ClassLoader.php new file mode 100644 index 0000000..a4a0dc5 --- /dev/null +++ b/vendor/composer/ClassLoader.php @@ -0,0 +1,207 @@ + + * Jordi Boggiano + * + * For the full copyright and license information, please view the LICENSE + * file that was distributed with this source code. + */ + +namespace Composer\Autoload; + +/** + * ClassLoader implements a PSR-0 class loader + * + * See https://github.com/php-fig/fig-standards/blob/master/accepted/PSR-0.md + * + * $loader = new \Composer\Autoload\ClassLoader(); + * + * // register classes with namespaces + * $loader->add('Symfony\Component', __DIR__.'/component'); + * $loader->add('Symfony', __DIR__.'/framework'); + * + * // activate the autoloader + * $loader->register(); + * + * // to enable searching the include path (eg. for PEAR packages) + * $loader->setUseIncludePath(true); + * + * In this example, if you try to use a class in the Symfony\Component + * namespace or one of its children (Symfony\Component\Console for instance), + * the autoloader will first look for the class under the component/ + * directory, and it will then fallback to the framework/ directory if not + * found before giving up. + * + * This class is loosely based on the Symfony UniversalClassLoader. + * + * @author Fabien Potencier + * @author Jordi Boggiano + */ +class ClassLoader +{ + private $prefixes = array(); + private $fallbackDirs = array(); + private $useIncludePath = false; + private $classMap = array(); + + public function getPrefixes() + { + return $this->prefixes; + } + + public function getFallbackDirs() + { + return $this->fallbackDirs; + } + + public function getClassMap() + { + return $this->classMap; + } + + /** + * @param array $classMap Class to filename map + */ + public function addClassMap(array $classMap) + { + if ($this->classMap) { + $this->classMap = array_merge($this->classMap, $classMap); + } else { + $this->classMap = $classMap; + } + } + + /** + * Registers a set of classes + * + * @param string $prefix The classes prefix + * @param array|string $paths The location(s) of the classes + */ + public function add($prefix, $paths) + { + if (!$prefix) { + foreach ((array) $paths as $path) { + $this->fallbackDirs[] = $path; + } + + return; + } + if (isset($this->prefixes[$prefix])) { + $this->prefixes[$prefix] = array_merge( + $this->prefixes[$prefix], + (array) $paths + ); + } else { + $this->prefixes[$prefix] = (array) $paths; + } + } + + /** + * Turns on searching the include path for class files. + * + * @param bool $useIncludePath + */ + public function setUseIncludePath($useIncludePath) + { + $this->useIncludePath = $useIncludePath; + } + + /** + * Can be used to check if the autoloader uses the include path to check + * for classes. + * + * @return bool + */ + public function getUseIncludePath() + { + return $this->useIncludePath; + } + + /** + * Registers this instance as an autoloader. + * + * @param bool $prepend Whether to prepend the autoloader or not + */ + public function register($prepend = false) + { + spl_autoload_register(array($this, 'loadClass'), true, $prepend); + } + + /** + * Unregisters this instance as an autoloader. + */ + public function unregister() + { + spl_autoload_unregister(array($this, 'loadClass')); + } + + /** + * Loads the given class or interface. + * + * @param string $class The name of the class + * @return bool|null True, if loaded + */ + public function loadClass($class) + { + if ($file = $this->findFile($class)) { + include $file; + + return true; + } + } + + /** + * Finds the path to the file where the class is defined. + * + * @param string $class The name of the class + * + * @return string|null The path, if found + */ + public function findFile($class) + { + if ('\\' == $class[0]) { + $class = substr($class, 1); + } + + if (isset($this->classMap[$class])) { + return $this->classMap[$class]; + } + + if (false !== $pos = strrpos($class, '\\')) { + // namespaced class name + $classPath = str_replace('\\', DIRECTORY_SEPARATOR, substr($class, 0, $pos)) . DIRECTORY_SEPARATOR; + $className = substr($class, $pos + 1); + } else { + // PEAR-like class name + $classPath = null; + $className = $class; + } + + $classPath .= str_replace('_', DIRECTORY_SEPARATOR, $className) . '.php'; + + foreach ($this->prefixes as $prefix => $dirs) { + if (0 === strpos($class, $prefix)) { + foreach ($dirs as $dir) { + if (file_exists($dir . DIRECTORY_SEPARATOR . $classPath)) { + return $dir . DIRECTORY_SEPARATOR . $classPath; + } + } + } + } + + foreach ($this->fallbackDirs as $dir) { + if (file_exists($dir . DIRECTORY_SEPARATOR . $classPath)) { + return $dir . DIRECTORY_SEPARATOR . $classPath; + } + } + + if ($this->useIncludePath && $file = stream_resolve_include_path($classPath)) { + return $file; + } + + return $this->classMap[$class] = false; + } +} diff --git a/vendor/composer/autoload_classmap.php b/vendor/composer/autoload_classmap.php new file mode 100644 index 0000000..4a9177d --- /dev/null +++ b/vendor/composer/autoload_classmap.php @@ -0,0 +1,9 @@ + $vendorDir . '/bartfeenstra/cldr/src', +); diff --git a/vendor/composer/autoload_real.php b/vendor/composer/autoload_real.php new file mode 100644 index 0000000..4c1196c --- /dev/null +++ b/vendor/composer/autoload_real.php @@ -0,0 +1,43 @@ + $path) { + $loader->add($namespace, $path); + } + + $classMap = require __DIR__ . '/autoload_classmap.php'; + if ($classMap) { + $loader->addClassMap($classMap); + } + + $loader->register(); + + return $loader; + } +} diff --git a/vendor/composer/installed.json b/vendor/composer/installed.json new file mode 100644 index 0000000..2cf591d --- /dev/null +++ b/vendor/composer/installed.json @@ -0,0 +1,43 @@ +[ + { + "name": "bartfeenstra/cldr", + "version": "1.x-dev", + "version_normalized": "1.9999999.9999999.9999999-dev", + "source": { + "type": "git", + "url": "https://github.com/bartfeenstra/cldr", + "reference": "dbb0b14b88fb79a43d47750dfca2e248efbdcecd" + }, + "dist": { + "type": "zip", + "url": "https://github.com/bartfeenstra/cldr/archive/dbb0b14b88fb79a43d47750dfca2e248efbdcecd.zip", + "reference": "dbb0b14b88fb79a43d47750dfca2e248efbdcecd", + "shasum": "" + }, + "require": { + "php": ">=5.3.0" + }, + "require-dev": { + "phpunit/phpunit": "3.7.*" + }, + "time": "2012-12-09 14:51:07", + "type": "library", + "installation-source": "dist", + "autoload": { + "psr-0": { + "BartFeenstra": "src" + } + }, + "license": [ + "MIT" + ], + "authors": [ + { + "name": "Bart Feenstra", + "email": "bart@mynameisbart.com", + "homepage": "http://mynameisbart.com", + "role": "Developer" + } + ] + } +]