content_type stringclasses 8
values | main_lang stringclasses 7
values | message stringlengths 1 50 | sha stringlengths 40 40 | patch stringlengths 52 962k | file_count int64 1 300 |
|---|---|---|---|---|---|
PHP | PHP | fix incorrect alias name on joined associations | 22f82f53e8d45e573b13303745009efdc0cf15cf | <ide><path>src/ORM/ResultSet.php
<ide> protected function _groupResult($row)
<ide> $presentAliases[$table] = true;
<ide> }
<ide>
<add> // If the default table is not in the results, set
<add> // it to an empty array so that any contained
<add> // associations hydrate correctly.
<add> if (!isset($results[$defaultAlias])) {
<add> $results[$defaultAlias] = [];
<add> }
<add>
<ide> unset($presentAliases[$defaultAlias]);
<ide>
<ide> foreach ($this->_containMap as $assoc) {
<ide><path>tests/TestCase/ORM/Association/BelongsToTest.php
<ide> public function testAttachToBeforeFindExtraOptions()
<ide> return $q->applyOptions(['something' => 'more']);
<ide> }]);
<ide> }
<add>
<add> /**
<add> * Test that failing to add the foreignKey to the list of fields will throw an
<add> * exception
<add> *
<add> * @return void
<add> */
<add> public function testAttachToNoFieldsSelected()
<add> {
<add> $articles = $this->getTableLocator()->get('Articles');
<add> $association = $articles->belongsTo('Authors');
<add>
<add> $query = $articles->find()
<add> ->select(['Authors.name'])
<add> ->where(['Articles.id' => 1])
<add> ->contain('Authors');
<add> $result = $query->firstOrFail();
<add>
<add> $this->assertNotEmpty($result->author);
<add> $this->assertSame('mariano', $result->author->name);
<add> $this->assertSame(['author'], array_keys($result->toArray()), 'No other properties included.');
<add> }
<ide> }
<ide><path>tests/TestCase/ORM/QueryTest.php
<ide> public function testContainSelectedFields()
<ide> ->contain(['Authors'])
<ide> ->order(['Authors.id' => 'asc'])
<ide> ->select(['Authors.id']);
<del> $results = $query->extract('Authors.id')->toList();
<add> $results = $query->extract('author.id')->toList();
<ide> $expected = [1, 1, 3];
<ide> $this->assertEquals($expected, $results);
<ide> } | 3 |
Python | Python | add pre_save hook in generic views | 8c360770c18ac38a2f4da81a3553fb40592558c4 | <ide><path>rest_framework/mixins.py
<ide> class CreateModelMixin(object):
<ide> def create(self, request, *args, **kwargs):
<ide> serializer = self.get_serializer(data=request.DATA)
<ide> if serializer.is_valid():
<add> self.pre_save(serializer.object)
<ide> self.object = serializer.save()
<ide> return Response(serializer.data, status=status.HTTP_201_CREATED)
<ide> return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
<ide>
<add> def pre_save(self, obj):
<add> pass
<add>
<ide>
<ide> class ListModelMixin(object):
<ide> """
<ide> def list(self, request, *args, **kwargs):
<ide> # which may be `None` to disable pagination.
<ide> page_size = self.get_paginate_by(self.object_list)
<ide> if page_size:
<del> paginator, page, queryset, is_paginated = self.paginate_queryset(self.object_list, page_size)
<add> packed = self.paginate_queryset(self.object_list, page_size)
<add> paginator, page, queryset, is_paginated = packed
<ide> serializer = self.get_pagination_serializer(page)
<ide> else:
<ide> serializer = self.get_serializer(instance=self.object_list)
<ide> def update(self, request, *args, **kwargs):
<ide> serializer = self.get_serializer(data=request.DATA, instance=self.object)
<ide>
<ide> if serializer.is_valid():
<del> if self.object is None:
<del> # If PUT occurs to a non existant object, we need to set any
<del> # attributes on the object that are implicit in the URL.
<del> self.update_urlconf_attributes(serializer.object)
<add> self.pre_save(serializer.object)
<ide> self.object = serializer.save()
<ide> return Response(serializer.data)
<ide>
<ide> return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
<ide>
<del> def update_urlconf_attributes(self, obj):
<add> def pre_save(self, obj):
<ide> """
<del> When update (re)creates an object, we need to set any attributes that
<del> are tied to the URLconf.
<add> Set any attributes on the object that are implicit in the request.
<ide> """
<add> # pk and/or slug attributes are implicit in the URL.
<ide> pk = self.kwargs.get(self.pk_url_kwarg, None)
<ide> if pk:
<ide> setattr(obj, 'pk', pk) | 1 |
Ruby | Ruby | add examples `alert=` and `notice=`, using memes | ebdb8633bfaddfee05b4207e5c51c7cf6a790f7d | <ide><path>actionpack/lib/action_dispatch/middleware/flash.rb
<ide> def [](k)
<ide> end
<ide>
<ide> # Convenience accessor for flash.now[:alert]=
<add> #
<add> # Example:
<add> #
<add> # flash.alert = "Error: no cheezburger"
<add> # # Equivlant to flash[:alert] = "No cheezburger"
<ide> def alert=(message)
<ide> self[:alert] = message
<ide> end
<ide>
<ide> # Convenience accessor for flash.now[:notice]=
<add> #
<add> # Example:
<add> #
<add> # flash.notice = "Bukkit stolen"
<add> # # Equivlant to flash[:notice] = "Bukkit stolen"
<ide> def notice=(message)
<ide> self[:notice] = message
<ide> end | 1 |
Go | Go | fix a wrong word in comment | 9be8bf019419be76e9582188888b80b0940abf74 | <ide><path>pkg/mflag/flag.go
<ide> // will display: `Warning: '-flagname' is deprecated, it will be removed soon. See usage.`
<ide> // so you can only use `-f`.
<ide> //
<del>// You can also group one letter flags, bif you declare
<add>// You can also group one letter flags, if you declare
<ide> // var v = flag.Bool([]string{"v", "-verbose"}, false, "help message for verbose")
<ide> // var s = flag.Bool([]string{"s", "-slow"}, false, "help message for slow")
<ide> // you will be able to use the -vs or -sv | 1 |
Javascript | Javascript | improve error phrasing | 9e0a95e48b22c2853dca841561c12ad5b01e2c59 | <ide><path>bin/convert-argv.js
<ide> module.exports = function(optimist, argv, convertOptions) {
<ide> var webpackOptionsValidationErrors = validateWebpackOptions(options);
<ide>
<ide> if(webpackOptionsValidationErrors.length) {
<del> console.error("Configuration is invalid. Fix the following errors:", webpackOptionsValidationErrors);
<add> console.error("Invalid configuration object. Webpack has been initialised using a configuration object that does not match the API schema. The following checks have failed.", webpackOptionsValidationErrors);
<ide> process.exit(-1); // eslint-disable-line
<ide> }
<ide> }
<ide><path>lib/WebpackOptionsValidationError.js
<ide> function WebpackOptionsValidationError(validationErrors) {
<ide> Error.call(this);
<ide> Error.captureStackTrace(this, WebpackOptionsValidationError);
<ide> this.name = "WebpackOptionsValidationError";
<del> this.message = "Passed 'options' object does not look like a valid webpack configuration.";
<add> this.message = "Invalid configuration object. Webpack has been initialised using a configuration object that does not match the API schema. Inspect validationErrors property of the error to learn what checks have failed.";
<ide> this.validationErrors = validationErrors;
<ide> }
<ide> module.exports = WebpackOptionsValidationError; | 2 |
Javascript | Javascript | check range fix for slowtostring | a04721df66db6d18f35116bcebcd3c2c6ddb2d19 | <ide><path>test/parallel/test-buffer.js
<ide> b.copy(new Buffer(1), 1, 1, 1);
<ide> // try to copy 0 bytes from past the end of the source buffer
<ide> b.copy(new Buffer(1), 0, 2048, 2048);
<ide>
<del>// try to toString() a 0-length slice of a buffer, both within and without the
<del>// valid buffer range
<del>assert.equal(new Buffer('abc').toString('ascii', 0, 0), '');
<del>assert.equal(new Buffer('abc').toString('ascii', -100, -100), '');
<del>assert.equal(new Buffer('abc').toString('ascii', 100, 100), '');
<add>const rangeBuffer = new Buffer('abc');
<add>
<add>// if start >= buffer's length, empty string will be returned
<add>assert.equal(rangeBuffer.toString('ascii', 3), '');
<add>assert.equal(rangeBuffer.toString('ascii', +Infinity), '');
<add>assert.equal(rangeBuffer.toString('ascii', 3.14, 3), '');
<add>assert.equal(rangeBuffer.toString('ascii', 'Infinity', 3), '');
<add>
<add>// if end <= 0, empty string will be returned
<add>assert.equal(rangeBuffer.toString('ascii', 1, 0), '');
<add>assert.equal(rangeBuffer.toString('ascii', 1, -1.2), '');
<add>assert.equal(rangeBuffer.toString('ascii', 1, -100), '');
<add>assert.equal(rangeBuffer.toString('ascii', 1, -Infinity), '');
<add>
<add>// if start < 0, start will be taken as zero
<add>assert.equal(rangeBuffer.toString('ascii', -1, 3), 'abc');
<add>assert.equal(rangeBuffer.toString('ascii', -1.99, 3), 'abc');
<add>assert.equal(rangeBuffer.toString('ascii', -Infinity, 3), 'abc');
<add>assert.equal(rangeBuffer.toString('ascii', '-1', 3), 'abc');
<add>assert.equal(rangeBuffer.toString('ascii', '-1.99', 3), 'abc');
<add>assert.equal(rangeBuffer.toString('ascii', '-Infinity', 3), 'abc');
<add>
<add>// if start is an invalid integer, start will be taken as zero
<add>assert.equal(rangeBuffer.toString('ascii', 'node.js', 3), 'abc');
<add>assert.equal(rangeBuffer.toString('ascii', {}, 3), 'abc');
<add>assert.equal(rangeBuffer.toString('ascii', [], 3), 'abc');
<add>assert.equal(rangeBuffer.toString('ascii', NaN, 3), 'abc');
<add>assert.equal(rangeBuffer.toString('ascii', null, 3), 'abc');
<add>assert.equal(rangeBuffer.toString('ascii', undefined, 3), 'abc');
<add>assert.equal(rangeBuffer.toString('ascii', false, 3), 'abc');
<add>assert.equal(rangeBuffer.toString('ascii', '', 3), 'abc');
<add>
<add>// but, if start is an integer when coerced, then it will be coerced and used.
<add>assert.equal(rangeBuffer.toString('ascii', '-1', 3), 'abc');
<add>assert.equal(rangeBuffer.toString('ascii', '1', 3), 'bc');
<add>assert.equal(rangeBuffer.toString('ascii', '-Infinity', 3), 'abc');
<add>assert.equal(rangeBuffer.toString('ascii', '3', 3), '');
<add>assert.equal(rangeBuffer.toString('ascii', Number(3), 3), '');
<add>assert.equal(rangeBuffer.toString('ascii', '3.14', 3), '');
<add>assert.equal(rangeBuffer.toString('ascii', '1.99', 3), 'bc');
<add>assert.equal(rangeBuffer.toString('ascii', '-1.99', 3), 'abc');
<add>assert.equal(rangeBuffer.toString('ascii', 1.99, 3), 'bc');
<add>assert.equal(rangeBuffer.toString('ascii', true, 3), 'bc');
<add>
<add>// if end > buffer's length, end will be taken as buffer's length
<add>assert.equal(rangeBuffer.toString('ascii', 0, 5), 'abc');
<add>assert.equal(rangeBuffer.toString('ascii', 0, 6.99), 'abc');
<add>assert.equal(rangeBuffer.toString('ascii', 0, Infinity), 'abc');
<add>assert.equal(rangeBuffer.toString('ascii', 0, '5'), 'abc');
<add>assert.equal(rangeBuffer.toString('ascii', 0, '6.99'), 'abc');
<add>assert.equal(rangeBuffer.toString('ascii', 0, 'Infinity'), 'abc');
<add>
<add>// if end is an invalid integer, end will be taken as buffer's length
<add>assert.equal(rangeBuffer.toString('ascii', 0, 'node.js'), '');
<add>assert.equal(rangeBuffer.toString('ascii', 0, {}), '');
<add>assert.equal(rangeBuffer.toString('ascii', 0, NaN), '');
<add>assert.equal(rangeBuffer.toString('ascii', 0, undefined), 'abc');
<add>assert.equal(rangeBuffer.toString('ascii', 0), 'abc');
<add>assert.equal(rangeBuffer.toString('ascii', 0, null), '');
<add>assert.equal(rangeBuffer.toString('ascii', 0, []), '');
<add>assert.equal(rangeBuffer.toString('ascii', 0, false), '');
<add>assert.equal(rangeBuffer.toString('ascii', 0, ''), '');
<add>
<add>// but, if end is an integer when coerced, then it will be coerced and used.
<add>assert.equal(rangeBuffer.toString('ascii', 0, '-1'), '');
<add>assert.equal(rangeBuffer.toString('ascii', 0, '1'), 'a');
<add>assert.equal(rangeBuffer.toString('ascii', 0, '-Infinity'), '');
<add>assert.equal(rangeBuffer.toString('ascii', 0, '3'), 'abc');
<add>assert.equal(rangeBuffer.toString('ascii', 0, Number(3)), 'abc');
<add>assert.equal(rangeBuffer.toString('ascii', 0, '3.14'), 'abc');
<add>assert.equal(rangeBuffer.toString('ascii', 0, '1.99'), 'a');
<add>assert.equal(rangeBuffer.toString('ascii', 0, '-1.99'), '');
<add>assert.equal(rangeBuffer.toString('ascii', 0, 1.99), 'a');
<add>assert.equal(rangeBuffer.toString('ascii', 0, true), 'a');
<ide>
<ide> // try toString() with a object as a encoding
<del>assert.equal(new Buffer('abc').toString({toString: function() {
<add>assert.equal(rangeBuffer.toString({toString: function() {
<ide> return 'ascii';
<ide> }}), 'abc');
<ide> | 1 |
Python | Python | fix lint and object instantiation | eacb989478158c940d0dc9167e2bb4e71eaa2478 | <ide><path>libcloud/compute/drivers/ec2.py
<ide> def ex_delete_keypair(self, keypair):
<ide> warnings.warn('This method has been deprecated in favor of '
<ide> 'delete_key_pair method')
<ide>
<del> keypair = KeyPair(name=keypair, driver=self, public_key='', fingerprint='')
<add> keypair = KeyPair(name=keypair, public_key=None, fingerprint=None,
<add> driver=self)
<ide>
<ide> return self.delete_key_pair(keypair)
<ide> | 1 |
Text | Text | add blog post to v2.1 page | 5944cf10c7b2b7ea399d51dde58cb811a8c3b8b8 | <ide><path>website/docs/usage/v2-1.md
<ide> design changes introduced in [v2.0](/usage/v2). As well as smaller models,
<ide> faster runtime, and many bug fixes, v2.1 also introduces experimental support
<ide> for some exciting new NLP innovations. For the full changelog, see the
<ide> [release notes on GitHub](https://github.com/explosion/spaCy/releases/tag/v2.1.0).
<add>For more details and a behind-the-scenes look at the new release,
<add>[see our blog post](https://explosion.ai/blog/spacy-v2-1).
<ide>
<ide> ### BERT/ULMFit/Elmo-style pre-training {#pretraining tag="experimental"}
<ide> | 1 |
PHP | PHP | use connectioninterface instead of implementation | 64b30a8c493547a9ae07090ee83450a486d3cd06 | <ide><path>src/Illuminate/Database/ConnectionResolver.php
<ide> public function __construct(array $connections = array())
<ide> * Get a database connection instance.
<ide> *
<ide> * @param string $name
<del> * @return \Illuminate\Database\Connection
<add> * @return \Illuminate\Database\ConnectionInterface
<ide> */
<ide> public function connection($name = null)
<ide> {
<ide> public function connection($name = null)
<ide> * Add a connection to the resolver.
<ide> *
<ide> * @param string $name
<del> * @param \Illuminate\Database\Connection $connection
<add> * @param \Illuminate\Database\ConnectionInterface $connection
<ide> * @return void
<ide> */
<del> public function addConnection($name, Connection $connection)
<add> public function addConnection($name, ConnectionInterface $connection)
<ide> {
<ide> $this->connections[$name] = $connection;
<ide> } | 1 |
Text | Text | fix depreciation dates | 26701e2d9fc9e45f39b091351088b6b9a9f019d5 | <ide><path>docs/misc/deprecated.md
<ide> the path does not exist.
<ide> Version 1.9 adds a flag (`--disable-legacy-registry=false`) which prevents the docker daemon from `pull`, `push`, and `login` operations against v1 registries. Though disabled by default, this signals the intent to deprecate the v1 protocol.
<ide>
<ide> ### Docker Content Trust ENV passphrase variables name change
<add>**Deprecated In Release: v1.9**
<add>
<add>**Target For Removal In Release: v1.10**
<ide>
<ide> As of 1.9, Docker Content Trust Offline key will be renamed to Root key and the Tagging key will be renamed to Repository key. Due to this renaming, we're also changing the corresponding environment variables
<ide>
<ide> - DOCKER_CONTENT_TRUST_OFFLINE_PASSPHRASE will now be named DOCKER_CONTENT_TRUST_ROOT_PASSPHRASE
<del>- DOCKER_CONTENT_TRUST_TAGGING_PASSPHRASE will now be named DOCKER_CONTENT_TRUST_REPOSITORY_PASSPHRASE
<ide>\ No newline at end of file
<add>- DOCKER_CONTENT_TRUST_TAGGING_PASSPHRASE will now be named DOCKER_CONTENT_TRUST_REPOSITORY_PASSPHRASE | 1 |
Ruby | Ruby | fix delete_all to remove records directly | e247f3257927e008ed89944249ac38a8838f719f | <ide><path>activerecord/lib/active_record/associations/collection_association.rb
<ide> def delete(*records)
<ide> dependent = _options[:dependent] || options[:dependent]
<ide>
<ide> if records.first == :all
<del> if loaded? || dependent == :destroy
<add> if (loaded? || dependent == :destroy) && dependent != :delete_all
<ide> delete_or_destroy(load_target, dependent)
<ide> else
<ide> delete_records(:all, dependent) | 1 |
Text | Text | fix some ‘cocoapods’ capitalization | 539ff6476a896b79c153972e050db3ef9b0fa2d4 | <ide><path>docs/EmbeddedApp.md
<ide> permalink: docs/embeded-app.html
<ide> next: activityindicatorios
<ide> ---
<ide>
<del>Since React makes no assumptions about the rest of your technology stack – it’s commonly noted as simply the `V` in `MVC` – it’s easily embeddable within an existing non-React Native app. In fact, it integrates with other best practice community tools like [Cocoapods](http://cocoapods.org/).
<add>Since React makes no assumptions about the rest of your technology stack – it’s commonly noted as simply the `V` in `MVC` – it’s easily embeddable within an existing non-React Native app. In fact, it integrates with other best practice community tools like [CocoaPods](http://cocoapods.org/).
<ide>
<ide> ## Requirements
<ide>
<del>- [Cocoapods](http://cocoapods.org/) – `gem install cocoapods`
<add>- [CocoaPods](http://cocoapods.org/) – `gem install cocoapods`
<ide> - [Node.js](http://nodejs.org) – `brew install node`
<ide>
<del>## Install React Native Using Cocoapods
<add>## Install React Native Using CocoaPods
<ide>
<ide> [CocoaPods](http://cocoapods.org/) is a package management tool for iOS/Mac development. We need to use it to download React Native. If you haven't install CocoaPods yet, checkout [this tutorial](http://guides.cocoapods.org/using/getting-started.html).
<ide> | 1 |
Python | Python | add upos as morphological field in ud_train | a6d153b0a0a9dcbefeca906cda37329ca15d7ce2 | <ide><path>spacy/cli/ud/ud_train.py
<ide> def read_data(
<ide> sent["words"].append(word)
<ide> sent["tags"].append(tag)
<ide> sent["morphology"].append(_parse_morph_string(morph))
<add> sent["morphology"][-1].add("POS_%s" % pos)
<ide> sent["heads"].append(head)
<ide> sent["deps"].append("ROOT" if dep == "root" else dep)
<ide> sent["spaces"].append(space_after == "_") | 1 |
Text | Text | use comma after etc | c40113d9cc275ec00062cbc6a48a1ee65381d7f3 | <ide><path>guides/source/active_record_multiple_databases.md
<ide> database you can run `bin/rails db:create:animals`.
<ide> ## Connecting to Databases without Managing Schema and Migrations
<ide>
<ide> If you would like to connect to an external database without any database
<del>management tasks such as schema management, migrations, seeds, etc. you can set
<add>management tasks such as schema management, migrations, seeds, etc., you can set
<ide> the per database config option `database_tasks: false`. By default it is
<ide> set to true.
<ide> | 1 |
Ruby | Ruby | add standalone requirement | 15916338888e48e70edc4ade7f0aff94e3607e76 | <ide><path>Library/Homebrew/requirements.rb
<ide> require "requirement"
<ide> require "requirements/apr_requirement"
<ide> require "requirements/fortran_requirement"
<add>require "requirements/gpg_requirement"
<ide> require "requirements/language_module_requirement"
<ide> require "requirements/minimum_macos_requirement"
<ide> require "requirements/maximum_macos_requirement"
<ide><path>Library/Homebrew/requirements/gpg_requirement.rb
<add>require "requirement"
<add>
<add>class GPGRequirement < Requirement
<add> fatal true
<add> default_formula "gnupg2"
<add>
<add> satisfy(:build_env => false) { gpg2 || gpg }
<add>
<add> # MacGPG2/GPGTools installs GnuPG 2.0.x as a vanilla `gpg` symlink
<add> # pointing to `gpg2`, as do we. Ensure we're actually using a 2.0 `gpg`.
<add> # Temporarily, only support 2.0.x rather than the 2.1.x "modern" series.
<add> def gpg
<add> which_all("gpg").detect do |gpg|
<add> gpg_short_version = Utils.popen_read(gpg, "--version")[/\d\.\d/, 0]
<add> next unless gpg_short_version
<add> Version.create(gpg_short_version.to_s) == Version.create("2.0")
<add> end
<add> end
<add>
<add> def gpg2
<add> which_all("gpg2").detect do |gpg2|
<add> gpg2_short_version = Utils.popen_read(gpg2, "--version")[/\d\.\d/, 0]
<add> next unless gpg2_short_version
<add> Version.create(gpg2_short_version.to_s) == Version.create("2.0")
<add> end
<add> end
<add>end | 2 |
Javascript | Javascript | simplify hmr codepath | 4afeb4310b9004eff46466ad2c86cca4fc8df845 | <ide><path>local-cli/server/util/attachHMRServer.js
<ide> function attachHMRServer({httpServer, path, packagerServer}) {
<ide> entryFile: client.bundleEntry,
<ide> platform: client.platform,
<ide> modules: modulesToUpdate,
<del> });
<add> })
<ide> })
<del> .then(update => {
<del> if (!client) {
<add> .then(bundle => {
<add> if (!client || !bundle) {
<ide> return;
<ide> }
<ide>
<del> // check we actually want to send an HMR update
<del> if (update) {
<add> const hmrUpdate = bundle.getSource();
<add> if (hmrUpdate) {
<ide> return JSON.stringify({
<ide> type: 'update',
<del> body: update,
<add> body: hmrUpdate,
<ide> });
<ide> }
<ide> })
<ide> function attachHMRServer({httpServer, path, packagerServer}) {
<ide>
<ide> return JSON.stringify({type: 'error', body});
<ide> })
<del> .then(bundle => {
<add> .then(update => {
<ide> if (!client) {
<ide> return;
<ide> }
<ide>
<del> // check we actually want to send an HMR update
<del> if (bundle) {
<del> client.ws.send(bundle);
<del> }
<add> client.ws.send(update);
<ide> });
<ide> },
<ide> () => {
<ide><path>packager/react-packager/src/Bundler/Bundle.js
<ide>
<ide> const _ = require('underscore');
<ide> const base64VLQ = require('./base64-vlq');
<add>const BundleBase = require('./BundleBase');
<ide> const UglifyJS = require('uglify-js');
<ide> const ModuleTransport = require('../lib/ModuleTransport');
<ide> const Activity = require('../Activity');
<ide> const getNameAndCode = ({name, code}) => ({name, code});
<ide> const getNameAndMinifiedCode =
<ide> ({name, code}) => ({name, code: minifyCode(code)});
<ide>
<del>class Bundle {
<add>class Bundle extends BundleBase {
<ide> constructor(sourceMapUrl) {
<del> this._finalized = false;
<del> this._modules = [];
<del> this._assets = [];
<add> super();
<ide> this._sourceMap = false;
<ide> this._sourceMapUrl = sourceMapUrl;
<ide> this._shouldCombineSourceMaps = false;
<ide> this._numPrependedModules = 0;
<ide> this._numRequireCalls = 0;
<ide> }
<ide>
<del> setMainModuleId(moduleId) {
<del> this._mainModuleId = moduleId;
<del> }
<del>
<del> addModule(module) {
<del> if (!(module instanceof ModuleTransport)) {
<del> throw new Error('Expeceted a ModuleTransport object');
<del> }
<del>
<del> // If we get a map from the transformer we'll switch to a mode
<del> // were we're combining the source maps as opposed to
<del> if (!this._shouldCombineSourceMaps && module.map != null) {
<del> this._shouldCombineSourceMaps = true;
<del> }
<del>
<del> this._modules.push(module);
<del> }
<add> addModule(resolver, response, module, transformed) {
<add> return resolver.wrapModule(
<add> response,
<add> module,
<add> transformed.code
<add> ).then(({code, name}) => {
<add> const moduleTransport = new ModuleTransport({
<add> code,
<add> name,
<add> map: transformed.map,
<add> sourceCode: transformed.sourceCode,
<add> sourcePath: transformed.sourcePath,
<add> virtual: transformed.virtual,
<add> });
<ide>
<del> getModules() {
<del> return this._modules;
<del> }
<add> // If we get a map from the transformer we'll switch to a mode
<add> // were we're combining the source maps as opposed to
<add> if (!this._shouldCombineSourceMaps && moduleTransport.map != null) {
<add> this._shouldCombineSourceMaps = true;
<add> }
<ide>
<del> getMainModuleId() {
<del> return this._mainModuleId;
<add> super.addModule(moduleTransport);
<add> });
<ide> }
<ide>
<ide> setNumPrependedModules(n) {
<ide> this._numPrependedModules = n;
<ide> }
<ide>
<del> addAsset(asset) {
<del> this._assets.push(asset);
<del> }
<del>
<ide> finalize(options) {
<ide> options = options || {};
<ide> if (options.runMainModule) {
<ide> options.runBeforeMainModule.forEach(this._addRequireCall, this);
<del> this._addRequireCall(this._mainModuleId);
<add> this._addRequireCall(super.getMainModuleId());
<ide> }
<ide>
<del> Object.freeze(this._modules);
<del> Object.seal(this._modules);
<del> Object.freeze(this._assets);
<del> Object.seal(this._assets);
<del> this._finalized = true;
<add> super.finalize();
<ide> }
<ide>
<ide> _addRequireCall(moduleId) {
<ide> const code = ';require("' + moduleId + '");';
<ide> const name = 'require-' + moduleId;
<del> this.addModule(new ModuleTransport({
<add> super.addModule(new ModuleTransport({
<ide> name,
<ide> code,
<ide> virtual: true,
<ide> class Bundle {
<ide> this._numRequireCalls += 1;
<ide> }
<ide>
<del> _assertFinalized() {
<del> if (!this._finalized) {
<del> throw new Error('Bundle needs to be finalized before getting any source');
<del> }
<del> }
<del>
<del> _getSource(dev) {
<del> if (this._source) {
<del> return this._source;
<del> }
<del>
<del> this._source = _.pluck(this._modules, 'code').join('\n');
<del> return this._source;
<del> }
<del>
<ide> _getInlineSourceMap(dev) {
<ide> if (this._inlineSourceMap == null) {
<ide> const sourceMap = this.getSourceMap({excludeSource: true, dev});
<ide> class Bundle {
<ide> }
<ide>
<ide> getSource(options) {
<del> this._assertFinalized();
<add> super.assertFinalized();
<ide>
<ide> options = options || {};
<ide>
<ide> if (options.minify) {
<ide> return this.getMinifiedSourceAndMap(options.dev).code;
<ide> }
<ide>
<del> let source = this._getSource(options.dev);
<add> let source = super.getSource();
<ide>
<ide> if (options.inlineSourceMap) {
<ide> source += SOURCEMAPPING_URL + this._getInlineSourceMap(options.dev);
<ide> class Bundle {
<ide> }
<ide>
<ide> getUnbundle({minify}) {
<del> const allModules = this._modules.slice();
<add> const allModules = super.getModules().slice();
<ide> const prependedModules = this._numPrependedModules;
<ide> const requireCalls = this._numRequireCalls;
<ide>
<ide> class Bundle {
<ide> }
<ide>
<ide> getMinifiedSourceAndMap(dev) {
<del> this._assertFinalized();
<add> super.assertFinalized();
<ide>
<ide> if (this._minifiedSourceAndMap) {
<ide> return this._minifiedSourceAndMap;
<ide> }
<ide>
<del> let source = this._getSource(dev);
<add> let source = this.getSource();
<ide> let map = this.getSourceMap();
<ide>
<ide> if (!dev) {
<ide> class Bundle {
<ide> };
<ide>
<ide> let line = 0;
<del> this._modules.forEach(function(module) {
<add> super.getModules().forEach(function(module) {
<ide> let map = module.map;
<ide> if (module.virtual) {
<ide> map = generateSourceMapForVirtualModule(module);
<ide> class Bundle {
<ide> }
<ide>
<ide> getSourceMap(options) {
<del> this._assertFinalized();
<add> super.assertFinalized();
<ide>
<ide> options = options || {};
<ide>
<ide> class Bundle {
<ide> const mappings = this._getMappings();
<ide> const map = {
<ide> file: 'bundle.js',
<del> sources: _.pluck(this._modules, 'sourcePath'),
<add> sources: _.pluck(super.getModules(), 'sourcePath'),
<ide> version: 3,
<ide> names: [],
<ide> mappings: mappings,
<ide> sourcesContent: options.excludeSource
<del> ? [] : _.pluck(this._modules, 'sourceCode')
<add> ? [] : _.pluck(super.getModules(), 'sourceCode')
<ide> };
<ide> return map;
<ide> }
<ide>
<del> getAssets() {
<del> return this._assets;
<del> }
<del>
<ide> _getMappings() {
<del> const modules = this._modules;
<add> const modules = super.getModules();
<ide>
<ide> // The first line mapping in our package is basically the base64vlq code for
<ide> // zeros (A).
<ide> class Bundle {
<ide> }
<ide>
<ide> getJSModulePaths() {
<del> return this._modules.filter(function(module) {
<add> return super.getModules().filter(function(module) {
<ide> // Filter out non-js files. Like images etc.
<ide> return !module.virtual;
<ide> }).map(function(module) {
<ide> class Bundle {
<ide>
<ide> getDebugInfo() {
<ide> return [
<del> '<div><h3>Main Module:</h3> ' + this._mainModuleId + '</div>',
<add> '<div><h3>Main Module:</h3> ' + super.getMainModuleId() + '</div>',
<ide> '<style>',
<ide> 'pre.collapsed {',
<ide> ' height: 10px;',
<ide> class Bundle {
<ide> '}',
<ide> '</style>',
<ide> '<h3> Module paths and transformed code: </h3>',
<del> this._modules.map(function(m) {
<add> super.getModules().map(function(m) {
<ide> return '<div> <h4> Path: </h4>' + m.sourcePath + '<br/> <h4> Source: </h4>' +
<ide> '<code><pre class="collapsed" onclick="this.classList.remove(\'collapsed\')">' +
<ide> _.escape(m.code) + '</pre></code></div>';
<ide> class Bundle {
<ide> }
<ide>
<ide> return {
<del> modules: this._modules,
<del> assets: this._assets,
<add> ...super.toJSON(),
<ide> sourceMapUrl: this._sourceMapUrl,
<del> mainModuleId: this._mainModuleId,
<add> mainModuleId: super.getMainModuleId(),
<ide> numPrependedModules: this._numPrependedModules,
<ide> numRequireCalls: this._numRequireCalls,
<ide> };
<ide> }
<ide>
<ide> static fromJSON(json) {
<ide> const bundle = new Bundle(json.sourceMapUrl);
<del> bundle._mainModuleId = json.mainModuleId;
<del> bundle._assets = json.assets;
<del> bundle._modules = json.modules;
<add>
<ide> bundle._sourceMapUrl = json.sourceMapUrl;
<ide> bundle._numPrependedModules = json.numPrependedModules;
<ide> bundle._numRequireCalls = json.numRequireCalls;
<ide>
<del> Object.freeze(bundle._modules);
<del> Object.seal(bundle._modules);
<del> Object.freeze(bundle._assets);
<del> Object.seal(bundle._assets);
<del> bundle._finalized = true;
<add> BundleBase.fromJSON(bundle, json);
<ide>
<ide> return bundle;
<ide> }
<ide><path>packager/react-packager/src/Bundler/BundleBase.js
<add>/**
<add> * Copyright (c) 2015-present, Facebook, Inc.
<add> * All rights reserved.
<add> *
<add> * This source code is licensed under the BSD-style license found in the
<add> * LICENSE file in the root directory of this source tree. An additional grant
<add> * of patent rights can be found in the PATENTS file in the same directory.
<add> */
<add>'use strict';
<add>
<add>const _ = require('underscore');
<add>const ModuleTransport = require('../lib/ModuleTransport');
<add>
<add>class BundleBase {
<add> constructor() {
<add> this._finalized = false;
<add> this._modules = [];
<add> this._assets = [];
<add> }
<add>
<add> getMainModuleId() {
<add> return this._mainModuleId;
<add> }
<add>
<add> setMainModuleId(moduleId) {
<add> this._mainModuleId = moduleId;
<add> }
<add>
<add> addModule(module) {
<add> if (!module instanceof ModuleTransport) {
<add> throw new Error('Expeceted a ModuleTransport object');
<add> }
<add>
<add> this._modules.push(module);
<add> }
<add>
<add> getModules() {
<add> return this._modules;
<add> }
<add>
<add> getAssets() {
<add> return this._assets;
<add> }
<add>
<add> addAsset(asset) {
<add> this._assets.push(asset);
<add> }
<add>
<add> finalize(options) {
<add> Object.freeze(this._modules);
<add> Object.seal(this._modules);
<add> Object.freeze(this._assets);
<add> Object.seal(this._assets);
<add> this._finalized = true;
<add> }
<add>
<add> getSource(options) {
<add> this.assertFinalized();
<add>
<add> if (this._source) {
<add> return this._source;
<add> }
<add>
<add> this._source = _.pluck(this._modules, 'code').join('\n');
<add> return this._source;
<add> }
<add>
<add> assertFinalized() {
<add> if (!this._finalized) {
<add> throw new Error('Bundle needs to be finalized before getting any source');
<add> }
<add> }
<add>
<add> toJSON() {
<add> return {
<add> modules: this._modules,
<add> assets: this._assets,
<add> };
<add> }
<add>
<add> static fromJSON(bundle, json) {
<add> bundle._assets = json.assets;
<add> bundle._modules = json.modules;
<add> bundle._mainModuleId = json.mainModuleId;
<add>
<add> Object.freeze(bundle._modules);
<add> Object.seal(bundle._modules);
<add> Object.freeze(bundle._assets);
<add> Object.seal(bundle._assets);
<add> bundle._finalized = true;
<add> }
<add>}
<add>
<add>module.exports = BundleBase;
<ide><path>packager/react-packager/src/Bundler/HMRBundle.js
<add>/**
<add> * Copyright (c) 2015-present, Facebook, Inc.
<add> * All rights reserved.
<add> *
<add> * This source code is licensed under the BSD-style license found in the
<add> * LICENSE file in the root directory of this source tree. An additional grant
<add> * of patent rights can be found in the PATENTS file in the same directory.
<add> */
<add>'use strict';
<add>
<add>const BundleBase = require('./BundleBase');
<add>const ModuleTransport = require('../lib/ModuleTransport');
<add>
<add>class HMRBundle extends BundleBase {
<add> constructor() {
<add> super();
<add> }
<add>
<add> addModule(resolver, response, module, transformed) {
<add> return resolver.resolveRequires(response,
<add> module,
<add> transformed.code,
<add> ).then(({name, code}) => {
<add> code = `
<add> __accept(
<add> '${name}',
<add> function(global, require, module, exports) {
<add> ${code}
<add> }
<add> );
<add> `;
<add>
<add> const moduleTransport = new ModuleTransport({
<add> code,
<add> name,
<add> map: transformed.map,
<add> sourceCode: transformed.sourceCode,
<add> sourcePath: transformed.sourcePath,
<add> virtual: transformed.virtual,
<add> });
<add>
<add> super.addModule(moduleTransport);
<add> });
<add> }
<add>}
<add>
<add>module.exports = HMRBundle;
<ide><path>packager/react-packager/src/Bundler/__tests__/Bundle-test.js
<ide>
<ide> jest.autoMockOff();
<ide>
<del>var SourceMapGenerator = require('source-map').SourceMapGenerator;
<add>const Bundle = require('../Bundle');
<add>const ModuleTransport = require('../../lib/ModuleTransport');
<add>const Promise = require('Promise');
<add>const SourceMapGenerator = require('source-map').SourceMapGenerator;
<add>const UglifyJS = require('uglify-js');
<ide>
<del>var Bundle = require('../Bundle');
<del>var ModuleTransport = require('../../lib/ModuleTransport');
<del>var UglifyJS = require('uglify-js');
<del>
<del>describe('Bundle', function() {
<add>describe('Bundle', () => {
<ide> var bundle;
<ide>
<del> beforeEach(function() {
<add> beforeEach(() => {
<ide> bundle = new Bundle('test_url');
<del> bundle.getSourceMap = jest.genMockFn().mockImpl(function() {
<add> bundle.getSourceMap = jest.genMockFn().mockImpl(() => {
<ide> return 'test-source-map';
<ide> });
<ide> });
<ide>
<del> describe('source bundle', function() {
<del> it('should create a bundle and get the source', function() {
<del> bundle.addModule(new ModuleTransport({
<del> code: 'transformed foo;',
<del> sourceCode: 'source foo',
<del> sourcePath: 'foo path',
<del> }));
<del> bundle.addModule(new ModuleTransport({
<del> code: 'transformed bar;',
<del> sourceCode: 'source bar',
<del> sourcePath: 'bar path',
<del> }));
<del>
<del> bundle.finalize({});
<del> expect(bundle.getSource({dev: true})).toBe([
<del> 'transformed foo;',
<del> 'transformed bar;',
<del> '\/\/# sourceMappingURL=test_url'
<del> ].join('\n'));
<add> describe('source bundle', () => {
<add> pit('should create a bundle and get the source', () => {
<add> return Promise.resolve().then(() => {
<add> return addModule({
<add> bundle,
<add> code: 'transformed foo;',
<add> sourceCode: 'source foo',
<add> sourcePath: 'foo path',
<add> });
<add> }).then(() => {
<add> return addModule({
<add> bundle,
<add> code: 'transformed bar;',
<add> sourceCode: 'source bar',
<add> sourcePath: 'bar path',
<add> });
<add> }).then(() => {
<add> bundle.finalize({});
<add> expect(bundle.getSource({dev: true})).toBe([
<add> 'transformed foo;',
<add> 'transformed bar;',
<add> '\/\/# sourceMappingURL=test_url'
<add> ].join('\n'));
<add> });
<ide> });
<ide>
<del> it('should be ok to leave out the source map url', function() {
<del> var p = new Bundle();
<del> p.addModule(new ModuleTransport({
<del> code: 'transformed foo;',
<del> sourceCode: 'source foo',
<del> sourcePath: 'foo path',
<del> }));
<del> p.addModule(new ModuleTransport({
<del> code: 'transformed bar;',
<del> sourceCode: 'source bar',
<del> sourcePath: 'bar path',
<del> }));
<del>
<del> p.finalize({});
<del> expect(p.getSource({dev: true})).toBe([
<del> 'transformed foo;',
<del> 'transformed bar;',
<del> ].join('\n'));
<add> pit('should be ok to leave out the source map url', () => {
<add> const otherBundle = new Bundle();
<add> return Promise.resolve().then(() => {
<add> return addModule({
<add> bundle: otherBundle,
<add> code: 'transformed foo;',
<add> sourceCode: 'source foo',
<add> sourcePath: 'foo path',
<add> });
<add> }).then(() => {
<add> return addModule({
<add> bundle: otherBundle,
<add> code: 'transformed bar;',
<add> sourceCode: 'source bar',
<add> sourcePath: 'bar path',
<add> });
<add> }).then(() => {
<add> otherBundle.finalize({});
<add> expect(otherBundle.getSource({dev: true})).toBe([
<add> 'transformed foo;',
<add> 'transformed bar;',
<add> ].join('\n'));
<add> });
<ide> });
<ide>
<del> it('should create a bundle and add run module code', function() {
<del> bundle.addModule(new ModuleTransport({
<del> code: 'transformed foo;',
<del> sourceCode: 'source foo',
<del> sourcePath: 'foo path'
<del> }));
<del>
<del> bundle.addModule(new ModuleTransport({
<del> code: 'transformed bar;',
<del> sourceCode: 'source bar',
<del> sourcePath: 'bar path'
<del> }));
<del>
<del> bundle.setMainModuleId('foo');
<del> bundle.finalize({
<del> runBeforeMainModule: ['bar'],
<del> runMainModule: true,
<add> pit('should create a bundle and add run module code', () => {
<add> return Promise.resolve().then(() => {
<add> return addModule({
<add> bundle,
<add> code: 'transformed foo;',
<add> sourceCode: 'source foo',
<add> sourcePath: 'foo path',
<add> });
<add> }).then(() => {
<add> return addModule({
<add> bundle,
<add> code: 'transformed bar;',
<add> sourceCode: 'source bar',
<add> sourcePath: 'bar path',
<add> });
<add> }).then(() => {
<add> bundle.setMainModuleId('foo');
<add> bundle.finalize({
<add> runBeforeMainModule: ['bar'],
<add> runMainModule: true,
<add> });
<add> expect(bundle.getSource({dev: true})).toBe([
<add> 'transformed foo;',
<add> 'transformed bar;',
<add> ';require("bar");',
<add> ';require("foo");',
<add> '\/\/# sourceMappingURL=test_url',
<add> ].join('\n'));
<ide> });
<del> expect(bundle.getSource({dev: true})).toBe([
<del> 'transformed foo;',
<del> 'transformed bar;',
<del> ';require("bar");',
<del> ';require("foo");',
<del> '\/\/# sourceMappingURL=test_url',
<del> ].join('\n'));
<ide> });
<ide>
<del> it('should get minified source', function() {
<del> var minified = {
<add> pit('should get minified source', () => {
<add> const minified = {
<ide> code: 'minified',
<ide> map: 'map',
<ide> };
<ide> describe('Bundle', function() {
<ide> return minified;
<ide> };
<ide>
<del> bundle.addModule(new ModuleTransport({
<del> code: 'transformed foo;',
<del> sourceCode: 'source foo',
<del> sourcePath: 'foo path'
<del> }));
<del> bundle.finalize();
<del> expect(bundle.getMinifiedSourceAndMap({dev: true})).toBe(minified);
<add> return Promise.resolve().then(() => {
<add> return addModule({
<add> bundle,
<add> code: 'transformed foo;',
<add> sourceCode: 'source foo',
<add> sourcePath: 'foo path',
<add> });
<add> }).then(() => {
<add> bundle.finalize();
<add> expect(bundle.getMinifiedSourceAndMap({dev: true})).toBe(minified);
<add> });
<ide> });
<ide> });
<ide>
<del> describe('sourcemap bundle', function() {
<del> it('should create sourcemap', function() {
<del> var p = new Bundle('test_url');
<del> p.addModule(new ModuleTransport({
<del> code: [
<del> 'transformed foo',
<del> 'transformed foo',
<del> 'transformed foo',
<del> ].join('\n'),
<del> sourceCode: [
<del> 'source foo',
<del> 'source foo',
<del> 'source foo',
<del> ].join('\n'),
<del> sourcePath: 'foo path',
<del> }));
<del> p.addModule(new ModuleTransport({
<del> code: [
<del> 'transformed bar',
<del> 'transformed bar',
<del> 'transformed bar',
<del> ].join('\n'),
<del> sourceCode: [
<del> 'source bar',
<del> 'source bar',
<del> 'source bar',
<del> ].join('\n'),
<del> sourcePath: 'bar path',
<del> }));
<add> describe('sourcemap bundle', () => {
<add> pit('should create sourcemap', () => {
<add> const otherBundle = new Bundle('test_url');
<ide>
<del> p.setMainModuleId('foo');
<del> p.finalize({
<del> runBeforeMainModule: [],
<del> runMainModule: true,
<add> return Promise.resolve().then(() => {
<add> return addModule({
<add> bundle: otherBundle,
<add> code: [
<add> 'transformed foo',
<add> 'transformed foo',
<add> 'transformed foo',
<add> ].join('\n'),
<add> sourceCode: [
<add> 'source foo',
<add> 'source foo',
<add> 'source foo',
<add> ].join('\n'),
<add> sourcePath: 'foo path',
<add> });
<add> }).then(() => {
<add> return addModule({
<add> bundle: otherBundle,
<add> code: [
<add> 'transformed bar',
<add> 'transformed bar',
<add> 'transformed bar',
<add> ].join('\n'),
<add> sourceCode: [
<add> 'source bar',
<add> 'source bar',
<add> 'source bar',
<add> ].join('\n'),
<add> sourcePath: 'bar path',
<add> });
<add> }).then(() => {
<add> otherBundle.setMainModuleId('foo');
<add> otherBundle.finalize({
<add> runBeforeMainModule: [],
<add> runMainModule: true,
<add> });
<add> const sourceMap = otherBundle.getSourceMap({dev: true});
<add> expect(sourceMap).toEqual(genSourceMap(otherBundle.getModules()));
<ide> });
<del> var s = p.getSourceMap({dev: true});
<del> expect(s).toEqual(genSourceMap(p.getModules()));
<ide> });
<ide>
<del> it('should combine sourcemaps', function() {
<del> var p = new Bundle('test_url');
<del>
<del> p.addModule(new ModuleTransport({
<del> code: 'transformed foo;\n',
<del> map: {name: 'sourcemap foo'},
<del> sourceCode: 'source foo',
<del> sourcePath: 'foo path'
<del> }));
<del>
<del> p.addModule(new ModuleTransport({
<del> code: 'transformed foo;\n',
<del> map: {name: 'sourcemap bar'},
<del> sourceCode: 'source foo',
<del> sourcePath: 'foo path'
<del> }));
<add> pit('should combine sourcemaps', () => {
<add> const otherBundle = new Bundle('test_url');
<ide>
<del> p.addModule(new ModuleTransport({
<del> code: 'image module;\nimage module;',
<del> virtual: true,
<del> sourceCode: 'image module;\nimage module;',
<del> sourcePath: 'image.png',
<del> }));
<del>
<del> p.setMainModuleId('foo');
<del> p.finalize({
<del> runBeforeMainModule: ['InitializeJavaScriptAppEngine'],
<del> runMainModule: true,
<del> });
<add> return Promise.resolve().then(() => {
<add> return addModule({
<add> bundle: otherBundle,
<add> code: 'transformed foo;\n',
<add> sourceCode: 'source foo',
<add> map: {name: 'sourcemap foo'},
<add> sourcePath: 'foo path',
<add> });
<add> }).then(() => {
<add> return addModule({
<add> bundle: otherBundle,
<add> code: 'transformed bar;\n',
<add> sourceCode: 'source bar',
<add> map: {name: 'sourcemap bar'},
<add> sourcePath: 'bar path',
<add> });
<add> }).then(() => {
<add> return addModule({
<add> bundle: otherBundle,
<add> code: 'image module;\nimage module;',
<add> virtual: true,
<add> sourceCode: 'image module;\nimage module;',
<add> sourcePath: 'image.png',
<add> });
<add> }).then(() => {
<add> otherBundle.setMainModuleId('foo');
<add> otherBundle.finalize({
<add> runBeforeMainModule: ['InitializeJavaScriptAppEngine'],
<add> runMainModule: true,
<add> });
<ide>
<del> var s = p.getSourceMap({dev: true});
<del> expect(s).toEqual({
<del> file: 'bundle.js',
<del> version: 3,
<del> sections: [
<del> { offset: { line: 0, column: 0 }, map: { name: 'sourcemap foo' } },
<del> { offset: { line: 2, column: 0 }, map: { name: 'sourcemap bar' } },
<del> {
<del> offset: {
<del> column: 0,
<del> line: 4
<add> const sourceMap = otherBundle.getSourceMap({dev: true});
<add> expect(sourceMap).toEqual({
<add> file: 'bundle.js',
<add> version: 3,
<add> sections: [
<add> { offset: { line: 0, column: 0 }, map: { name: 'sourcemap foo' } },
<add> { offset: { line: 2, column: 0 }, map: { name: 'sourcemap bar' } },
<add> {
<add> offset: {
<add> column: 0,
<add> line: 4
<add> },
<add> map: {
<add> file: 'image.png',
<add> mappings: 'AAAA;AACA;',
<add> names: [],
<add> sources: [ 'image.png' ],
<add> sourcesContent: ['image module;\nimage module;'],
<add> version: 3,
<add> }
<ide> },
<del> map: {
<del> file: 'image.png',
<del> mappings: 'AAAA;AACA;',
<del> names: [],
<del> sources: [ 'image.png' ],
<del> sourcesContent: ['image module;\nimage module;'],
<del> version: 3,
<del> }
<del> },
<del> {
<del> offset: {
<del> column: 0,
<del> line: 6
<add> {
<add> offset: {
<add> column: 0,
<add> line: 6
<add> },
<add> map: {
<add> file: 'require-InitializeJavaScriptAppEngine.js',
<add> mappings: 'AAAA;',
<add> names: [],
<add> sources: [ 'require-InitializeJavaScriptAppEngine.js' ],
<add> sourcesContent: [';require("InitializeJavaScriptAppEngine");'],
<add> version: 3,
<add> }
<ide> },
<del> map: {
<del> file: 'require-InitializeJavaScriptAppEngine.js',
<del> mappings: 'AAAA;',
<del> names: [],
<del> sources: [ 'require-InitializeJavaScriptAppEngine.js' ],
<del> sourcesContent: [';require("InitializeJavaScriptAppEngine");'],
<del> version: 3,
<del> }
<del> },
<del> {
<del> offset: {
<del> column: 0,
<del> line: 7
<add> {
<add> offset: {
<add> column: 0,
<add> line: 7
<add> },
<add> map: {
<add> file: 'require-foo.js',
<add> mappings: 'AAAA;',
<add> names: [],
<add> sources: [ 'require-foo.js' ],
<add> sourcesContent: [';require("foo");'],
<add> version: 3,
<add> }
<ide> },
<del> map: {
<del> file: 'require-foo.js',
<del> mappings: 'AAAA;',
<del> names: [],
<del> sources: [ 'require-foo.js' ],
<del> sourcesContent: [';require("foo");'],
<del> version: 3,
<del> }
<del> },
<del> ],
<add> ],
<add> });
<ide> });
<ide> });
<ide> });
<ide>
<del> describe('getAssets()', function() {
<del> it('should save and return asset objects', function() {
<add> describe('getAssets()', () => {
<add> it('should save and return asset objects', () => {
<ide> var p = new Bundle('test_url');
<ide> var asset1 = {};
<ide> var asset2 = {};
<ide> describe('Bundle', function() {
<ide> });
<ide> });
<ide>
<del> describe('getJSModulePaths()', function() {
<del> it('should return module paths', function() {
<del> var p = new Bundle('test_url');
<del> p.addModule(new ModuleTransport({
<del> code: 'transformed foo;\n',
<del> sourceCode: 'source foo',
<del> sourcePath: 'foo path'
<del> }));
<del> p.addModule(new ModuleTransport({
<del> code: 'image module;\nimage module;',
<del> virtual: true,
<del> sourceCode: 'image module;\nimage module;',
<del> sourcePath: 'image.png',
<del> }));
<del>
<del> expect(p.getJSModulePaths()).toEqual(['foo path']);
<add> describe('getJSModulePaths()', () => {
<add> pit('should return module paths', () => {
<add> var otherBundle = new Bundle('test_url');
<add> return Promise.resolve().then(() => {
<add> return addModule({
<add> bundle: otherBundle,
<add> code: 'transformed foo;\n',
<add> sourceCode: 'source foo',
<add> sourcePath: 'foo path',
<add> });
<add> }).then(() => {
<add> return addModule({
<add> bundle: otherBundle,
<add> code: 'image module;\nimage module;',
<add> virtual: true,
<add> sourceCode: 'image module;\nimage module;',
<add> sourcePath: 'image.png',
<add> });
<add> }).then(() => {
<add> expect(otherBundle.getJSModulePaths()).toEqual(['foo path']);
<add> });
<ide> });
<ide> });
<ide> });
<ide> function genSourceMap(modules) {
<ide> }
<ide> return sourceMapGen.toJSON();
<ide> }
<add>
<add>function resolverFor(code) {
<add> return {
<add> wrapModule: (response, module, sourceCode) => Promise.resolve(
<add> {name: 'name', code}
<add> ),
<add> };
<add>}
<add>
<add>function addModule({bundle, code, sourceCode, sourcePath, map, virtual}) {
<add> return bundle.addModule(
<add> resolverFor(code),
<add> null,
<add> null,
<add> {sourceCode, sourcePath, map, virtual}
<add> );
<add>}
<ide><path>packager/react-packager/src/Bundler/__tests__/Bundler-test.js
<ide> describe('Bundler', function() {
<ide> runBeforeMainModule: [],
<ide> runModule: true,
<ide> sourceMapUrl: 'source_map_url',
<del> }).then(function(p) {
<del> expect(p.addModule.mock.calls[0][0]).toEqual({
<del> name: 'foo',
<del> code: 'lol transformed /root/foo.js lol',
<del> map: 'sourcemap /root/foo.js',
<del> sourceCode: 'source /root/foo.js',
<del> sourcePath: '/root/foo.js',
<del> });
<add> }).then(bundle => {
<add> const ithAddedModule = (i) => bundle.addModule.mock.calls[i][2].path;
<ide>
<del> expect(p.addModule.mock.calls[1][0]).toEqual({
<del> name: 'bar',
<del> code: 'lol transformed /root/bar.js lol',
<del> map: 'sourcemap /root/bar.js',
<del> sourceCode: 'source /root/bar.js',
<del> sourcePath: '/root/bar.js'
<del> });
<add> expect(ithAddedModule(0)).toEqual('/root/foo.js');
<add> expect(ithAddedModule(1)).toEqual('/root/bar.js');
<add> expect(ithAddedModule(2)).toEqual('/root/img/img.png');
<add> expect(ithAddedModule(3)).toEqual('/root/img/new_image.png');
<add> expect(ithAddedModule(4)).toEqual('/root/file.json');
<add>
<add> expect(bundle.finalize.mock.calls[0]).toEqual([
<add> {runMainModule: true, runBeforeMainModule: []}
<add> ]);
<ide>
<del> var imgModule_DEPRECATED = {
<add> expect(bundle.addAsset.mock.calls).toContain([{
<ide> __packager_asset: true,
<ide> path: '/root/img/img.png',
<ide> uri: 'img',
<ide> width: 25,
<ide> height: 50,
<ide> deprecated: true,
<del> };
<add> }]);
<ide>
<del> expect(p.addModule.mock.calls[2][0]).toEqual({
<del> name: 'image!img',
<del> code: 'lol module.exports = ' +
<del> JSON.stringify(imgModule_DEPRECATED) +
<del> '; lol',
<del> sourceCode: 'module.exports = ' +
<del> JSON.stringify(imgModule_DEPRECATED) +
<del> ';',
<del> sourcePath: '/root/img/img.png',
<del> virtual: true,
<del> map: undefined,
<del> });
<del>
<del> var imgModule = {
<add> expect(bundle.addAsset.mock.calls).toContain([{
<ide> __packager_asset: true,
<ide> fileSystemLocation: '/root/img',
<ide> httpServerLocation: '/assets/img',
<ide> describe('Bundler', function() {
<ide> hash: 'i am a hash',
<ide> name: 'img',
<ide> type: 'png',
<del> };
<del>
<del> expect(p.addModule.mock.calls[3][0]).toEqual({
<del> name: 'new_image.png',
<del> code: 'lol module.exports = require("AssetRegistry").registerAsset(' +
<del> JSON.stringify(imgModule) +
<del> '); lol',
<del> sourceCode: 'module.exports = require("AssetRegistry").registerAsset(' +
<del> JSON.stringify(imgModule) +
<del> ');',
<del> sourcePath: '/root/img/new_image.png',
<del> virtual: true,
<del> map: undefined,
<del> });
<del>
<del> expect(p.addModule.mock.calls[4][0]).toEqual({
<del> name: 'package/file.json',
<del> code: 'lol module.exports = {"json":true}; lol',
<del> sourceCode: 'module.exports = {"json":true};',
<del> sourcePath: '/root/file.json',
<del> map: undefined,
<del> virtual: true,
<del> });
<del>
<del> expect(p.finalize.mock.calls[0]).toEqual([
<del> {runMainModule: true, runBeforeMainModule: []}
<del> ]);
<del>
<del> expect(p.addAsset.mock.calls).toContain([
<del> imgModule_DEPRECATED
<del> ]);
<del>
<del> expect(p.addAsset.mock.calls).toContain([
<del> imgModule
<del> ]);
<add> }]);
<ide>
<ide> // TODO(amasad) This fails with 0 != 5 in OSS
<ide> //expect(ProgressBar.prototype.tick.mock.calls.length).toEqual(modules.length);
<ide><path>packager/react-packager/src/Bundler/index.js
<ide> const Cache = require('../DependencyResolver/Cache');
<ide> const Transformer = require('../JSTransformer');
<ide> const Resolver = require('../Resolver');
<ide> const Bundle = require('./Bundle');
<add>const HMRBundle = require('./HMRBundle');
<ide> const PrepackBundle = require('./PrepackBundle');
<ide> const Activity = require('../Activity');
<ide> const ModuleTransport = require('../lib/ModuleTransport');
<ide> class Bundler {
<ide> return this._bundlesLayout.generateLayout(main, isDev);
<ide> }
<ide>
<del> bundle({
<add> bundle(options) {
<add> return this._bundle({
<add> bundle: new Bundle(options.sourceMapUrl),
<add> includeSystemDependencies: true,
<add> ...options,
<add> });
<add> }
<add>
<add> bundleForHMR(options) {
<add> return this._bundle({
<add> bundle: new HMRBundle(),
<add> hot: true,
<add> ...options,
<add> });
<add> }
<add>
<add> _bundle({
<add> bundle,
<add> modules,
<ide> entryFile,
<ide> runModule: runMainModule,
<ide> runBeforeMainModule,
<del> sourceMapUrl,
<ide> dev: isDev,
<add> includeSystemDependencies,
<ide> platform,
<ide> unbundle: isUnbundle,
<ide> hot: hot,
<ide> }) {
<del> // Const cannot have the same name as the method (babel/babel#2834)
<del> const bbundle = new Bundle(sourceMapUrl);
<ide> const findEventId = Activity.startEvent('find dependencies');
<ide> let transformEventId;
<ide>
<del> const moduleSystem = this._resolver.getModuleSystemDependencies(
<del> { dev: isDev, platform, isUnbundle }
<del> );
<del>
<ide> return this.getDependencies(entryFile, isDev, platform).then((response) => {
<ide> Activity.endEvent(findEventId);
<add> bundle.setMainModuleId(response.mainModuleId);
<ide> transformEventId = Activity.startEvent('transform');
<ide>
<del> // Prepend the module system polyfill to the top of dependencies
<del> var dependencies = moduleSystem.concat(response.dependencies);
<add> const moduleSystemDeps = includeSystemDependencies
<add> ? this._resolver.getModuleSystemDependencies(
<add> { dev: isDev, platform, isUnbundle }
<add> )
<add> : [];
<add>
<add> const modulesToProcess = modules || response.dependencies;
<add> const dependencies = moduleSystemDeps.concat(modulesToProcess);
<add>
<add> bundle.setNumPrependedModules && bundle.setNumPrependedModules(
<add> response.numPrependedDependencies + moduleSystemDeps.length
<add> );
<ide>
<ide> let bar;
<ide> if (process.stdout.isTTY) {
<ide> class Bundler {
<ide> });
<ide> }
<ide>
<del> bbundle.setMainModuleId(response.mainModuleId);
<del> bbundle.setNumPrependedModules(
<del> response.numPrependedDependencies + moduleSystem.length);
<ide> return Promise.all(
<ide> dependencies.map(
<del> module => this._transformModule(
<del> bbundle,
<add> module => {
<add> return this._transformModule(
<add> bundle,
<add> response,
<add> module,
<add> platform,
<add> hot,
<add> ).then(transformed => {
<add> if (bar) {
<add> bar.tick();
<add> }
<add>
<add> return {
<add> module,
<add> transformed,
<add> };
<add> });
<add> }
<add> )
<add> ).then(transformedModules => Promise.all(
<add> transformedModules.map(({module, transformed}) => {
<add> return bundle.addModule(
<add> this._resolver,
<ide> response,
<ide> module,
<del> platform,
<del> hot,
<del> ).then(transformed => {
<del> if (bar) {
<del> bar.tick();
<del> }
<del> return this._wrapTransformedModule(response, module, transformed);
<del> })
<del> )
<del> );
<del> }).then((transformedModules) => {
<add> transformed,
<add> );
<add> })
<add> ));
<add> }).then(() => {
<ide> Activity.endEvent(transformEventId);
<del>
<del> transformedModules.forEach(function(moduleTransport) {
<del> bbundle.addModule(moduleTransport);
<del> });
<del>
<del> bbundle.finalize({runBeforeMainModule, runMainModule});
<del> return bbundle;
<add> bundle.finalize({runBeforeMainModule, runMainModule});
<add> return bundle;
<ide> });
<ide> }
<ide>
<ide> class Bundler {
<ide> });
<ide> }
<ide>
<del> bundleForHMR({entryFile, platform, modules}) {
<del> return this.getDependencies(entryFile, /*isDev*/true, platform)
<del> .then(response => {
<del> return Promise.all(
<del> modules.map(module => {
<del> return Promise.all([
<del> module.getName(),
<del> this._transformModuleForHMR(module, platform),
<del> ]).then(([moduleName, transformed]) => {
<del> return this._resolver.resolveRequires(response,
<del> module,
<del> transformed.code,
<del> ).then(({name, code}) => {
<del> return (`
<del> __accept(
<del> '${moduleName}',
<del> function(global, require, module, exports) {
<del> ${code}
<del> }
<del> );
<del> `);
<del> });
<del> });
<del> })
<del> );
<del> })
<del> .then(modules => modules.join('\n'));
<del> }
<del>
<ide> _transformModuleForHMR(module, platform) {
<ide> if (module.isAsset()) {
<ide> return this._generateAssetObjAndCode(module, platform).then(
<ide> class Bundler {
<ide> }
<ide> }
<ide>
<del> _wrapTransformedModule(response, module, transformed) {
<del> return this._resolver.wrapModule(
<del> response,
<del> module,
<del> transformed.code
<del> ).then(
<del> ({code, name}) => new ModuleTransport({
<del> code,
<del> name,
<del> map: transformed.map,
<del> sourceCode: transformed.sourceCode,
<del> sourcePath: transformed.sourcePath,
<del> virtual: transformed.virtual,
<del> })
<del> );
<del> }
<del>
<ide> getGraphDebugInfo() {
<ide> return this._resolver.getDebugInfo();
<ide> } | 7 |
Javascript | Javascript | reorganize metal to support 2wb in glimmer | 9471527454b30b9a892d6d40f21735365b5a2897 | <ide><path>packages/ember-glimmer/lib/component.js
<ide> import AriaRoleSupport from 'ember-views/mixins/aria_role_support';
<ide> import ViewMixin from 'ember-views/mixins/view_support';
<ide> import EmberView from 'ember-views/views/view';
<ide> import symbol from 'ember-metal/symbol';
<add>import { get } from 'ember-metal/property_get';
<add>import { PROPERTY_DID_CHANGE } from 'ember-metal/property_events';
<add>import { UPDATE } from './utils/references';
<ide> import { DirtyableTag } from 'glimmer-reference';
<ide>
<ide> export const DIRTY_TAG = symbol('DIRTY_TAG');
<add>export const ARGS = symbol('ARGS');
<add>export const IS_DISPATCHING_ATTRS = symbol('IS_DISPATCHING_ATTRS');
<ide>
<ide> export default CoreView.extend(
<ide> ChildViewsSupport,
<ide> export default CoreView.extend(
<ide>
<ide> __defineNonEnumerable(property) {
<ide> this[property.name] = property.descriptor.value;
<add> },
<add>
<add> [IS_DISPATCHING_ATTRS]: false,
<add>
<add> [PROPERTY_DID_CHANGE](key) {
<add> if (this[IS_DISPATCHING_ATTRS]) { return; }
<add>
<add> let args, reference;
<add>
<add> if ((args = this[ARGS]) && (reference = args[key])) {
<add> if (reference[UPDATE]) {
<add> reference[UPDATE](get(this, key));
<add> } else {
<add> let name = this._debugContainerKey.split(':')[1];
<add> let value = get(this, key);
<add> throw new Error(strip`
<add>Cannot set the \`${key}\` property (on component ${name}) to
<add>\`${value}\`. The \`${key}\` property came from an immutable
<add>binding in the template, such as {{${name} ${key}="string"}}
<add>or {{${name} ${key}=(if theTruth "truth" "false")}}.
<add> `);
<add> }
<add> }
<ide> }
<ide> });
<add>
<add>function strip([...strings], ...values) {
<add> let str = strings.map((string, index) => {
<add> let interpolated = values[index];
<add> return string + (interpolated !== undefined ? interpolated : '');
<add> }).join('');
<add> return str.split('\n').map(s => s.trim()).join(' ');
<add>}
<ide><path>packages/ember-glimmer/lib/syntax/curly-component.js
<ide> import { StatementSyntax, ValueReference } from 'glimmer-runtime';
<ide> import { AttributeBindingReference, RootReference, applyClassNameBinding } from '../utils/references';
<del>import { DIRTY_TAG } from '../component';
<add>import { DIRTY_TAG, IS_DISPATCHING_ATTRS } from '../component';
<ide> import { assert } from 'ember-metal/debug';
<add>import isEnabled from 'ember-metal/features';
<add>import { meta as metaFor } from 'ember-metal/meta';
<add>import { watchKey } from 'ember-metal/watch_key';
<ide> import processArgs from '../utils/process-args';
<ide>
<ide> function aliasIdToElementId(args, props) {
<ide> class CurlyComponentManager {
<ide>
<ide> let component = klass.create(props);
<ide>
<add> if (isEnabled('mandatory-setter')) {
<add> let meta = metaFor(component);
<add> let keys = Object.keys(props);
<add>
<add> for (let i = 0; i < keys.length; i++) {
<add> // Watching a key triggers Ember to install the mandatory setter
<add> watchKey(component, keys[i], meta);
<add> }
<add> }
<add>
<ide> dynamicScope.view = component;
<ide> parentView.appendChild(component);
<ide>
<ide> class CurlyComponentManager {
<ide> let oldAttrs = component.attrs;
<ide> let newAttrs = attrs;
<ide>
<add> component[IS_DISPATCHING_ATTRS] = true;
<ide> component.setProperties(props);
<add> component[IS_DISPATCHING_ATTRS] = false;
<ide>
<ide> component.trigger('didUpdateAttrs', { oldAttrs, newAttrs });
<ide> component.trigger('didReceiveAttrs', { oldAttrs, newAttrs });
<ide><path>packages/ember-glimmer/lib/utils/process-args.js
<ide> import { CONSTANT_TAG } from 'glimmer-reference';
<ide> import { assert } from 'ember-metal/debug';
<ide> import EmptyObject from 'ember-metal/empty_object';
<add>import { ARGS } from '../component';
<ide>
<ide> export default function processArgs(args, positionalParamsDefinition) {
<ide> if (!positionalParamsDefinition || positionalParamsDefinition.length === 0 || args.positional.length === 0) {
<ide> const EMPTY_ARGS = {
<ide> tag: CONSTANT_TAG,
<ide>
<ide> value() {
<del> return { attrs: {}, props: { attrs: {} } };
<add> return { attrs: {}, props: { attrs: {}, [ARGS]: {} } };
<ide> }
<ide> };
<ide>
<ide> class SimpleArgs {
<ide> let keys = namedArgs.keys;
<ide> let attrs = namedArgs.value();
<ide> let props = new EmptyObject();
<add> let args = new EmptyObject();
<ide>
<ide> props.attrs = attrs;
<add> props[ARGS] = args;
<ide>
<ide> for (let i = 0, l = keys.length; i < l; i++) {
<ide> let name = keys[i];
<ide> let value = attrs[name];
<ide>
<add> args[name] = namedArgs.get(name);
<ide> props[name] = value;
<ide> }
<ide>
<ide> class RestArgs {
<ide>
<ide> let result = simpleArgs.value();
<ide>
<add> result.props[ARGS] = positionalArgs;
<ide> result.attrs[restArgName] = result.props[restArgName] = positionalArgs.value();
<ide>
<ide> return result;
<ide> class PositionalArgs {
<ide>
<ide> for (let i = 0; i < positionalParamNames.length; i++) {
<ide> let name = positionalParamNames[i];
<del> result.attrs[name] = result.props[name] = positionalArgs.at(i).value();
<add> let reference = result.props[ARGS][name] = positionalArgs.at(i);
<add> result.attrs[name] = result.props[name] = reference.value();
<ide> }
<ide>
<ide> return result;
<ide><path>packages/ember-glimmer/lib/utils/references.js
<ide> import { get } from 'ember-metal/property_get';
<add>import { set } from 'ember-metal/property_set';
<ide> import { tagFor } from 'ember-metal/tags';
<add>import symbol from 'ember-metal/symbol';
<ide> import { CURRENT_TAG, CONSTANT_TAG, VOLATILE_TAG, ConstReference, DirtyableTag, UpdatableTag, combine, isConst } from 'glimmer-reference';
<ide> import { ConditionalReference as GlimmerConditionalReference, NULL_REFERENCE, UNDEFINED_REFERENCE } from 'glimmer-runtime';
<ide> import emberToBool from './to-bool';
<ide> import { RECOMPUTE_TAG } from '../helper';
<ide> import { dasherize } from 'ember-runtime/system/string';
<ide>
<add>export const UPDATE = symbol('UPDATE');
<add>
<ide> // FIXME: fix tests that uses a "fake" proxy (i.e. a POJOs that "happen" to
<ide> // have an `isTruthy` property on them). This is not actually supported –
<ide> // we should fix the tests to use an actual proxy. When that's done, we should
<ide> class PropertyReference extends CachedReference { // jshint ignore:line
<ide> }
<ide> }
<ide>
<add> [UPDATE](value) {
<add> let parent = this._parentReference.value();
<add> set(parent, this._propertyKey, value);
<add> }
<add>
<ide> get(propertyKey) {
<ide> return new PropertyReference(this, propertyKey);
<ide> }
<ide><path>packages/ember-glimmer/tests/integration/components/curly-components-test.js
<ide> /* globals EmberDev */
<add>import isEnabled from 'ember-metal/features';
<ide> import { set } from 'ember-metal/property_set';
<ide> import { observer } from 'ember-metal/mixin';
<ide> import { Component, compile } from '../../utils/helpers';
<ide> moduleFor('Components test: curly components', class extends RenderingTest {
<ide> // this.assertText('blarkporybaz- Click Me');
<ide> }
<ide>
<del> ['@htmlbars a two way binding flows upstream through a CP when consumed in the template']() {
<add> ['@glimmer cannot set an immutable argument']() {
<add> let component;
<add> let FooBarComponent = Component.extend({
<add> init() {
<add> this._super(...arguments);
<add> component = this;
<add> }
<add> });
<add>
<add> this.registerComponent('foo-bar', {
<add> ComponentClass: FooBarComponent,
<add>
<add> template: '{{foo}} – {{bar}}'
<add> });
<add>
<add> this.render('{{foo-bar foo="foo" bar=(concat localBar)}}', {
<add> localBar: 'bar'
<add> });
<add>
<add> this.assertText('foo – bar');
<add>
<add> this.runTask(() => this.rerender());
<add>
<add> this.assertText('foo – bar');
<add>
<add> if (isEnabled('mandatory-setter')) {
<add> expectAssertion(() => {
<add> component.foo = 'new foo';
<add> }, /You must use Ember\.set\(\) to set the `foo` property \(of .+\) to `new foo`\./);
<add>
<add> expectAssertion(() => {
<add> component.bar = 'new bar';
<add> }, /You must use Ember\.set\(\) to set the `bar` property \(of .+\) to `new bar`\./);
<add>
<add> this.assertText('foo – bar');
<add> }
<add>
<add> throws(() => {
<add> this.runTask(() => { component.set('foo', 'new foo'); });
<add> }, 'Cannot set the `foo` property (on component foo-bar) to `new foo`. The `foo` property came from an immutable binding in the template, such as {{foo-bar foo="string"}} or {{foo-bar foo=(if theTruth "truth" "false")}}.');
<add>
<add> throws(() => {
<add> this.runTask(() => { component.set('bar', 'new bar'); });
<add> }, 'Cannot set the `bar` property (on component foo-bar) to `new bar`. The `bar` property came from an immutable binding in the template, such as {{foo-bar bar="string"}} or {{foo-bar bar=(if theTruth "truth" "false")}}.');
<add>
<add> this.assertText('foo – bar');
<add> }
<add>
<add> ['@test a two way binding flows upstream when consumed in the template']() {
<add> let component;
<add> let FooBarComponent = Component.extend({
<add> init() {
<add> this._super(...arguments);
<add> component = this;
<add> }
<add> });
<add>
<add> this.registerComponent('foo-bar', {
<add> ComponentClass: FooBarComponent,
<add>
<add> template: '{{bar}}'
<add> });
<add>
<add> this.render('{{localBar}} - {{foo-bar bar=localBar}}', {
<add> localBar: 'initial value'
<add> });
<add>
<add> this.assertText('initial value - initial value');
<add>
<add> this.runTask(() => this.rerender());
<add>
<add> this.assertText('initial value - initial value');
<add>
<add> if (isEnabled('mandatory-setter')) {
<add> expectAssertion(() => {
<add> component.bar = 'foo-bar';
<add> }, /You must use Ember\.set\(\) to set the `bar` property \(of .+\) to `foo-bar`\./);
<add>
<add> this.assertText('initial value - initial value');
<add> }
<add>
<add> this.runTask(() => { component.set('bar', 'updated value'); });
<add>
<add> this.assertText('updated value - updated value');
<add>
<add> this.runTask(() => { this.component.set('localBar', 'initial value'); });
<add>
<add> this.assertText('initial value - initial value');
<add> }
<add>
<add> ['@test a two way binding flows upstream through a CP when consumed in the template']() {
<ide> let component;
<ide> let FooBarComponent = Component.extend({
<ide> init() {
<ide> moduleFor('Components test: curly components', class extends RenderingTest {
<ide> this.assertText('initial value - initial value');
<ide> }
<ide>
<del> // regression introduced in Ember 1.13
<del> ['@skip a two way binding flows upstream through a CP without template consumption']() {
<add> ['@test a two way binding flows upstream through a CP without template consumption']() {
<ide> let component;
<ide> let FooBarComponent = Component.extend({
<ide> init() {
<ide><path>packages/ember-glimmer/tests/integration/content-test.js
<ide> class DynamicContentTest extends RenderingTest {
<ide> this.assertInvariants();
<ide> }
<ide>
<add> ['@test it can render a computed property with nested dependency']() {
<add> let Formatter = EmberObject.extend({
<add> formattedMessage: computed('messenger.message', function() {
<add> return this.get('messenger.message').toUpperCase();
<add> })
<add> });
<add>
<add> let m = Formatter.create({ messenger: { message: 'hello' } });
<add>
<add> this.renderPath('m.formattedMessage', { m });
<add>
<add> this.assertContent('HELLO');
<add>
<add> this.assertStableRerender();
<add>
<add> this.runTask(() => set(m, 'messenger.message', 'goodbye'));
<add>
<add> this.assertContent('GOODBYE');
<add> this.assertInvariants();
<add>
<add> this.runTask(() => set(this.context, 'm', Formatter.create({ messenger: { message: 'hello' } })));
<add>
<add> this.assertContent('HELLO');
<add> this.assertInvariants();
<add> }
<add>
<ide> ['@test it can read from a null object']() {
<ide> let nullObject = Object.create(null);
<ide> nullObject['message'] = 'hello';
<ide><path>packages/ember-metal/lib/chains.js
<ide> ChainNode.prototype = {
<ide> }
<ide> };
<ide>
<add>import { makeChainNode } from './watch_path';
<add>
<ide> export function finishChains(obj) {
<ide> // We only create meta if we really have to
<ide> let m = peekMeta(obj);
<ide> export function finishChains(obj) {
<ide> // ensure that if we have inherited any chains they have been
<ide> // copied onto our own meta.
<ide> if (m.readableChains()) {
<del> m.writableChains();
<add> m.writableChains(makeChainNode);
<ide> }
<ide> }
<ide> }
<ide><path>packages/ember-metal/lib/computed.js
<ide> ComputedPropertyPrototype._set = function computedPropertySet(obj, keyName, valu
<ide> return ret;
<ide> }
<ide>
<del> let watched = meta.peekWatching(keyName);
<del> if (watched) {
<del> propertyWillChange(obj, keyName);
<del> }
<add> propertyWillChange(obj, keyName);
<ide>
<ide> if (hadCachedValue) {
<ide> cache[keyName] = undefined;
<ide> ComputedPropertyPrototype._set = function computedPropertySet(obj, keyName, valu
<ide> cache[keyName] = ret;
<ide> }
<ide>
<del> if (watched) {
<del> propertyDidChange(obj, keyName);
<del> }
<add> propertyDidChange(obj, keyName);
<ide>
<ide> return ret;
<ide> };
<ide><path>packages/ember-metal/lib/meta.js
<ide> // Remove "use strict"; from transpiled module until
<ide> // https://bugs.webkit.org/show_bug.cgi?id=138038 is fixed
<ide>
<add>import isEnabled from 'ember-metal/features';
<ide> import { protoMethods as listenerMethods } from 'ember-metal/meta_listeners';
<ide> import EmptyObject from 'ember-metal/empty_object';
<add>import { lookupDescriptor } from 'ember-metal/utils';
<add>import symbol from 'ember-metal/symbol';
<ide>
<ide> /**
<ide> @module ember-metal
<ide> function Meta(obj, parentMeta) {
<ide> this._initializeListeners();
<ide> }
<ide>
<add>Meta.prototype.isInitialized = function(obj) {
<add> return this.proto !== obj;
<add>};
<add>
<ide> for (let name in listenerMethods) {
<ide> Meta.prototype[name] = listenerMethods[name];
<ide> }
<ide> Meta.prototype._findInherited = function(key, subkey) {
<ide> }
<ide> };
<ide>
<add>export const UNDEFINED = symbol('undefined');
<ide>
<ide> // Implements a member that provides a lazily created map of maps,
<ide> // with inheritance at both levels.
<ide> var EMBER_META_PROPERTY = {
<ide> descriptor: META_DESC
<ide> };
<ide>
<add>if (isEnabled('mandatory-setter')) {
<add> Meta.prototype.readInheritedValue = function(key, subkey) {
<add> let internalKey = `_${key}`;
<add>
<add> let pointer = this;
<add>
<add> while (pointer !== undefined) {
<add> let map = pointer[internalKey];
<add> if (map) {
<add> let value = map[subkey];
<add> if (value !== undefined || subkey in map) {
<add> return map[subkey];
<add> }
<add> }
<add> pointer = pointer.parent;
<add> }
<add>
<add> return UNDEFINED;
<add> };
<add>
<add> Meta.prototype.writeValue = function(obj, key, value) {
<add> let descriptor = lookupDescriptor(obj, key);
<add> let isMandatorySetter = descriptor && descriptor.set && descriptor.set.isMandatorySetter;
<add>
<add> if (isMandatorySetter) {
<add> this.writeValues(key, value);
<add> } else {
<add> obj[key] = value;
<add> }
<add> };
<add>}
<add>
<ide> // choose the one appropriate for given platform
<ide> let setMeta = function(obj, meta) {
<ide> // if `null` already, just set it to the new value
<ide><path>packages/ember-metal/lib/properties.js
<ide>
<ide> import { assert } from 'ember-metal/debug';
<ide> import isEnabled from 'ember-metal/features';
<del>import { meta as metaFor } from 'ember-metal/meta';
<add>import { meta as metaFor, peekMeta } from 'ember-metal/meta';
<ide> import { overrideChains } from 'ember-metal/property_events';
<ide> // ..........................................................
<ide> // DESCRIPTOR
<ide> const REDEFINE_SUPPORTED = (function () {
<ide>
<ide> export function MANDATORY_SETTER_FUNCTION(name) {
<ide> function SETTER_FUNCTION(value) {
<del> assert(`You must use Ember.set() to set the \`${name}\` property (of ${this}) to \`${value}\`.`, false);
<add> let m = peekMeta(this);
<add> if (!m.isInitialized(this)) {
<add> m.writeValues(name, value);
<add> } else {
<add> assert(`You must use Ember.set() to set the \`${name}\` property (of ${this}) to \`${value}\`.`, false);
<add> }
<ide> }
<ide>
<ide> SETTER_FUNCTION.isMandatorySetter = true;
<ide> export function DEFAULT_GETTER_FUNCTION(name) {
<ide> };
<ide> }
<ide>
<add>import { UNDEFINED } from './meta';
<add>
<ide> export function INHERITING_GETTER_FUNCTION(name) {
<ide> function IGETTER_FUNCTION() {
<del> var proto = Object.getPrototypeOf(this);
<del> return proto && proto[name];
<add> let meta = this['__ember_meta__'];
<add> let val = meta && meta.readInheritedValue('values', name);
<add>
<add> if (val === UNDEFINED) {
<add> var proto = Object.getPrototypeOf(this);
<add> return proto && proto[name];
<add> } else {
<add> return val;
<add> }
<ide> }
<ide>
<ide> IGETTER_FUNCTION.isInheritingGetter = true;
<ide><path>packages/ember-metal/lib/property_events.js
<ide> import {
<ide> sendEvent,
<ide> accumulateListeners
<ide> } from 'ember-metal/events';
<add>import {
<add> markObjectAsDirty
<add>} from './tags';
<ide> import ObserverSet from 'ember-metal/observer_set';
<ide> import symbol from 'ember-metal/symbol';
<ide>
<ide> var deferred = 0;
<ide> */
<ide> function propertyWillChange(obj, keyName) {
<ide> var m = peekMeta(obj);
<del> var watching = (m && m.peekWatching(keyName) > 0) || keyName === 'length';
<del> var proto = m && m.proto;
<del> var possibleDesc = obj[keyName];
<del> var desc = (possibleDesc !== null && typeof possibleDesc === 'object' && possibleDesc.isDescriptor) ? possibleDesc : undefined;
<ide>
<del> if (!watching) {
<add> if (m && !m.isInitialized(obj)) {
<ide> return;
<ide> }
<ide>
<del> if (proto === obj) {
<del> return;
<del> }
<add> var watching = m && m.peekWatching(keyName) > 0;
<add> var possibleDesc = obj[keyName];
<add> var desc = (possibleDesc !== null && typeof possibleDesc === 'object' && possibleDesc.isDescriptor) ? possibleDesc : undefined;
<ide>
<ide> if (desc && desc.willChange) {
<ide> desc.willChange(obj, keyName);
<ide> }
<ide>
<del> dependentKeysWillChange(obj, keyName, m);
<del> chainsWillChange(obj, keyName, m);
<del> notifyBeforeObservers(obj, keyName);
<add> if (watching) {
<add> dependentKeysWillChange(obj, keyName, m);
<add> chainsWillChange(obj, keyName, m);
<add> notifyBeforeObservers(obj, keyName);
<add> }
<ide> }
<ide>
<ide> /**
<ide> function propertyWillChange(obj, keyName) {
<ide> */
<ide> function propertyDidChange(obj, keyName) {
<ide> var m = peekMeta(obj);
<del> var watching = (m && m.peekWatching(keyName) > 0) || keyName === 'length';
<del> var proto = m && m.proto;
<del> var possibleDesc = obj[keyName];
<del> var desc = (possibleDesc !== null && typeof possibleDesc === 'object' && possibleDesc.isDescriptor) ? possibleDesc : undefined;
<ide>
<del> if (proto === obj) {
<add> if (m && !m.isInitialized(obj)) {
<ide> return;
<ide> }
<ide>
<add> var watching = m && m.peekWatching(keyName) > 0;
<add> var possibleDesc = obj[keyName];
<add> var desc = (possibleDesc !== null && typeof possibleDesc === 'object' && possibleDesc.isDescriptor) ? possibleDesc : undefined;
<add>
<ide> // shouldn't this mean that we're watching this key?
<ide> if (desc && desc.didChange) {
<ide> desc.didChange(obj, keyName);
<ide> }
<ide>
<del> if (obj[PROPERTY_DID_CHANGE]) {
<del> obj[PROPERTY_DID_CHANGE](keyName);
<del> }
<add> if (watching) {
<add> if (m.hasDeps(keyName)) {
<add> dependentKeysDidChange(obj, keyName, m);
<add> }
<ide>
<del> if (!watching && keyName !== 'length') {
<del> return;
<add> chainsDidChange(obj, keyName, m, false);
<add> notifyObservers(obj, keyName);
<ide> }
<ide>
<del> if (m && m.hasDeps(keyName)) {
<del> dependentKeysDidChange(obj, keyName, m);
<add> if (obj[PROPERTY_DID_CHANGE]) {
<add> obj[PROPERTY_DID_CHANGE](keyName);
<ide> }
<ide>
<del> chainsDidChange(obj, keyName, m, false);
<del> notifyObservers(obj, keyName);
<add> markObjectAsDirty(m);
<ide> }
<ide>
<add>
<ide> var WILL_SEEN, DID_SEEN;
<ide> // called whenever a property is about to change to clear the cache of any dependent keys (and notify those properties of changes, etc...)
<ide> function dependentKeysWillChange(obj, depKey, meta) {
<ide><path>packages/ember-metal/lib/property_set.js
<ide> import { assert } from 'ember-metal/debug';
<ide> import isEnabled from 'ember-metal/features';
<ide> import { _getPath as getPath } from 'ember-metal/property_get';
<ide> import {
<del> PROPERTY_DID_CHANGE,
<ide> propertyWillChange,
<ide> propertyDidChange
<ide> } from 'ember-metal/property_events';
<del>import { defineProperty } from 'ember-metal/properties';
<add>
<ide> import EmberError from 'ember-metal/error';
<ide> import {
<ide> isPath,
<ide> import {
<ide> } from 'ember-metal/meta';
<ide>
<ide> import {
<del> lookupDescriptor,
<ide> toString
<ide> } from 'ember-metal/utils';
<ide>
<del>import {
<del> markObjectAsDirty
<del>} from './tags';
<del>
<ide> /**
<ide> Sets the value of a property on an object, respecting computed properties
<ide> and notifying observers and other listeners of the change. If the
<ide> export function set(obj, keyName, value, tolerant) {
<ide> `Set must be called with three or four arguments; an object, a property key, a value and tolerant true/false`,
<ide> arguments.length === 3 || arguments.length === 4
<ide> );
<del> assert(`Cannot call set with '${keyName}' on an undefined object.`, obj !== undefined && obj !== null);
<add> assert(`Cannot call set with '${keyName}' on an undefined object.`, obj && typeof obj === 'object' || typeof obj === 'function');
<ide> assert(`The key provided to set must be a string, you passed ${keyName}`, typeof keyName === 'string');
<ide> assert(`'this' in paths is not supported`, !pathHasThis(keyName));
<add> assert(`calling set on destroyed object: ${toString(obj)}.${keyName} = ${toString(value)}`, !obj.isDestroyed);
<ide>
<del> let meta, possibleDesc, desc;
<del>
<del> if (obj) {
<del> meta = peekMeta(obj);
<del> possibleDesc = obj[keyName];
<del> desc = (possibleDesc !== null && typeof possibleDesc === 'object' && possibleDesc.isDescriptor) ? possibleDesc : undefined;
<del> }
<del>
<del> var isUnknown, currentValue;
<del> if (desc === undefined && isPath(keyName)) {
<add> if (isPath(keyName)) {
<ide> return setPath(obj, keyName, value, tolerant);
<ide> }
<ide>
<del> assert(`calling set on destroyed object: ${toString(obj)}.${keyName} = ${toString(value)}`,
<del> !obj.isDestroyed);
<add> let meta = peekMeta(obj);
<add> let possibleDesc = obj[keyName];
<ide>
<del> markObjectAsDirty(meta);
<add> let desc, currentValue;
<add> if (possibleDesc !== null && typeof possibleDesc === 'object' && possibleDesc.isDescriptor) {
<add> desc = possibleDesc;
<add> } else {
<add> currentValue = possibleDesc;
<add> }
<ide>
<del> if (desc) {
<add> if (desc) { /* computed property */
<ide> desc.set(obj, keyName, value);
<add> } else if (obj.setUnknownProperty && currentValue === undefined && !(keyName in obj)) { /* unknown property */
<add> assert('setUnknownProperty must be a function', typeof obj.setUnknownProperty === 'function');
<add> obj.setUnknownProperty(keyName, value);
<add> } else if (currentValue === value) { /* no change */
<add> return value;
<ide> } else {
<del> if (value !== undefined && typeof obj === 'object' && obj[keyName] === value) {
<del> return value;
<del> }
<add> propertyWillChange(obj, keyName);
<ide>
<del> isUnknown = 'object' === typeof obj && !(keyName in obj);
<del>
<del> // setUnknownProperty is called if `obj` is an object,
<del> // the property does not already exist, and the
<del> // `setUnknownProperty` method exists on the object
<del> if (isUnknown && 'function' === typeof obj.setUnknownProperty) {
<del> obj.setUnknownProperty(keyName, value);
<del> } else if (meta && meta.peekWatching(keyName) > 0) {
<del> if (meta.proto !== obj) {
<del> currentValue = obj[keyName];
<del> }
<del> // only trigger a change if the value has changed
<del> if (value !== currentValue) {
<del> propertyWillChange(obj, keyName);
<del>
<del> if (isEnabled('mandatory-setter')) {
<del> if ((currentValue === undefined && !(keyName in obj)) ||
<del> !Object.prototype.propertyIsEnumerable.call(obj, keyName)
<del> ) {
<del> defineProperty(obj, keyName, null, value); // setup mandatory setter
<del> } else {
<del> let descriptor = lookupDescriptor(obj, keyName);
<del> let isMandatorySetter = descriptor && descriptor.set && descriptor.set.isMandatorySetter;
<del> if (isMandatorySetter) {
<del> meta.writeValues(keyName, value);
<del> } else {
<del> obj[keyName] = value;
<del> }
<del> }
<del> } else {
<del> obj[keyName] = value;
<del> }
<del> propertyDidChange(obj, keyName);
<del> }
<add> if (isEnabled('mandatory-setter')) {
<add> setWithMandatorySetter(meta, obj, keyName, value);
<ide> } else {
<ide> obj[keyName] = value;
<del> if (obj[PROPERTY_DID_CHANGE]) {
<del> obj[PROPERTY_DID_CHANGE](keyName);
<del> }
<ide> }
<add>
<add> propertyDidChange(obj, keyName);
<ide> }
<add>
<ide> return value;
<ide> }
<ide>
<add>if (isEnabled('mandatory-setter')) {
<add> var setWithMandatorySetter = function(meta, obj, keyName, value) {
<add> if (meta && meta.peekWatching(keyName) > 0) {
<add> makeEnumerable(obj, keyName);
<add> meta.writeValue(obj, keyName, value);
<add> } else {
<add> obj[keyName] = value;
<add> }
<add> };
<add>
<add> var makeEnumerable = function(obj, key) {
<add> let desc = Object.getOwnPropertyDescriptor(obj, key);
<add>
<add> if (desc && desc.set && desc.set.isMandatorySetter) {
<add> desc.enumerable = true;
<add> Object.defineProperty(obj, key, desc);
<add> }
<add> };
<add>}
<add>
<ide> function setPath(root, path, value, tolerant) {
<ide> var keyName;
<ide>
<ide><path>packages/ember-metal/lib/watch_key.js
<ide> import { lookupDescriptor } from 'ember-metal/utils';
<ide> let handleMandatorySetter;
<ide>
<ide> export function watchKey(obj, keyName, meta) {
<del> // can't watch length on Array - it is special...
<del> if (keyName === 'length' && Array.isArray(obj)) { return; }
<del>
<ide> var m = meta || metaFor(obj);
<ide>
<ide> // activate watching first time
<ide> export function watchKey(obj, keyName, meta) {
<ide>
<ide>
<ide> if (isEnabled('mandatory-setter')) {
<add> let hasOwnProperty = function(obj, key) {
<add> return Object.prototype.hasOwnProperty.call(obj, key);
<add> };
<add>
<add> let propertyIsEnumerable = function(obj, key) {
<add> return Object.prototype.propertyIsEnumerable.call(obj, key);
<add> };
<add>
<ide> // Future traveler, although this code looks scary. It merely exists in
<ide> // development to aid in development asertions. Production builds of
<ide> // ember strip this entire block out
<ide> if (isEnabled('mandatory-setter')) {
<ide> if (configurable && isWritable && hasValue && keyName in obj) {
<ide> let desc = {
<ide> configurable: true,
<del> enumerable: Object.prototype.propertyIsEnumerable.call(obj, keyName),
<ide> set: MANDATORY_SETTER_FUNCTION(keyName),
<add> enumerable: propertyIsEnumerable(obj, keyName),
<ide> get: undefined
<ide> };
<ide>
<del> if (Object.prototype.hasOwnProperty.call(obj, keyName)) {
<add> if (hasOwnProperty(obj, keyName)) {
<ide> m.writeValues(keyName, obj[keyName]);
<ide> desc.get = DEFAULT_GETTER_FUNCTION(keyName);
<ide> } else {
<ide> if (isEnabled('mandatory-setter')) {
<ide> };
<ide> }
<ide>
<add>import { UNDEFINED } from './meta';
<add>
<ide> export function unwatchKey(obj, keyName, meta) {
<ide> var m = meta || metaFor(obj);
<ide> let count = m.peekWatching(keyName);
<ide> export function unwatchKey(obj, keyName, meta) {
<ide>
<ide> if (maybeMandatoryDescriptor.set && maybeMandatoryDescriptor.set.isMandatorySetter) {
<ide> if (maybeMandatoryDescriptor.get && maybeMandatoryDescriptor.get.isInheritingGetter) {
<del> delete obj[keyName];
<del> } else {
<del> Object.defineProperty(obj, keyName, {
<del> configurable: true,
<del> enumerable: Object.prototype.propertyIsEnumerable.call(obj, keyName),
<del> writable: true,
<del> value: m.peekValues(keyName)
<del> });
<del> m.deleteFromValues(keyName);
<add> let possibleValue = m.readInheritedValue('values', keyName);
<add> if (possibleValue === UNDEFINED) {
<add> delete obj[keyName];
<add> return;
<add> }
<ide> }
<add>
<add> Object.defineProperty(obj, keyName, {
<add> configurable: true,
<add> enumerable: Object.prototype.propertyIsEnumerable.call(obj, keyName),
<add> writable: true,
<add> value: m.peekValues(keyName)
<add> });
<add> m.deleteFromValues(keyName);
<ide> }
<ide> }
<ide> }
<ide><path>packages/ember-metal/lib/watch_path.js
<ide> function chainsFor(obj, meta) {
<ide> return (meta || metaFor(obj)).writableChains(makeChainNode);
<ide> }
<ide>
<del>function makeChainNode(obj) {
<add>export function makeChainNode(obj) {
<ide> return new ChainNode(null, null, obj);
<ide> }
<ide>
<ide> export function watchPath(obj, keyPath, meta) {
<del> // can't watch length on Array - it is special...
<del> if (keyPath === 'length' && Array.isArray(obj)) { return; }
<del>
<ide> var m = meta || metaFor(obj);
<ide> let counter = m.peekWatching(keyPath) || 0;
<ide> if (!counter) { // activate watching first time
<ide><path>packages/ember-metal/lib/watching.js
<ide> import {
<ide> @param {String} _keyPath
<ide> */
<ide> function watch(obj, _keyPath, m) {
<del> // can't watch length on Array - it is special...
<del> if (_keyPath === 'length' && Array.isArray(obj)) { return; }
<del>
<ide> if (!isPath(_keyPath)) {
<ide> watchKey(obj, _keyPath, m);
<ide> } else {
<ide> export function watcherCount(obj, key) {
<ide> }
<ide>
<ide> export function unwatch(obj, _keyPath, m) {
<del> // can't watch length on Array - it is special...
<del> if (_keyPath === 'length' && Array.isArray(obj)) { return; }
<del>
<ide> if (!isPath(_keyPath)) {
<ide> unwatchKey(obj, _keyPath, m);
<ide> } else {
<ide><path>packages/ember-metal/tests/watching/watch_test.js
<ide> testBoth('watching "length" property on an array', function(get, set) {
<ide> equal(get(arr, 'length'), 0, 'should have original prop');
<ide>
<ide> set(arr, 'length', '10');
<del> equal(willCount, 0, 'should NOT have invoked willCount');
<del> equal(didCount, 0, 'should NOT have invoked didCount');
<add> equal(willCount, 1, 'should NOT have invoked willCount');
<add> equal(didCount, 1, 'should NOT have invoked didCount');
<ide>
<ide> equal(get(arr, 'length'), 10, 'should get new value');
<ide> equal(arr.length, 10, 'property should be accessible on arr');
<ide><path>packages/ember-runtime/lib/system/native_array.js
<ide> var NativeArray = Mixin.create(MutableArray, Observable, Copyable, {
<ide> // because length is a built-in property we need to know to just get the
<ide> // original property.
<ide> get(key) {
<del> if (key === 'length') {
<del> return this.length;
<del> } else if ('number' === typeof key) {
<add> if ('number' === typeof key) {
<ide> return this[key];
<ide> } else {
<ide> return this._super(key);
<ide><path>packages/ember-runtime/tests/system/object/observer_test.js
<ide> testBoth('chain observer on class that has a reference to an uninitialized objec
<ide> parent.set('one.two', 'new');
<ide>
<ide> equal(changed, true, 'child should have been notified of change to path');
<add>
<add> parent.set('one', { two: 'newer' });
<add>
<add> equal(changed, true, 'child should have been notified of change to path');
<ide> }); | 18 |
Ruby | Ruby | fix directory leak in test_cleaner | 4d14cafaa543ebeb133d65a6e82967509c223ae8 | <ide><path>Library/Homebrew/test/test_cleaner.rb
<ide> def setup
<ide> end
<ide>
<ide> def teardown
<del> @f.prefix.rmtree if @f.prefix.exist?
<add> @f.rack.rmtree if @f.rack.exist?
<ide> end
<ide>
<ide> def test_clean_file | 1 |
PHP | PHP | fix publishing visibility | f2ce3d50073eedb49c806a6f2f0049b58b3b04bc | <ide><path>src/Illuminate/Foundation/Console/VendorPublishCommand.php
<ide> use League\Flysystem\Filesystem as Flysystem;
<ide> use League\Flysystem\Local\LocalFilesystemAdapter as LocalAdapter;
<ide> use League\Flysystem\MountManager;
<add>use League\Flysystem\UnixVisibility\PortableVisibilityConverter;
<add>use League\Flysystem\Visibility;
<ide>
<ide> class VendorPublishCommand extends Command
<ide> {
<ide> protected function publishFile($from, $to)
<ide> */
<ide> protected function publishDirectory($from, $to)
<ide> {
<add> $visibility = PortableVisibilityConverter::fromArray([], Visibility::PUBLIC);
<add>
<ide> $this->moveManagedFiles(new MountManager([
<ide> 'from' => new Flysystem(new LocalAdapter($from)),
<del> 'to' => new Flysystem(new LocalAdapter($to)),
<add> 'to' => new Flysystem(new LocalAdapter($to, $visibility)),
<ide> ]));
<ide>
<ide> $this->status($from, $to, 'Directory'); | 1 |
Mixed | Python | add script to generate chart changelog annotations | c56835304318f0695c79ac42df7a97ad05ccd21e | <ide><path>dev/README_RELEASE_HELM_CHART.md
<ide> commits between the last release, `1.1.0`, and `main`:
<ide> git log --oneline helm-chart/1.1.0..main --pretty='format:- %s' -- chart/ docs/helm-chart/
<ide> ```
<ide>
<add>### Add changelog annotations to `Chart.yaml`
<add>
<add>Once the changelog has been built, run the script to generate the changelog annotations.
<add>
<add>```shell
<add>./dev/chart/build_changelog_annotations.py
<add>```
<add>
<add>Verify the output looks right (only entries from this release), then put them in `Chart.yaml`, for example:
<add>
<add>```yaml
<add>annotations:
<add> artifacthub.io/changes: |
<add> - kind: added
<add> description: Add resources for `cleanup` and `createuser` jobs
<add> links:
<add> - name: "#19263"
<add> url: https://github.com/apache/airflow/pull/19263
<add>```
<add>
<ide> ## Build RC artifacts
<ide>
<ide> The Release Candidate artifacts we vote upon should be the exact ones we vote against,
<ide><path>dev/chart/build_changelog_annotations.py
<add>#!/usr/bin/env python3
<add>
<add># Licensed to the Apache Software Foundation (ASF) under one
<add># or more contributor license agreements. See the NOTICE file
<add># distributed with this work for additional information
<add># regarding copyright ownership. The ASF licenses this file
<add># to you under the Apache License, Version 2.0 (the
<add># "License"); you may not use this file except in compliance
<add># with the License. You may obtain a copy of the License at
<add>#
<add># http://www.apache.org/licenses/LICENSE-2.0
<add>#
<add># Unless required by applicable law or agreed to in writing,
<add># software distributed under the License is distributed on an
<add># "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
<add># KIND, either express or implied. See the License for the
<add># specific language governing permissions and limitations
<add># under the License.
<add>
<add>'''
<add>Take normal chart CHANGELOG entries and build ArtifactHub changelog annotations.
<add>Only outputs the annotations for the latest release in the CHANGELOG.
<add>
<add>e.g from:
<add>
<add>New Features
<add>""""""""""""
<add>
<add>- Add resources for `cleanup` and `createuser` jobs (#19263)
<add>
<add>to:
<add>
<add>- kind: added
<add> description: Add resources for `cleanup` and `createuser` jobs
<add> links:
<add> - name: "#19263"
<add> url: https://github.com/apache/airflow/pull/19263
<add>'''
<add>
<add>
<add>import re
<add>from typing import Dict, List, Optional, Tuple, Union
<add>
<add>import yaml
<add>
<add>TYPE_MAPPING = {
<add> # CHANGELOG: (ArtifactHub kind, prefix for description)
<add> # ArtifactHub kind must be one of: added, changed, deprecated, removed, fixed or security
<add> "New Features": ("added", None),
<add> "Improvements": ("changed", None),
<add> "Bug Fixes": ("fixed", None),
<add> "Doc only changes": ("changed", "Docs"),
<add> "Misc": ("changed", "Misc"),
<add>}
<add>
<add>PREFIXES_TO_STRIP = [
<add> # case insensitive
<add> "Chart:",
<add> "Chart Docs:",
<add>]
<add>
<add>
<add>def parse_line(line: str) -> Tuple[Optional[str], Optional[int]]:
<add> match = re.search(r'^- (.*?)(?:\(#(\d+)\)){0,1}$', line)
<add> if not match:
<add> return None, None
<add> desc, pr_number = match.groups()
<add> return desc.strip(), int(pr_number)
<add>
<add>
<add>def print_entry(section: str, description: str, pr_number: Optional[int]):
<add> for unwanted_prefix in PREFIXES_TO_STRIP:
<add> if description.lower().startswith(unwanted_prefix.lower()):
<add> description = description[len(unwanted_prefix) :].strip()
<add>
<add> kind, prefix = TYPE_MAPPING[section]
<add> if prefix:
<add> description = f"{prefix}: {description}"
<add> entry: Dict[str, Union[str, List]] = {"kind": kind, "description": description}
<add> if pr_number:
<add> entry["links"] = [
<add> {"name": f"#{pr_number}", "url": f"https://github.com/apache/airflow/pull/{pr_number}"}
<add> ]
<add> print(yaml.dump([entry]))
<add>
<add>
<add>in_first_release = False
<add>section = ""
<add>with open("chart/CHANGELOG.txt") as f:
<add> for line in f:
<add> line = line.strip()
<add> if not line:
<add> continue
<add> if line.startswith("Airflow Helm Chart"):
<add> # We only want to get annotations for the "latest" release
<add> if in_first_release:
<add> break
<add> in_first_release = True
<add> continue
<add> if line.startswith('"""') or line.startswith('----'):
<add> continue
<add> if not line.startswith('- '):
<add> section = line
<add> continue
<add>
<add> description, pr = parse_line(line)
<add> if description:
<add> print_entry(section, description, pr) | 2 |
Python | Python | add error message concerning revision | 401377e6796a5939bbd4cd6c3b8d8d00ca33495d | <ide><path>src/transformers/configuration_utils.py
<ide> def get_config_dict(
<ide> f"- '{pretrained_model_name_or_path}' is a correct model identifier listed on 'https://huggingface.co/models'\n\n"
<ide> f"- or '{pretrained_model_name_or_path}' is the correct path to a directory containing a {CONFIG_NAME} file\n\n"
<ide> )
<add>
<add> if revision is not None:
<add> msg += f"- or '{revision}' is a valid git identifier (branch name, a tag name, or a commit id) that exists for this model name as listed on its model page on 'https://huggingface.co/models'\n\n"
<add>
<ide> raise EnvironmentError(msg)
<ide>
<ide> except json.JSONDecodeError:
<ide><path>src/transformers/modeling_utils.py
<ide> def from_pretrained(cls, pretrained_model_name_or_path: Optional[Union[str, os.P
<ide> msg = (
<ide> f"Can't load weights for '{pretrained_model_name_or_path}'. Make sure that:\n\n"
<ide> f"- '{pretrained_model_name_or_path}' is a correct model identifier listed on 'https://huggingface.co/models'\n\n"
<del> f"- or '{pretrained_model_name_or_path}' is the correct path to a directory containing a file named one of {WEIGHTS_NAME}, {TF2_WEIGHTS_NAME}, {TF_WEIGHTS_NAME}.\n\n"
<add> f"- or '{pretrained_model_name_or_path}' is the correct path to a directory containing a file named one of {WEIGHTS_NAME}, {TF2_WEIGHTS_NAME}, {TF_WEIGHTS_NAME}\n\n"
<ide> )
<add>
<add> if revision is not None:
<add> msg += f"- or '{revision}' is a valid git identifier (branch name, a tag name, or a commit id) that exists for this model name as listed on its model page on 'https://huggingface.co/models'\n\n"
<add>
<ide> raise EnvironmentError(msg)
<ide>
<ide> if resolved_archive_file == archive_file:
<ide><path>src/transformers/tokenization_utils_base.py
<ide> def from_pretrained(cls, pretrained_model_name_or_path: Union[str, os.PathLike],
<ide> f"- '{pretrained_model_name_or_path}' is a correct model identifier listed on 'https://huggingface.co/models'\n\n"
<ide> f"- or '{pretrained_model_name_or_path}' is the correct path to a directory containing relevant tokenizer files\n\n"
<ide> )
<add>
<add> if revision is not None:
<add> msg += f"- or '{revision}' is a valid git identifier (branch name, a tag name, or a commit id) that exists for this model name as listed on its model page on 'https://huggingface.co/models'\n\n"
<add>
<ide> raise EnvironmentError(msg)
<ide>
<ide> for file_id, file_path in vocab_files.items(): | 3 |
Go | Go | fix mutex copy | 46077fcfb13008dd8692c4be5180104dfbfe5e39 | <ide><path>libnetwork/drivers/overlay/overlay.go
<ide> func Init(dc driverapi.DriverCallback, config map[string]interface{}) error {
<ide> d := &driver{
<ide> networks: networkTable{},
<ide> peerDb: peerNetworkMap{
<del> mp: map[string]peerMap{},
<add> mp: map[string]*peerMap{},
<ide> },
<ide> config: config,
<ide> }
<ide><path>libnetwork/drivers/overlay/peerdb.go
<ide> type peerMap struct {
<ide> }
<ide>
<ide> type peerNetworkMap struct {
<del> mp map[string]peerMap
<add> mp map[string]*peerMap
<ide> sync.Mutex
<ide> }
<ide>
<ide> func (d *driver) peerDbAdd(nid, eid string, peerIP net.IP, peerIPMask net.IPMask
<ide> d.peerDb.Lock()
<ide> pMap, ok := d.peerDb.mp[nid]
<ide> if !ok {
<del> d.peerDb.mp[nid] = peerMap{
<add> d.peerDb.mp[nid] = &peerMap{
<ide> mp: make(map[string]peerEntry),
<ide> }
<ide> | 2 |
Javascript | Javascript | fix test-worker-memory.js for large cpu #s | f96a6608eb63f4c6710c9c2078916655e32cf003 | <ide><path>test/parallel/test-worker-memory.js
<ide> const assert = require('assert');
<ide> const util = require('util');
<ide> const { Worker } = require('worker_threads');
<ide>
<del>const numWorkers = +process.env.JOBS || require('os').cpus().length;
<add>let numWorkers = +process.env.JOBS || require('os').cpus().length;
<add>if (numWorkers > 20) {
<add> // Cap the number of workers at 20 (as an even divisor of 60 used as
<add> // the total number of workers started) otherwise the test fails on
<add> // machines with high core counts.
<add> numWorkers = 20;
<add>}
<ide>
<ide> // Verify that a Worker's memory isn't kept in memory after the thread finishes.
<ide> | 1 |
Python | Python | add special tokens to gpt-2 | c30139a013f8d65dc691efaac107691bb798419e | <ide><path>pytorch_pretrained_bert/modeling_gpt2.py
<ide> class GPT2Config(object):
<ide> def __init__(
<ide> self,
<ide> vocab_size_or_config_json_file=50257,
<add> n_special=0,
<ide> n_positions=1024,
<ide> n_ctx=1024,
<ide> n_embd=768,
<ide> def __init__(
<ide>
<ide> Args:
<ide> vocab_size_or_config_json_file: Vocabulary size of `inputs_ids` in `GPT2Model` or a configuration json file.
<add> n_special: The number of special tokens to learn during fine-tuning ('[SEP]', '[CLF]', ...)
<ide> n_positions: Number of positional embeddings.
<ide> n_ctx: Size of the causal mask (usually same as n_positions).
<ide> n_embd: Dimensionality of the embeddings and hidden states.
<ide> def __init__(
<ide> self.__dict__[key] = value
<ide> elif isinstance(vocab_size_or_config_json_file, int):
<ide> self.vocab_size = vocab_size_or_config_json_file
<add> self.n_special = n_special
<ide> self.n_ctx = n_ctx
<ide> self.n_positions = n_positions
<ide> self.n_embd = n_embd
<ide> def __init__(
<ide> "or the path to a pretrained model config file (str)"
<ide> )
<ide>
<add> @property
<add> def total_tokens_embeddings(self):
<add> return self.vocab_size + self.n_special
<add>
<ide> @classmethod
<ide> def from_dict(cls, json_object):
<ide> """Constructs a `GPT2Config` from a Python dictionary of parameters."""
<ide> class GPT2LMHead(nn.Module):
<ide> def __init__(self, model_embeddings_weights, config):
<ide> super(GPT2LMHead, self).__init__()
<ide> self.n_embd = config.n_embd
<add> embed_shape = model_embeddings_weights.shape
<add> self.decoder = nn.Linear(embed_shape[1], embed_shape[0], bias=False)
<ide> self.set_embeddings_weights(model_embeddings_weights)
<ide>
<ide> def set_embeddings_weights(self, model_embeddings_weights):
<ide> embed_shape = model_embeddings_weights.shape
<del> self.decoder = nn.Linear(embed_shape[1], embed_shape[0], bias=False)
<ide> self.decoder.weight = model_embeddings_weights # Tied weights
<ide>
<ide> def forward(self, hidden_state):
<ide> def __init__(self, config, *inputs, **kwargs):
<ide> )
<ide> self.config = config
<ide>
<del> def set_tied(self):
<add> def set_num_special_tokens(self, num_special_tokens):
<ide> pass
<ide>
<ide> def init_weights(self, module):
<ide> def load(module, prefix=""):
<ide> "Error(s) in loading state_dict for {}:\n\t{}".format(model.__class__.__name__, "\n\t".join(error_msgs))
<ide> )
<ide>
<del> # Make sure we are still sharing the output and input embeddings after loading weights
<del> model.set_tied()
<add> # Add additional embeddings for special tokens if needed
<add> # This step also make sure we are still sharing the output and input embeddings after loading weights
<add> model.set_num_special_tokens(num_special_tokens if num_special_tokens is not None else config.n_special)
<ide> return model
<ide>
<ide>
<ide> class GPT2Model(GPT2PreTrainedModel):
<ide> """OpenAI GPT-2 model ("Language Models are Unsupervised Multitask Learners").
<ide>
<add> GPT-2 use a single embedding matrix to store the word and special embeddings.
<add> Special tokens embeddings are additional tokens that are not pre-trained: [SEP], [CLS]...
<add> Special tokens need to be trained during the fine-tuning if you use them.
<add> The number of special embeddings can be controled using the `set_num_special_tokens(num_special_tokens)` function.
<add>
<add> The embeddings are ordered as follow in the token embeddings matrice:
<add> [0, ----------------------
<add> ... -> word embeddings
<add> config.vocab_size - 1, ______________________
<add> config.vocab_size,
<add> ... -> special embeddings
<add> config.vocab_size + config.n_special - 1] ______________________
<add>
<add> where total_tokens_embeddings can be obtained as config.total_tokens_embeddings and is:
<add> total_tokens_embeddings = config.vocab_size + config.n_special
<add> You should use the associate indices to index the embeddings.
<add>
<ide> Params:
<ide> config: a GPT2Config class instance with the configuration to build a new model
<ide>
<ide> def __init__(self, config):
<ide>
<ide> self.apply(self.init_weights)
<ide>
<add> def set_num_special_tokens(self, num_special_tokens):
<add> " Update input embeddings with new embedding matrice if needed "
<add> if self.config.n_special == num_special_tokens:
<add> return
<add> # Update config
<add> self.config.n_special = num_special_tokens
<add> # Build new embeddings and initialize all new embeddings (in particular the special tokens)
<add> old_embed = self.wte
<add> self.wte = nn.Embedding(self.config.total_tokens_embeddings, self.config.n_embd)
<add> self.wte.to(old_embed.weight.device)
<add> self.init_weights(self.wte)
<add> # Copy word embeddings from the previous weights
<add> self.wte.weight.data[:self.config.vocab_size, :] = old_embed.weight.data[:self.config.vocab_size, :]
<add>
<ide> def forward(self, input_ids, position_ids=None, token_type_ids=None, past=None):
<ide> if past is None:
<ide> past_length = 0
<ide> def __init__(self, config):
<ide> self.lm_head = GPT2LMHead(self.transformer.wte.weight, config)
<ide> self.apply(self.init_weights)
<ide>
<del> def set_tied(self):
<del> """ Make sure we are sharing the embeddings
<add> def set_num_special_tokens(self, num_special_tokens):
<add> """ Update input and output embeddings with new embedding matrice
<add> Make sure we are sharing the embeddings
<ide> """
<add> self.transformer.set_num_special_tokens(num_special_tokens)
<ide> self.lm_head.set_embeddings_weights(self.transformer.wte.weight)
<ide>
<ide> def forward(self, input_ids, position_ids=None, token_type_ids=None, lm_labels=None, past=None):
<ide> def __init__(self, config):
<ide> self.multiple_choice_head = GPT2MultipleChoiceHead(config)
<ide> self.apply(self.init_weights)
<ide>
<del> def set_tied(self):
<del> """ Make sure we are sharing the embeddings
<add> def set_num_special_tokens(self, num_special_tokens):
<add> """ Update input and output embeddings with new embedding matrice
<add> Make sure we are sharing the embeddings
<ide> """
<add> self.transformer.set_num_special_tokens(num_special_tokens)
<ide> self.lm_head.set_embeddings_weights(self.transformer.wte.weight)
<ide>
<ide> def forward(self, input_ids, mc_token_ids, lm_labels=None, mc_labels=None, token_type_ids=None, position_ids=None, past=None):
<ide><path>pytorch_pretrained_bert/modeling_openai.py
<ide> class OpenAIGPTLMHead(nn.Module):
<ide> def __init__(self, model_embeddings_weights, config):
<ide> super(OpenAIGPTLMHead, self).__init__()
<ide> self.n_embd = config.n_embd
<add> embed_shape = model_embeddings_weights.shape
<add> self.decoder = nn.Linear(embed_shape[1], embed_shape[0], bias=False)
<ide> self.set_embeddings_weights(model_embeddings_weights)
<ide>
<ide> def set_embeddings_weights(self, model_embeddings_weights):
<ide> embed_shape = model_embeddings_weights.shape
<del> self.decoder = nn.Linear(embed_shape[1], embed_shape[0], bias=False)
<ide> self.decoder.weight = model_embeddings_weights # Tied weights
<ide>
<ide> def forward(self, hidden_state):
<ide> class OpenAIGPTModel(OpenAIGPTPreTrainedModel):
<ide>
<ide> def __init__(self, config):
<ide> super(OpenAIGPTModel, self).__init__(config)
<del> num_tokens = config.vocab_size + config.n_special
<del> self.tokens_embed = nn.Embedding(num_tokens, config.n_embd)
<add> self.tokens_embed = nn.Embedding(config.total_tokens_embeddings, config.n_embd)
<ide> self.positions_embed = nn.Embedding(config.n_positions, config.n_embd)
<ide> self.drop = nn.Dropout(config.embd_pdrop)
<ide> block = Block(config.n_ctx, config, scale=True)
<ide><path>tests/modeling_gpt2_test.py
<ide> def __init__(self,
<ide> use_token_type_ids=True,
<ide> use_labels=True,
<ide> vocab_size=99,
<add> n_special=1,
<ide> n_positions=33,
<ide> n_embd=32,
<ide> n_layer=5,
<ide> def __init__(self,
<ide> self.use_token_type_ids = use_token_type_ids
<ide> self.use_labels = use_labels
<ide> self.vocab_size = vocab_size
<add> self.n_special = n_special
<ide> self.n_positions = n_positions
<ide> self.n_embd = n_embd
<ide> self.n_layer = n_layer
<ide> def __init__(self,
<ide> self.scope = scope
<ide>
<ide> def prepare_config_and_inputs(self):
<del> input_ids = GPT2ModelTest.ids_tensor([self.batch_size, self.n_choices, self.seq_length], self.vocab_size)
<add> total_num_tokens = self.vocab_size + self.n_special
<add> input_ids = GPT2ModelTest.ids_tensor([self.batch_size, self.n_choices, self.seq_length], total_num_tokens)
<ide>
<ide> position_ids = None
<ide> if self.use_position_ids:
<ide> def prepare_config_and_inputs(self):
<ide>
<ide> config = GPT2Config(
<ide> vocab_size_or_config_json_file=self.vocab_size,
<add> n_special=self.n_special,
<ide> n_positions=self.n_positions,
<ide> n_embd=self.n_embd,
<ide> n_layer=self.n_layer,
<ide> def create_gpt2_lm_head(self, config, input_ids, token_type_ids, position_ids,
<ide> return outputs
<ide>
<ide> def check_gpt2_lm_head_output(self, result):
<del> total_voc = self.vocab_size
<add> total_voc = self.n_special + self.vocab_size
<ide> self.parent.assertListEqual(
<ide> list(result["lm_logits"].size()),
<ide> [self.batch_size, self.n_choices, self.seq_length, total_voc])
<ide> def create_gpt2_double_heads(self, config, input_ids, token_type_ids, position_i
<ide> return outputs
<ide>
<ide> def check_gpt2_double_heads_output(self, result):
<del> total_voc = self.vocab_size
<add> total_voc = self.n_special + self.vocab_size
<ide> self.parent.assertListEqual(
<ide> list(result["lm_logits"].size()),
<ide> [self.batch_size, self.n_choices, self.seq_length, total_voc]) | 3 |
Ruby | Ruby | remove the need for `ensure_cache_exists` | b2f67c6d776170b64a2963e175f96f23eef4646e | <ide><path>Library/Homebrew/cask/lib/hbc.rb
<ide>
<ide> module Hbc
<ide> def self.init
<del> Cache.ensure_cache_exists
<ide> Caskroom.ensure_caskroom_exists
<ide> end
<ide> end
<ide><path>Library/Homebrew/cask/lib/hbc/cache.rb
<ide> module Cache
<ide> def path
<ide> @path ||= HOMEBREW_CACHE.join("Cask")
<ide> end
<del>
<del> def ensure_cache_exists
<del> return if path.exist?
<del>
<del> odebug "Creating Cache at #{path}"
<del> path.mkpath
<del> end
<ide> end
<ide> end
<ide><path>Library/Homebrew/cask/lib/hbc/cli/cleanup.rb
<ide> def self.help
<ide> "cleans up cached downloads and tracker symlinks"
<ide> end
<ide>
<del> def self.needs_init?
<del> true
<del> end
<del>
<ide> attr_reader :cache_location
<ide>
<ide> def initialize(*args, cache_location: Cache.path)
<ide> def run
<ide> end
<ide>
<ide> def cache_files
<del> return [] unless cache_location.exist?
<add> return [] unless cache_location.directory?
<ide> cache_location.children
<ide> .map(&method(:Pathname))
<ide> .reject(&method(:outdated?))
<ide><path>Library/Homebrew/cask/lib/hbc/cli/fetch.rb
<ide> def run
<ide> end
<ide> end
<ide>
<del> def self.needs_init?
<del> true
<del> end
<del>
<ide> def self.help
<ide> "downloads remote application files to local cache"
<ide> end
<ide><path>Library/Homebrew/cask/lib/hbc/download_strategy.rb
<ide> def _fetch
<ide> end
<ide>
<ide> def fetch
<add> tarball_path.dirname.mkpath
<add>
<ide> ohai "Downloading #{@url}"
<ide> if tarball_path.exist?
<ide> puts "Already downloaded: #{tarball_path}"
<ide> def repo_url
<ide>
<ide> # super does not provide checks for already-existing downloads
<ide> def fetch
<add> cached_location.dirname.mkpath
<add>
<ide> if cached_location.directory?
<ide> puts "Already downloaded: #{cached_location}"
<ide> else
<ide><path>Library/Homebrew/test/support/helper/spec/shared_context/homebrew_cask.rb
<ide> begin
<ide> HOMEBREW_CASK_DIRS.values.each(&:mkpath)
<ide>
<del> [Hbc::Config.global.binarydir, Hbc::Caskroom.path, Hbc::Cache.path].each(&:mkpath)
<add> [Hbc::Config.global.binarydir, Hbc::Caskroom.path].each(&:mkpath)
<ide>
<ide> Tap.default_cask_tap.tap do |tap|
<ide> FileUtils.mkdir_p tap.path.dirname | 6 |
Ruby | Ruby | handle nil key for memcachestore#normalize_key | d13937bab5d821fc2b68ac4c7215946fee02e53f | <ide><path>activesupport/lib/active_support/cache/mem_cache_store.rb
<ide> def delete_entry(key, **options)
<ide> # before applying the regular expression to ensure we are escaping all
<ide> # characters properly.
<ide> def normalize_key(key, options)
<del> key = super.dup
<del> key = key.force_encoding(Encoding::ASCII_8BIT)
<del> key = key.gsub(ESCAPE_KEY_CHARS) { |match| "%#{match.getbyte(0).to_s(16).upcase}" }
<del> key = "#{key[0, 212]}:hash:#{ActiveSupport::Digest.hexdigest(key)}" if key.size > 250
<add> key = super
<add> if key
<add> key = key.dup.force_encoding(Encoding::ASCII_8BIT)
<add> key = key.gsub(ESCAPE_KEY_CHARS) { |match| "%#{match.getbyte(0).to_s(16).upcase}" }
<add> key = "#{key[0, 213]}:md5:#{ActiveSupport::Digest.hexdigest(key)}" if key.size > 250
<add> end
<ide> key
<ide> end
<ide>
<ide><path>activesupport/test/cache/stores/mem_cache_store_test.rb
<ide> def setup
<ide> @namespace = "test-#{SecureRandom.hex}"
<ide> @cache = lookup_store(expires_in: 60)
<ide> @peek = lookup_store
<del> @cache.silence!
<ide> @cache.logger = ActiveSupport::Logger.new(File::NULL)
<ide> end
<ide> | 2 |
Javascript | Javascript | add test for sync methods (type=sync) | 37bbfa663de8dfab6fdf1235c8f94efbd1046e91 | <ide><path>Libraries/BatchedBridge/__mocks__/MessageQueueTestConfig.js
<ide> const remoteModulesConfig: $ReadOnlyArray<ModuleConfig> = [
<ide> [
<ide> 'RemoteModule1',
<ide> null,
<del> ['remoteMethod', 'promiseMethod', 'promiseReturningMethod'],
<add> ['remoteMethod', 'promiseMethod', 'promiseReturningMethod', 'syncMethod'],
<ide> [2 /* promiseReturningMethod */],
<del> null,
<add> [3 /* syncMethod */],
<ide> ],
<ide> [
<ide> 'RemoteModule2',
<ide> null,
<del> ['remoteMethod', 'promiseMethod', 'promiseReturningMethod'],
<add> ['remoteMethod', 'promiseMethod', 'promiseReturningMethod', 'syncMethod'],
<ide> [2 /* promiseReturningMethod */],
<del> null,
<add> [3 /* syncMethod */],
<ide> ],
<ide> ];
<ide>
<ide><path>Libraries/BatchedBridge/__tests__/NativeModules-test.js
<ide> describe('MessageQueue', function() {
<ide> }).toThrow();
<ide> await promise2;
<ide> });
<add>
<add> describe('sync methods', () => {
<add> afterEach(function() {
<add> delete global.nativeCallSyncHook;
<add> });
<add>
<add> it('throwing an exception', function() {
<add> global.nativeCallSyncHook = jest.fn(() => {
<add> throw new Error('firstFailure');
<add> });
<add>
<add> let error;
<add> try {
<add> NativeModules.RemoteModule1.syncMethod('paloAlto', 'menloPark');
<add> } catch (e) {
<add> error = e;
<add> }
<add>
<add> expect(global.nativeCallSyncHook).toBeCalledTimes(1);
<add> expect(global.nativeCallSyncHook).toBeCalledWith(
<add> 0, // `RemoteModule1`
<add> 3, // `syncMethod`
<add> ['paloAlto', 'menloPark'],
<add> );
<add> expect(error).toBeInstanceOf(Error);
<add> expect(error).toMatchObject({
<add> message: 'firstFailure',
<add> });
<add> });
<add>
<add> it('returning a value', function() {
<add> global.nativeCallSyncHook = jest.fn(() => {
<add> return 'secondSucc';
<add> });
<add>
<add> const result = NativeModules.RemoteModule2.syncMethod('mac', 'windows');
<add>
<add> expect(global.nativeCallSyncHook).toBeCalledTimes(1);
<add> expect(global.nativeCallSyncHook).toBeCalledWith(
<add> 1, // `RemoteModule2`
<add> 3, // `syncMethod`
<add> ['mac', 'windows'],
<add> );
<add>
<add> expect(result).toBe('secondSucc');
<add> });
<add> });
<ide> });
<ide>
<ide> const linesByFile = new Map(); | 2 |
Javascript | Javascript | fix linter issue | 4d0f36f4afa6d4896f72ca20aab019fdadd469f5 | <ide><path>tasks/nuget.js
<ide> module.exports = function (grunt) {
<ide> });
<ide> grunt.registerTask('nugetkey_pre', function () {
<ide> grunt.option('key', process.env.NUGET_KEY);
<del> grunt.option('source', "https://www.nuget.org/api/v2/package");
<add> grunt.option('source', 'https://www.nuget.org/api/v2/package');
<ide> });
<ide> grunt.registerTask('nugetkey_post', function () {
<ide> grunt.option('key', null); | 1 |
PHP | PHP | fix failing tests with requestaction() | c248470af204aa6f5f4610d89cfa046e4938570a | <ide><path>lib/Cake/Core/Object.php
<ide> public function toString() {
<ide> *
<ide> * #### Passing POST and GET data
<ide> *
<del> * POST and GET data can be simulated in requestAction. Use `$extra['url']` for
<del> * GET data. The `$extra['data']` parameter allows POST data simulation.
<add> * POST and GET data can be simulated in requestAction. Use `$extra['query']` for
<add> * GET data. The `$extra['post']` parameter allows POST data simulation.
<ide> *
<ide> * @param string|array $url String or array-based url. Unlike other url arrays in CakePHP, this
<ide> * url will not automatically handle passed arguments in the $url parameter.
<ide> public function requestAction($url, $extra = array()) {
<ide> $extra['autoRender'] = 1;
<ide> unset($extra[$index]);
<ide> }
<del> if (is_array($url) && !isset($extra['url'])) {
<del> $extra['url'] = array();
<del> }
<ide> $extra = array_merge(array('autoRender' => 0, 'return' => 1, 'bare' => 1, 'requested' => 1), $extra);
<del> $data = isset($extra['data']) ? $extra['data'] : null;
<del> unset($extra['data']);
<add> $data = isset($extra['post']) ? $extra['post'] : null;
<add> unset($extra['post']);
<ide>
<ide> if (is_string($url) && strpos($url, FULL_BASE_URL) === 0) {
<ide> $url = Router::normalize(str_replace(FULL_BASE_URL, '', $url));
<ide> }
<ide> if (is_string($url)) {
<del> $request = new Request($url);
<add> $params = array(
<add> 'url' => $url
<add> );
<ide> } elseif (is_array($url)) {
<del> $params = $url + array('pass' => array(), 'base' => false);
<del> $params = array_merge($params, $extra);
<del> $request = new Request(Router::reverse($params));
<add> $url += array('pass' => array(), 'base' => false);
<add> $params = array(
<add> 'url' => Router::reverse($url)
<add> );
<ide> }
<ide> if (isset($data)) {
<del> $request->data = $data;
<add> $params['post'] = $data;
<ide> }
<add> $request = new Request($params);
<ide> $dispatcher = new Dispatcher();
<ide> $result = $dispatcher->dispatch($request, new Response(), $extra);
<ide> Router::popRequest();
<ide><path>lib/Cake/Routing/Router.php
<ide> public static function pushRequest(Request $request) {
<ide> public static function popRequest() {
<ide> $removed = array_pop(static::$_requests);
<ide> $last = end(static::$_requests);
<del> static::$_routes->setContext($last);
<del> reset(static::$_requests);
<add> if ($last) {
<add> static::$_routes->setContext($last);
<add> reset(static::$_requests);
<add> }
<ide> return $removed;
<ide> }
<ide>
<ide> public static function url($url = null, $options = array()) {
<ide> * @return string The string that is the reversed result of the array
<ide> */
<ide> public static function reverse($params, $full = false) {
<add> $url = array();
<ide> if ($params instanceof Request) {
<ide> $url = $params->query;
<ide> $params = $params->params;
<del> } else {
<add> } elseif (isset($params['url'])) {
<ide> $url = $params['url'];
<ide> }
<ide> $pass = isset($params['pass']) ? $params['pass'] : array();
<ide><path>lib/Cake/Test/TestCase/Core/ObjectTest.php
<ide> public function setUp() {
<ide> parent::setUp();
<ide> $this->object = new TestObject();
<ide> Configure::write('App.namespace', 'TestApp');
<add> Configure::write('Security.salt', 'not-the-default');
<add> Configure::write('Security.cipherSeed', '123456');
<ide> }
<ide>
<ide> /**
<ide> public function testRequestActionArray() {
<ide> 'Plugin' => array(CAKE . 'Test' . DS . 'TestApp' . DS . 'Plugin' . DS)
<ide> ), App::RESET);
<ide> Plugin::load(array('TestPlugin'));
<add> Router::reload();
<add> require CAKE . 'Config' . DS . 'routes.php';
<ide>
<ide> $result = $this->object->requestAction(
<ide> array('controller' => 'request_action', 'action' => 'test_request_action')
<ide> public function testRequestActionParamParseAndPass() {
<ide> * @return void
<ide> */
<ide> public function testRequestActionNoPostPassing() {
<del> $_tmp = $_POST;
<add> Router::reload();
<add> require CAKE . 'Config' . DS . 'routes.php';
<ide>
<del> $_POST = array('data' => array(
<add> $_POST = array(
<ide> 'item' => 'value'
<del> ));
<add> );
<ide> $result = $this->object->requestAction(array('controller' => 'request_action', 'action' => 'post_pass'));
<ide> $expected = null;
<ide> $this->assertEmpty($result);
<ide>
<ide> $result = $this->object->requestAction(
<ide> array('controller' => 'request_action', 'action' => 'post_pass'),
<del> array('data' => $_POST['data'])
<add> array('post' => $_POST)
<ide> );
<del> $expected = $_POST['data'];
<del> $this->assertEquals($expected, $result);
<del>
<del> $result = $this->object->requestAction('/request_action/post_pass');
<del> $expected = $_POST['data'];
<add> $expected = $_POST;
<ide> $this->assertEquals($expected, $result);
<del>
<del> $_POST = $_tmp;
<ide> }
<ide>
<ide> /**
<ide> public function testRequestActionNoPostPassing() {
<ide> * @return void
<ide> */
<ide> public function testRequestActionPostWithData() {
<add> Router::reload();
<add> require CAKE . 'Config' . DS . 'routes.php';
<add>
<ide> $data = array(
<ide> 'Post' => array('id' => 2)
<ide> );
<ide> $result = $this->object->requestAction(
<ide> array('controller' => 'request_action', 'action' => 'post_pass'),
<del> array('data' => $data)
<add> array('post' => $data)
<ide> );
<ide> $this->assertEquals($data, $result);
<ide>
<ide> $result = $this->object->requestAction(
<ide> '/request_action/post_pass',
<del> array('data' => $data)
<add> array('post' => $data)
<ide> );
<ide> $this->assertEquals($data, $result);
<ide> }
<add>
<ide> }
<ide><path>lib/Cake/Test/TestCase/Routing/RouterTest.php
<ide> public function testUrlWithRequestAction() {
<ide> Router::popRequest();
<ide> $result = Router::url(array('_base' => false));
<ide> $this->assertEquals('/posts', $result, 'with second requests, the last should win.');
<add>
<add> // Make sure that popping an empty request doesn't fail.
<add> Router::popRequest();
<ide> }
<ide>
<ide> /** | 4 |
PHP | PHP | fix eager loading within global scope | 9cce184103e6ef40d90dd601224efa11e30884b2 | <ide><path>src/Illuminate/Database/Eloquent/Builder.php
<ide> public function firstOrFail($columns = ['*'])
<ide> */
<ide> public function get($columns = ['*'])
<ide> {
<del> $models = $this->getModels($columns);
<add> $builder = $this->applyScopes();
<add>
<add> $models = $builder->getModels($columns);
<ide>
<ide> // If we actually found models we will also eager load any relationships that
<ide> // have been specified as needing to be eager loaded, which will solve the
<ide> // n+1 query issue for the developers to avoid running a lot of queries.
<ide> if (count($models) > 0) {
<del> $models = $this->eagerLoadRelations($models);
<add> $models = $builder->eagerLoadRelations($models);
<ide> }
<ide>
<del> return $this->model->newCollection($models);
<add> return $builder->getModel()->newCollection($models);
<ide> }
<ide>
<ide> /**
<ide> public function onDelete(Closure $callback)
<ide> */
<ide> public function getModels($columns = ['*'])
<ide> {
<del> $results = $this->toBase()->get($columns);
<add> $results = $this->query->get($columns);
<ide>
<ide> $connection = $this->model->getConnectionName();
<ide>
<ide><path>src/Illuminate/Database/Eloquent/Relations/BelongsToMany.php
<ide> public function get($columns = ['*'])
<ide>
<ide> $select = $this->getSelectColumns($columns);
<ide>
<del> $models = $this->query->addSelect($select)->getModels();
<add> $builder = $this->query->applyScopes();
<add>
<add> $models = $builder->addSelect($select)->getModels();
<ide>
<ide> $this->hydratePivotRelation($models);
<ide>
<ide> // If we actually found models we will also eager load any relationships that
<ide> // have been specified as needing to be eager loaded. This will solve the
<ide> // n + 1 query problem for the developer and also increase performance.
<ide> if (count($models) > 0) {
<del> $models = $this->query->eagerLoadRelations($models);
<add> $models = $builder->eagerLoadRelations($models);
<ide> }
<ide>
<ide> return $this->related->newCollection($models);
<ide><path>src/Illuminate/Database/Eloquent/Relations/HasManyThrough.php
<ide> public function get($columns = ['*'])
<ide>
<ide> $select = $this->getSelectColumns($columns);
<ide>
<del> $models = $this->query->addSelect($select)->getModels();
<add> $builder = $this->query->applyScopes();
<add>
<add> $models = $builder->addSelect($select)->getModels();
<ide>
<ide> // If we actually found models we will also eager load any relationships that
<ide> // have been specified as needing to be eager loaded. This will solve the
<ide> // n + 1 query problem for the developer and also increase performance.
<ide> if (count($models) > 0) {
<del> $models = $this->query->eagerLoadRelations($models);
<add> $models = $builder->eagerLoadRelations($models);
<ide> }
<ide>
<ide> return $this->related->newCollection($models);
<ide><path>tests/Database/DatabaseEloquentBelongsToManyTest.php
<ide> public function testModelsAreProperlyHydrated()
<ide> $relation = $this->getRelation();
<ide> $relation->getParent()->shouldReceive('getConnectionName')->andReturn('foo.connection');
<ide> $relation->getQuery()->shouldReceive('addSelect')->once()->with(['roles.*', 'user_role.user_id as pivot_user_id', 'user_role.role_id as pivot_role_id'])->andReturn($relation->getQuery());
<add> $relation->getQuery()->shouldReceive('applyScopes')->once()->andReturnSelf();
<ide> $relation->getQuery()->shouldReceive('getModels')->once()->andReturn($models);
<ide> $relation->getQuery()->shouldReceive('eagerLoadRelations')->once()->with($models)->andReturn($models);
<ide> $relation->getRelated()->shouldReceive('newCollection')->andReturnUsing(function ($array) { return new Collection($array); });
<ide> public function testTimestampsCanBeRetrievedProperly()
<ide> 'user_role.created_at as pivot_created_at',
<ide> 'user_role.updated_at as pivot_updated_at',
<ide> ])->andReturn($relation->getQuery());
<add> $relation->getQuery()->shouldReceive('applyScopes')->once()->andReturnSelf();
<ide> $relation->getQuery()->shouldReceive('getModels')->once()->andReturn($models);
<ide> $relation->getQuery()->shouldReceive('eagerLoadRelations')->once()->with($models)->andReturn($models);
<ide> $relation->getRelated()->shouldReceive('newCollection')->andReturnUsing(function ($array) { return new Collection($array); });
<ide><path>tests/Database/DatabaseEloquentBuilderTest.php
<ide> public function testFirstMethod()
<ide> public function testGetMethodLoadsModelsAndHydratesEagerRelations()
<ide> {
<ide> $builder = m::mock('Illuminate\Database\Eloquent\Builder[getModels,eagerLoadRelations]', [$this->getMockQueryBuilder()]);
<add> $builder->shouldReceive('applyScopes')->andReturnSelf();
<ide> $builder->shouldReceive('getModels')->with(['foo'])->andReturn(['bar']);
<ide> $builder->shouldReceive('eagerLoadRelations')->with(['bar'])->andReturn(['bar', 'baz']);
<ide> $builder->setModel($this->getMockModel());
<ide> public function testGetMethodLoadsModelsAndHydratesEagerRelations()
<ide> public function testGetMethodDoesntHydrateEagerRelationsWhenNoResultsAreReturned()
<ide> {
<ide> $builder = m::mock('Illuminate\Database\Eloquent\Builder[getModels,eagerLoadRelations]', [$this->getMockQueryBuilder()]);
<add> $builder->shouldReceive('applyScopes')->andReturnSelf();
<ide> $builder->shouldReceive('getModels')->with(['foo'])->andReturn([]);
<ide> $builder->shouldReceive('eagerLoadRelations')->never();
<ide> $builder->setModel($this->getMockModel());
<ide><path>tests/Database/DatabaseEloquentHasManyThroughTest.php
<ide> public function testAllColumnsAreSelectedByDefault()
<ide> $relation->getRelated()->shouldReceive('newCollection')->once();
<ide>
<ide> $builder = $relation->getQuery();
<add> $builder->shouldReceive('applyScopes')->andReturnSelf();
<ide> $builder->shouldReceive('getQuery')->andReturn($baseBuilder);
<ide> $builder->shouldReceive('addSelect')->once()->with($select)->andReturn($builder);
<ide> $builder->shouldReceive('getModels')->once()->andReturn([]);
<ide> public function testOnlyProperColumnsAreSelectedIfProvided()
<ide> $relation->getRelated()->shouldReceive('newCollection')->once();
<ide>
<ide> $builder = $relation->getQuery();
<add> $builder->shouldReceive('applyScopes')->andReturnSelf();
<ide> $builder->shouldReceive('getQuery')->andReturn($baseBuilder);
<ide> $builder->shouldReceive('addSelect')->once()->with($select)->andReturn($builder);
<ide> $builder->shouldReceive('getModels')->once()->andReturn([]);
<ide><path>tests/Database/DatabaseEloquentIntegrationTest.php
<ide> public function testDefaultIncrementingPrimaryKeyIntegerCastCanBeOverwritten()
<ide> $this->assertInternalType('string', $user->id);
<ide> }
<ide>
<add> public function testRelationsArePreloadedInGlobalScope()
<add> {
<add> $user = EloquentTestUserWithGlobalScope::create(['email' => 'taylorotwell@gmail.com']);
<add> $user->posts()->create(['name' => 'My Post']);
<add>
<add> $result = EloquentTestUserWithGlobalScope::first();
<add>
<add> $this->assertCount(1, $result->getRelations());
<add> }
<add>
<ide> /**
<ide> * Helpers...
<ide> */
<ide> public function photos()
<ide> }
<ide> }
<ide>
<add>class EloquentTestUserWithGlobalScope extends EloquentTestUser
<add>{
<add> public static function boot()
<add> {
<add> parent::boot();
<add>
<add> static::addGlobalScope(function ($builder) {
<add> $builder->with('posts');
<add> });
<add> }
<add>}
<add>
<ide> class EloquentTestPost extends Eloquent
<ide> {
<ide> protected $table = 'posts'; | 7 |
Text | Text | update directory name in sample commands | 23e6ad547cf30a7ddffaba4dc5f93c45f3ef4722 | <ide><path>guides/source/contributing_to_ruby_on_rails.md
<ide> $ TEST_DIR=generators bundle exec rake test
<ide> You can run the tests for a particular file by using:
<ide>
<ide> ```bash
<del>$ cd actionpack
<add>$ cd actionview
<ide> $ bundle exec ruby -w -Itest test/template/form_helper_test.rb
<ide> ```
<ide> | 1 |
Javascript | Javascript | add a null type test for memo | 48f1e5b3ced33aa2d5ba42afa38af9cf7e51a0ed | <ide><path>packages/react-reconciler/src/__tests__/ReactMemo-test.internal.js
<ide> describe('memo', () => {
<ide> expect(ReactNoop.getChildren()).toEqual([span(20)]);
<ide> });
<ide>
<del> it('warns if first argument is undefined', () => {
<add> it('warns if the first argument is undefined', () => {
<ide> expect(() => memo()).toWarnDev(
<ide> 'memo: The first argument must be a component. Instead ' +
<ide> 'received: undefined',
<ide> {withoutStack: true},
<ide> );
<ide> });
<add>
<add> it('warns if the first argument is null', () => {
<add> expect(() => memo(null)).toWarnDev(
<add> 'memo: The first argument must be a component. Instead ' +
<add> 'received: null',
<add> {withoutStack: true},
<add> );
<add> });
<ide> });
<ide> }
<ide> });
<ide><path>scripts/jest/matchers/toWarnDev.js
<ide> const createMatcherFor = consoleMethod =>
<ide> };
<ide>
<ide> // TODO Decide whether we need to support nested toWarn* expectations.
<del> // If we don't need id, add a check here to see if this is already our spy,
<add> // If we don't need it, add a check here to see if this is already our spy,
<ide> // And throw an error.
<ide> const originalMethod = console[consoleMethod];
<ide> | 2 |
Go | Go | move signal.dumpstacks() to a separate package | ea5c94cdb94f74808958732d8b3254921f52be4f | <ide><path>daemon/cluster/cluster.go
<ide> import (
<ide> "github.com/docker/docker/daemon/cluster/controllers/plugin"
<ide> executorpkg "github.com/docker/docker/daemon/cluster/executor"
<ide> lncluster "github.com/docker/docker/libnetwork/cluster"
<del> "github.com/docker/docker/pkg/signal"
<add> "github.com/docker/docker/pkg/stack"
<ide> swarmapi "github.com/docker/swarmkit/api"
<ide> swarmnode "github.com/docker/swarmkit/node"
<ide> "github.com/pkg/errors"
<ide> func (c *Cluster) Cleanup() {
<ide>
<ide> if err := node.Stop(); err != nil {
<ide> logrus.Errorf("failed to shut down cluster node: %v", err)
<del> signal.DumpStacks("")
<add> stack.Dump()
<ide> }
<ide>
<ide> c.mu.Lock()
<ide><path>daemon/cluster/swarm.go
<ide> import (
<ide> "github.com/docker/docker/daemon/cluster/convert"
<ide> "github.com/docker/docker/errdefs"
<ide> "github.com/docker/docker/opts"
<del> "github.com/docker/docker/pkg/signal"
<add> "github.com/docker/docker/pkg/stack"
<ide> swarmapi "github.com/docker/swarmkit/api"
<ide> "github.com/docker/swarmkit/manager/encryption"
<ide> swarmnode "github.com/docker/swarmkit/node"
<ide> func (c *Cluster) Leave(force bool) error {
<ide> // release readers in here
<ide> if err := nr.Stop(); err != nil {
<ide> logrus.Errorf("failed to shut down cluster node: %v", err)
<del> signal.DumpStacks("")
<add> stack.Dump()
<ide> return err
<ide> }
<ide>
<ide><path>daemon/debugtrap_unix.go
<ide> import (
<ide> "os"
<ide> "os/signal"
<ide>
<del> stackdump "github.com/docker/docker/pkg/signal"
<add> "github.com/docker/docker/pkg/stack"
<ide> "github.com/sirupsen/logrus"
<ide> "golang.org/x/sys/unix"
<ide> )
<ide> func (daemon *Daemon) setupDumpStackTrap(root string) {
<ide> signal.Notify(c, unix.SIGUSR1)
<ide> go func() {
<ide> for range c {
<del> path, err := stackdump.DumpStacks(root)
<add> path, err := stack.DumpToFile(root)
<ide> if err != nil {
<ide> logrus.WithError(err).Error("failed to write goroutines dump")
<ide> } else {
<ide><path>daemon/debugtrap_windows.go
<ide> import (
<ide> "os"
<ide> "unsafe"
<ide>
<del> "github.com/docker/docker/pkg/signal"
<add> "github.com/docker/docker/pkg/stack"
<ide> "github.com/sirupsen/logrus"
<ide> "golang.org/x/sys/windows"
<ide> )
<ide> func (daemon *Daemon) setupDumpStackTrap(root string) {
<ide> logrus.Debugf("Stackdump - waiting signal at %s", event)
<ide> for {
<ide> windows.WaitForSingleObject(h, windows.INFINITE)
<del> path, err := signal.DumpStacks(root)
<add> path, err := stack.DumpToFile(root)
<ide> if err != nil {
<ide> logrus.WithError(err).Error("failed to write goroutines dump")
<ide> } else {
<ide><path>libnetwork/diagnostic/server.go
<ide> import (
<ide> "sync/atomic"
<ide>
<ide> "github.com/docker/docker/libnetwork/internal/caller"
<del> stackdump "github.com/docker/docker/pkg/signal"
<add> "github.com/docker/docker/pkg/stack"
<ide> "github.com/sirupsen/logrus"
<ide> )
<ide>
<ide> func stackTrace(ctx interface{}, w http.ResponseWriter, r *http.Request) {
<ide> log := logrus.WithFields(logrus.Fields{"component": "diagnostic", "remoteIP": r.RemoteAddr, "method": caller.Name(0), "url": r.URL.String()})
<ide> log.Info("stack trace")
<ide>
<del> path, err := stackdump.DumpStacks("/tmp/")
<add> path, err := stack.DumpToFile("/tmp/")
<ide> if err != nil {
<ide> log.WithError(err).Error("failed to write goroutines dump")
<ide> HTTPReply(w, FailCommand(err), json) // nolint:errcheck
<ide><path>pkg/signal/signal_deprecated.go
<add>package signal
<add>
<add>import "github.com/docker/docker/pkg/stack"
<add>
<add>// DumpStacks appends the runtime stack into file in dir and returns full path
<add>// to that file.
<add>// Deprecated: use github.com/docker/docker/pkg/stack.Dump instead.
<add>var DumpStacks = stack.DumpToFile
<ide><path>pkg/signal/trap.go
<ide> import (
<ide> "fmt"
<ide> "os"
<ide> gosignal "os/signal"
<del> "path/filepath"
<del> "runtime"
<del> "strings"
<ide> "sync/atomic"
<ide> "syscall"
<del> "time"
<ide>
<del> "github.com/pkg/errors"
<add> "github.com/docker/docker/pkg/stack"
<ide> )
<ide>
<ide> // Trap sets up a simplified signal "trap", appropriate for common
<ide> func Trap(cleanup func(), logger interface {
<ide> logger.Info("Forcing docker daemon shutdown without cleanup; 3 interrupts received")
<ide> }
<ide> case syscall.SIGQUIT:
<del> DumpStacks("")
<add> stack.Dump()
<ide> logger.Info("Forcing docker daemon shutdown without cleanup on SIGQUIT")
<ide> }
<ide> // for the SIGINT/TERM, and SIGQUIT non-clean shutdown case, exit with 128 + signal #
<ide> func Trap(cleanup func(), logger interface {
<ide> }
<ide> }()
<ide> }
<del>
<del>const stacksLogNameTemplate = "goroutine-stacks-%s.log"
<del>
<del>// DumpStacks appends the runtime stack into file in dir and returns full path
<del>// to that file.
<del>func DumpStacks(dir string) (string, error) {
<del> var (
<del> buf []byte
<del> stackSize int
<del> )
<del> bufferLen := 16384
<del> for stackSize == len(buf) {
<del> buf = make([]byte, bufferLen)
<del> stackSize = runtime.Stack(buf, true)
<del> bufferLen *= 2
<del> }
<del> buf = buf[:stackSize]
<del> var f *os.File
<del> if dir != "" {
<del> path := filepath.Join(dir, fmt.Sprintf(stacksLogNameTemplate, strings.Replace(time.Now().Format(time.RFC3339), ":", "", -1)))
<del> var err error
<del> f, err = os.OpenFile(path, os.O_CREATE|os.O_WRONLY, 0666)
<del> if err != nil {
<del> return "", errors.Wrap(err, "failed to open file to write the goroutine stacks")
<del> }
<del> defer f.Close()
<del> defer f.Sync()
<del> } else {
<del> f = os.Stderr
<del> }
<del> if _, err := f.Write(buf); err != nil {
<del> return "", errors.Wrap(err, "failed to write goroutine stacks")
<del> }
<del> return f.Name(), nil
<del>}
<ide><path>pkg/signal/trap_linux_test.go
<ide> func TestTrap(t *testing.T) {
<ide> }
<ide>
<ide> }
<del>
<del>func TestDumpStacks(t *testing.T) {
<del> directory, err := ioutil.TempDir("", "test-dump-tasks")
<del> assert.Check(t, err)
<del> defer os.RemoveAll(directory)
<del> dumpPath, err := DumpStacks(directory)
<del> assert.Check(t, err)
<del> readFile, _ := ioutil.ReadFile(dumpPath)
<del> fileData := string(readFile)
<del> assert.Check(t, is.Contains(fileData, "goroutine"))
<del>}
<del>
<del>func TestDumpStacksWithEmptyInput(t *testing.T) {
<del> path, err := DumpStacks("")
<del> assert.Check(t, err)
<del> assert.Check(t, is.Equal(os.Stderr.Name(), path))
<del>}
<ide><path>pkg/stack/stackdump.go
<add>package stack // import "github.com/docker/docker/pkg/stack"
<add>
<add>import (
<add> "fmt"
<add> "os"
<add> "path/filepath"
<add> "runtime"
<add> "strings"
<add> "time"
<add>
<add> "github.com/pkg/errors"
<add>)
<add>
<add>const stacksLogNameTemplate = "goroutine-stacks-%s.log"
<add>
<add>// Dump outputs the runtime stack to os.StdErr.
<add>func Dump() {
<add> _ = dump(os.Stderr)
<add>}
<add>
<add>// DumpToFile appends the runtime stack into a file named "goroutine-stacks-<timestamp>.log"
<add>// in dir and returns the full path to that file. If no directory name is
<add>// provided, it outputs to os.Stderr.
<add>func DumpToFile(dir string) (string, error) {
<add> var f *os.File
<add> if dir != "" {
<add> path := filepath.Join(dir, fmt.Sprintf(stacksLogNameTemplate, strings.Replace(time.Now().Format(time.RFC3339), ":", "", -1)))
<add> var err error
<add> f, err = os.OpenFile(path, os.O_CREATE|os.O_WRONLY, 0666)
<add> if err != nil {
<add> return "", errors.Wrap(err, "failed to open file to write the goroutine stacks")
<add> }
<add> defer f.Close()
<add> defer f.Sync()
<add> } else {
<add> f = os.Stderr
<add> }
<add> return f.Name(), dump(f)
<add>}
<add>
<add>func dump(f *os.File) error {
<add> var (
<add> buf []byte
<add> stackSize int
<add> )
<add> bufferLen := 16384
<add> for stackSize == len(buf) {
<add> buf = make([]byte, bufferLen)
<add> stackSize = runtime.Stack(buf, true)
<add> bufferLen *= 2
<add> }
<add> buf = buf[:stackSize]
<add> if _, err := f.Write(buf); err != nil {
<add> return errors.Wrap(err, "failed to write goroutine stacks")
<add> }
<add> return nil
<add>}
<ide><path>pkg/stack/stackdump_test.go
<add>package stack // import "github.com/docker/docker/pkg/stack"
<add>
<add>import (
<add> "io/ioutil"
<add> "os"
<add> "testing"
<add>
<add> "gotest.tools/v3/assert"
<add> is "gotest.tools/v3/assert/cmp"
<add>)
<add>
<add>func TestDump(t *testing.T) {
<add> Dump()
<add>}
<add>
<add>func TestDumpToFile(t *testing.T) {
<add> directory, err := ioutil.TempDir("", "test-dump-tasks")
<add> assert.Check(t, err)
<add> defer os.RemoveAll(directory)
<add> dumpPath, err := DumpToFile(directory)
<add> assert.Check(t, err)
<add> readFile, _ := ioutil.ReadFile(dumpPath)
<add> fileData := string(readFile)
<add> assert.Check(t, is.Contains(fileData, "goroutine"))
<add>}
<add>
<add>func TestDumpToFileWithEmptyInput(t *testing.T) {
<add> path, err := DumpToFile("")
<add> assert.Check(t, err)
<add> assert.Check(t, is.Equal(os.Stderr.Name(), path))
<add>} | 10 |
Mixed | Javascript | add perspective transform support on android | a06ced4b164c003992daec50c7c8f909f07b0d39 | <ide><path>Examples/UIExplorer/js/TransformExample.js
<ide> exports.title = 'Transforms';
<ide> exports.description = 'View transforms';
<ide> exports.examples = [
<ide> {
<del> title: 'Perspective',
<add> title: 'Perspective, Rotate, Animation',
<ide> description: 'perspective: 850, rotateX: Animated.timing(0 -> 360)',
<ide> render(): React.Element<any> { return <Flip />; }
<ide> },
<ide><path>ReactAndroid/src/main/java/com/facebook/react/uimanager/BaseViewManager.java
<ide> import android.graphics.Color;
<ide> import android.os.Build;
<ide> import android.view.View;
<del>import android.view.ViewGroup;
<del>
<ide> import com.facebook.react.bridge.ReadableArray;
<ide> import com.facebook.react.uimanager.annotations.ReactProp;
<ide>
<ide> private static final String PROP_TRANSLATE_X = "translateX";
<ide> private static final String PROP_TRANSLATE_Y = "translateY";
<ide>
<add> private static final int PERSPECTIVE_ARRAY_INVERTED_CAMERA_DISTANCE_INDEX = 2;
<add> private static final float CAMERA_DISTANCE_NORMALIZATION_MULTIPLIER = 5;
<add>
<ide> /**
<ide> * Used to locate views in end-to-end (UI) tests.
<ide> */
<ide> private static void setTransformProperty(View view, ReadableArray transforms) {
<ide> view.setRotationY((float) sMatrixDecompositionContext.rotationDegrees[1]);
<ide> view.setScaleX((float) sMatrixDecompositionContext.scale[0]);
<ide> view.setScaleY((float) sMatrixDecompositionContext.scale[1]);
<add>
<add> double[] perspectiveArray = sMatrixDecompositionContext.perspective;
<add>
<add> if (perspectiveArray.length > PERSPECTIVE_ARRAY_INVERTED_CAMERA_DISTANCE_INDEX) {
<add> float invertedCameraDistance = (float) perspectiveArray[PERSPECTIVE_ARRAY_INVERTED_CAMERA_DISTANCE_INDEX];
<add> if (invertedCameraDistance < 0) {
<add> float cameraDistance = -1 / invertedCameraDistance;
<add> float scale = DisplayMetricsHolder.getScreenDisplayMetrics().density;
<add>
<add> // The following converts the matrix's perspective to a camera distance
<add> // such that the camera perspective looks the same on Android and iOS
<add> float normalizedCameraDistance = scale * cameraDistance * CAMERA_DISTANCE_NORMALIZATION_MULTIPLIER;
<add>
<add> view.setCameraDistance(normalizedCameraDistance);
<add> }
<add> }
<ide> }
<ide>
<ide> private static void resetTransformProperty(View view) {
<ide> private static void resetTransformProperty(View view) {
<ide> view.setRotationY(0);
<ide> view.setScaleX(1);
<ide> view.setScaleY(1);
<add> view.setCameraDistance(0);
<ide> }
<ide> } | 2 |
PHP | PHP | fix variadic routing parameters | 7ad809ddc026597806f7a7359ef44f5abd3a6ab0 | <ide><path>src/Controller/ControllerFactory.php
<ide> public function invoke($controller): ResponseInterface
<ide> );
<ide> }
<ide> }
<add> if (count($passed)) {
<add> $args = array_merge($args, $passed);
<add> }
<ide> $controller->invokeAction($action, $args);
<ide>
<ide> $result = $controller->shutdownProcess();
<ide><path>tests/TestCase/Controller/ControllerFactoryTest.php
<ide> public function testInvokeInjectParametersRequiredWithPassedParameters()
<ide> $this->assertSame($data->str, 'two');
<ide> $this->assertSame('value', $data->dep->key);
<ide> }
<add>
<add> /**
<add> * Test that routing parameters are passed into variadic controller functions
<add> *
<add> * @return void
<add> */
<add> public function testInvokeInjectPassedParametersVariadic()
<add> {
<add> $this->container->add(stdClass::class, json_decode('{"key":"value"}'));
<add> $request = new ServerRequest([
<add> 'url' => 'test_plugin_three/dependencies/optionalDep',
<add> 'params' => [
<add> 'plugin' => null,
<add> 'controller' => 'Dependencies',
<add> 'action' => 'variadic',
<add> 'pass' => ['one', 'two'],
<add> ],
<add> ]);
<add> $controller = $this->factory->create($request);
<add> $result = $this->factory->invoke($controller);
<add> $data = json_decode((string)$result->getBody());
<add>
<add> $this->assertNotNull($data);
<add> $this->assertSame(['one', 'two'], $data->args);
<add> }
<ide> }
<ide><path>tests/test_app/TestApp/Controller/DependenciesController.php
<ide> public function requiredDep(stdClass $dep, $any = null, ?string $str = null)
<ide> {
<ide> return $this->response->withStringBody(json_encode(compact('dep', 'any', 'str')));
<ide> }
<add>
<add> public function variadic()
<add> {
<add> return $this->response->withStringBody(json_encode(['args' => func_get_args()]));
<add> }
<ide> } | 3 |
Javascript | Javascript | add max for http keepalive | 12894924af54114b1d9e8d19fff7dbaf1e2a23da | <ide><path>lib/_http_outgoing.js
<ide> function _storeHeader(firstLine, headers) {
<ide> header += 'Connection: keep-alive\r\n';
<ide> if (this._keepAliveTimeout && this._defaultKeepAlive) {
<ide> const timeoutSeconds = MathFloor(this._keepAliveTimeout / 1000);
<del> header += `Keep-Alive: timeout=${timeoutSeconds}\r\n`;
<add> let max = '';
<add> if (~~this._maxRequestsPerSocket > 0) {
<add> max = `, max=${this._maxRequestsPerSocket}`;
<add> }
<add> header += `Keep-Alive: timeout=${timeoutSeconds}${max}\r\n`;
<ide> }
<ide> } else {
<ide> this._last = true;
<ide><path>lib/_http_server.js
<ide> function parserOnIncoming(server, socket, state, req, keepAlive) {
<ide>
<ide> const res = new server[kServerResponse](req);
<ide> res._keepAliveTimeout = server.keepAliveTimeout;
<add> res._maxRequestsPerSocket = server.maxRequestsPerSocket;
<ide> res._onPendingData = updateOutgoingData.bind(undefined,
<ide> socket, state);
<ide>
<ide><path>test/parallel/test-http-keep-alive-max-requests.js
<ide> function assertResponse(headers, body, expectClosed) {
<ide> assert.match(body, /Hello World!/m);
<ide> } else {
<ide> assert.match(headers, /Connection: keep-alive\r\n/m);
<del> assert.match(headers, /Keep-Alive: timeout=5\r\n/m);
<add> assert.match(headers, /Keep-Alive: timeout=5, max=3\r\n/m);
<ide> assert.match(body, /Hello World!/m);
<ide> }
<ide> }
<ide><path>test/parallel/test-http-keep-alive-pipeline-max-requests.js
<ide> const bodySent = 'This is my request';
<ide> function assertResponse(headers, body, expectClosed) {
<ide> if (expectClosed) {
<ide> assert.match(headers, /Connection: close\r\n/m);
<del> assert.strictEqual(headers.search(/Keep-Alive: timeout=5\r\n/m), -1);
<add> assert.strictEqual(headers.search(/Keep-Alive: timeout=5, max=3\r\n/m), -1);
<ide> assert.match(body, /Hello World!/m);
<ide> } else {
<ide> assert.match(headers, /Connection: keep-alive\r\n/m);
<del> assert.match(headers, /Keep-Alive: timeout=5\r\n/m);
<add> assert.match(headers, /Keep-Alive: timeout=5, max=3\r\n/m);
<ide> assert.match(body, /Hello World!/m);
<ide> }
<ide> } | 4 |
Text | Text | add more internal links to fs.stats object | 746da42cae214e27b97cd583eb3c5f6eb4777dec | <ide><path>doc/api/fs.md
<ide> added: v0.1.95
<ide>
<ide> * `fd` {Integer}
<ide>
<del>Synchronous fstat(2). Returns an instance of `fs.Stats`.
<add>Synchronous fstat(2). Returns an instance of [`fs.Stats`][].
<ide>
<ide> ## fs.fsync(fd, callback)
<ide> <!-- YAML
<ide> added: v0.1.30
<ide>
<ide> * `path` {String | Buffer}
<ide>
<del>Synchronous lstat(2). Returns an instance of `fs.Stats`.
<add>Synchronous lstat(2). Returns an instance of [`fs.Stats`][].
<ide>
<ide> ## fs.mkdir(path[, mode], callback)
<ide> <!-- YAML | 1 |
Javascript | Javascript | add promisified readfile benchmark | b9fd4eb651dd26c3845aa46714593abae185455d | <ide><path>benchmark/fs/readfile-promises.js
<add>// Call fs.promises.readFile over and over again really fast.
<add>// Then see how many times it got called.
<add>// Yes, this is a silly benchmark. Most benchmarks are silly.
<add>'use strict';
<add>
<add>const path = require('path');
<add>const common = require('../common.js');
<add>const fs = require('fs');
<add>const assert = require('assert');
<add>
<add>const tmpdir = require('../../test/common/tmpdir');
<add>tmpdir.refresh();
<add>const filename = path.resolve(tmpdir.path,
<add> `.removeme-benchmark-garbage-${process.pid}`);
<add>
<add>const bench = common.createBenchmark(main, {
<add> duration: [5],
<add> len: [1024, 16 * 1024 * 1024],
<add> concurrent: [1, 10]
<add>});
<add>
<add>function main({ len, duration, concurrent }) {
<add> try { fs.unlinkSync(filename); } catch { }
<add> let data = Buffer.alloc(len, 'x');
<add> fs.writeFileSync(filename, data);
<add> data = null;
<add>
<add> let writes = 0;
<add> let benchEnded = false;
<add> bench.start();
<add> setTimeout(() => {
<add> benchEnded = true;
<add> bench.end(writes);
<add> try { fs.unlinkSync(filename); } catch { }
<add> process.exit(0);
<add> }, duration * 1000);
<add>
<add> function read() {
<add> fs.promises.readFile(filename)
<add> .then((res) => afterRead(undefined, res))
<add> .catch((err) => afterRead(err));
<add> }
<add>
<add> function afterRead(er, data) {
<add> if (er) {
<add> if (er.code === 'ENOENT') {
<add> // Only OK if unlinked by the timer from main.
<add> assert.ok(benchEnded);
<add> return;
<add> }
<add> throw er;
<add> }
<add>
<add> if (data.length !== len)
<add> throw new Error('wrong number of bytes returned');
<add>
<add> writes++;
<add> if (!benchEnded)
<add> read();
<add> }
<add>
<add> while (concurrent--) read();
<add>} | 1 |
Javascript | Javascript | unite iteration through modules into one loop | fc20348f970c7a187c6038f22e76186ea65f2d60 | <ide><path>lib/optimize/ConcatenatedModule.js
<ide> class ConcatenatedModule extends Module {
<ide> this.cacheable = modules.every(m => m.cacheable);
<ide> const modulesSet = new Set(modules);
<ide> this.reasons = rootModule.reasons.filter(reason => !modulesSet.has(reason.module));
<del> this.dependencies = [];
<ide> this.meta = rootModule.meta;
<del> this.dependenciesWarnings = modules.reduce((w, m) => m.dependenciesWarnings.forEach(x => w.push(x)), []);
<del> this.dependenciesErrors = modules.reduce((w, m) => m.dependenciesErrors.forEach(x => w.push(x)), []);
<del> this.warnings = modules.reduce((w, m) => m.warnings.forEach(x => w.push(x)), []);
<del> this.errors = modules.reduce((w, m) => m.errors.forEach(x => w.push(x)), []);
<ide> this.moduleArgument = rootModule.moduleArgument;
<ide> this.exportsArgument = rootModule.exportsArgument;
<ide> this.strict = true;
<del> modules.forEach((m, idx) => {
<del> for(const dep of m.dependencies.filter(dep => !modulesSet.has(dep.module))) {
<del> this.dependencies.push(dep);
<del> }
<del> });
<add>
<add> this.dependencies = [];
<add> this.dependenciesWarnings = [];
<add> this.dependenciesErrors = [];
<add> this.warnings = [];
<add> this.errors = [];
<add> for(const m of modules) {
<add> // populate dependencies
<add> m.dependencies.filter(dep => !modulesSet.has(dep.module))
<add> .forEach(d => this.dependencies.push(d));
<add> // populate dep warning
<add> m.dependenciesWarnings.forEach(depWarning => this.dependenciesWarnings.push(depWarning));
<add> // populate dep errors
<add> m.dependenciesErrors.forEach(depError => this.dependenciesErrors.push(depError));
<add> // populate warnings
<add> m.warnings.forEach(warning => this.warnings.push(warning));
<add> // populate errors
<add> m.errors.forEach(error => this.errors.push(error));
<add> }
<ide> }
<ide>
<ide> identifier() { | 1 |
Ruby | Ruby | add pinned taps count to brew tap-info | 4165b34ddeb99e67f9ad3ad856a28f28092aa779 | <ide><path>Library/Homebrew/cmd/tap-info.rb
<ide> def print_tap_info(taps)
<ide> tap_count = 0
<ide> formula_count = 0
<ide> command_count = 0
<add> pinned_count = 0
<ide> Tap.each do |tap|
<ide> tap_count += 1
<ide> formula_count += tap.formula_files.size
<ide> command_count += tap.command_files.size
<add> pinned_count += 1 if tap.pinned?
<ide> end
<ide> info = "#{tap_count} tap#{plural(tap_count)}"
<add> info += ", #{pinned_count} pinned"
<ide> info += ", #{formula_count} formula#{plural(formula_count, "e")}"
<ide> info += ", #{command_count} command#{plural(command_count)}"
<ide> info += ", #{Tap::TAP_DIRECTORY.abv}" if Tap::TAP_DIRECTORY.directory? | 1 |
Python | Python | correct linker flags for nag fortran compiler | acb0e9eb57674288ef18bf39908026bc4f42c4a4 | <ide><path>numpy/distutils/fcompiler/nag.py
<ide> def version_match(self, version_string):
<ide> return None
<ide>
<ide> def get_flags_linker_so(self):
<del> if sys.platform == 'darwin':
<del> return ['-unsharedf95',
<del> '-Wl,-bundle,-flat_namespace,-undefined,suppress']
<ide> return ["-Wl,-shared"]
<ide> def get_flags_opt(self):
<ide> return ['-O4']
<ide> class NAGFCompiler(BaseNAGFCompiler):
<ide> 'ranlib' : ["ranlib"]
<ide> }
<ide>
<add> def get_flags_linker_so(self):
<add> if sys.platform == 'darwin':
<add> return ['-unsharedf95', '-Wl,-bundle,-flat_namespace,-undefined,suppress']
<add> return BaseNAGFCompiler.get_flags_linker_so(self)
<ide> def get_flags_arch(self):
<ide> version = self.get_version()
<ide> if version and version < '5.1':
<ide> class NAGFORCompiler(BaseNAGFCompiler):
<ide> 'ranlib' : ["ranlib"]
<ide> }
<ide>
<add> def get_flags_linker_so(self):
<add> if sys.platform == 'darwin':
<add> return ['-unsharedrts',
<add> '-Wl,-bundle,-flat_namespace,-undefined,suppress']
<add> return BaseNAGFCompiler.get_flags_linker_so(self)
<ide> def get_flags_debug(self):
<ide> version = self.get_version()
<ide> if version and version > '6.1': | 1 |
Go | Go | remove timeout on fifos opening | c178700a0420118fe7f632af4da1bc43abd3a9bf | <ide><path>libcontainerd/client_linux.go
<ide> func (clnt *client) GetServerVersion(ctx context.Context) (*ServerVersion, error
<ide> // AddProcess is the handler for adding a process to an already running
<ide> // container. It's called through docker exec. It returns the system pid of the
<ide> // exec'd process.
<del>func (clnt *client) AddProcess(ctx context.Context, containerID, processFriendlyName string, specp Process, attachStdio StdioCallback) (int, error) {
<add>func (clnt *client) AddProcess(ctx context.Context, containerID, processFriendlyName string, specp Process, attachStdio StdioCallback) (pid int, err error) {
<ide> clnt.lock(containerID)
<ide> defer clnt.unlock(containerID)
<ide> container, err := clnt.getContainer(containerID)
<ide> func (clnt *client) AddProcess(ctx context.Context, containerID, processFriendly
<ide> Rlimits: convertRlimits(sp.Rlimits),
<ide> }
<ide>
<del> iopipe, err := p.openFifos(sp.Terminal)
<add> fifoCtx, cancel := context.WithCancel(context.Background())
<add> defer func() {
<add> if err != nil {
<add> cancel()
<add> }
<add> }()
<add>
<add> iopipe, err := p.openFifos(fifoCtx, sp.Terminal)
<ide> if err != nil {
<ide> return -1, err
<ide> }
<ide> func (clnt *client) restore(cont *containerd.Container, lastEvent *containerd.Ev
<ide> }
<ide> }
<ide>
<del> iopipe, err := container.openFifos(terminal)
<add> fifoCtx, cancel := context.WithCancel(context.Background())
<add> defer func() {
<add> if err != nil {
<add> cancel()
<add> }
<add> }()
<add>
<add> iopipe, err := container.openFifos(fifoCtx, terminal)
<ide> if err != nil {
<ide> return err
<ide> }
<ide><path>libcontainerd/container_unix.go
<ide> func (ctr *container) spec() (*specs.Spec, error) {
<ide> return &spec, nil
<ide> }
<ide>
<del>func (ctr *container) start(checkpoint string, checkpointDir string, attachStdio StdioCallback) error {
<add>func (ctr *container) start(checkpoint string, checkpointDir string, attachStdio StdioCallback) (err error) {
<ide> spec, err := ctr.spec()
<ide> if err != nil {
<ide> return nil
<ide> func (ctr *container) start(checkpoint string, checkpointDir string, attachStdio
<ide> defer cancel()
<ide> ready := make(chan struct{})
<ide>
<del> iopipe, err := ctr.openFifos(spec.Process.Terminal)
<add> fifoCtx, cancel := context.WithCancel(context.Background())
<add> defer func() {
<add> if err != nil {
<add> cancel()
<add> }
<add> }()
<add>
<add> iopipe, err := ctr.openFifos(fifoCtx, spec.Process.Terminal)
<ide> if err != nil {
<ide> return err
<ide> }
<ide><path>libcontainerd/process_unix.go
<ide> import (
<ide> "path/filepath"
<ide> goruntime "runtime"
<ide> "strings"
<del> "time"
<ide>
<ide> containerd "github.com/docker/containerd/api/grpc/types"
<ide> "github.com/tonistiigi/fifo"
<ide> type process struct {
<ide> dir string
<ide> }
<ide>
<del>func (p *process) openFifos(terminal bool) (pipe *IOPipe, err error) {
<add>func (p *process) openFifos(ctx context.Context, terminal bool) (pipe *IOPipe, err error) {
<ide> if err := os.MkdirAll(p.dir, 0700); err != nil {
<ide> return nil, err
<ide> }
<ide>
<del> ctx, _ := context.WithTimeout(context.Background(), 15*time.Second)
<del>
<ide> io := &IOPipe{}
<ide>
<ide> io.Stdin, err = fifo.OpenFifo(ctx, p.fifo(unix.Stdin), unix.O_WRONLY|unix.O_CREAT|unix.O_NONBLOCK, 0700) | 3 |
Go | Go | fix jsonmessage in build | 95c0ade04bb8fe95029fed521126e3268a1eda7f | <ide><path>buildfile.go
<ide> type StdoutFormater struct {
<ide> }
<ide>
<ide> func (sf *StdoutFormater) Write(buf []byte) (int, error) {
<del> formattedBuf := sf.StreamFormatter.FormatStatus("", "%s", string(buf))
<add> formattedBuf := sf.StreamFormatter.FormatStream(string(buf))
<ide> n, err := sf.Writer.Write(formattedBuf)
<ide> if n != len(formattedBuf) {
<ide> return n, io.ErrShortWrite
<ide> type StderrFormater struct {
<ide> }
<ide>
<ide> func (sf *StderrFormater) Write(buf []byte) (int, error) {
<del> formattedBuf := sf.StreamFormatter.FormatStatus("", "%s", "\033[91m"+string(buf)+"\033[0m")
<add> formattedBuf := sf.StreamFormatter.FormatStream("\033[91m" + string(buf) + "\033[0m")
<ide> n, err := sf.Writer.Write(formattedBuf)
<ide> if n != len(formattedBuf) {
<ide> return n, io.ErrShortWrite
<ide><path>commands.go
<ide> func (cli *DockerCli) CmdBuild(args ...string) error {
<ide> if context != nil {
<ide> headers.Set("Content-Type", "application/tar")
<ide> }
<del> // Temporary hack to fix displayJSON behavior
<del> cli.isTerminal = false
<ide> err = cli.stream("POST", fmt.Sprintf("/build?%s", v.Encode()), body, cli.out, headers)
<ide> if jerr, ok := err.(*utils.JSONError); ok {
<ide> return &utils.StatusError{Status: jerr.Message, StatusCode: jerr.Code}
<ide><path>utils/jsonmessage.go
<ide> func (p *JSONProgress) String() string {
<ide> }
<ide>
<ide> type JSONMessage struct {
<add> Stream string `json:"stream,omitempty"`
<ide> Status string `json:"status,omitempty"`
<ide> Progress *JSONProgress `json:"progressDetail,omitempty"`
<ide> ProgressMessage string `json:"progress,omitempty"` //deprecated
<ide> func (jm *JSONMessage) Display(out io.Writer, isTerminal bool) error {
<ide> if isTerminal {
<ide> // <ESC>[2K = erase entire current line
<ide> fmt.Fprintf(out, "%c[2K\r", 27)
<del> endl = "\r\n"
<add> endl = "\r"
<ide> }
<ide> if jm.Time != 0 {
<ide> fmt.Fprintf(out, "[%s] ", time.Unix(jm.Time, 0))
<ide> func (jm *JSONMessage) Display(out io.Writer, isTerminal bool) error {
<ide> fmt.Fprintf(out, "%s %s%s", jm.Status, jm.Progress.String(), endl)
<ide> } else if jm.ProgressMessage != "" { //deprecated
<ide> fmt.Fprintf(out, "%s %s%s", jm.Status, jm.ProgressMessage, endl)
<add> } else if jm.Stream != "" {
<add> fmt.Fprintf(out, "%s%s", jm.Stream, endl)
<ide> } else {
<del> fmt.Fprintf(out, "%s%s", jm.Status, endl)
<add> fmt.Fprintf(out, "%s%s\n", jm.Status, endl)
<ide> }
<ide> return nil
<ide> }
<ide><path>utils/streamformatter.go
<ide> func NewStreamFormatter(json bool) *StreamFormatter {
<ide> return &StreamFormatter{json, false}
<ide> }
<ide>
<add>func (sf *StreamFormatter) FormatStream(str string) []byte {
<add> sf.used = true
<add> if sf.json {
<add> b, err := json.Marshal(&JSONMessage{Stream: str})
<add> if err != nil {
<add> return sf.FormatError(err)
<add> }
<add> return b
<add> }
<add> return []byte(str + "\r")
<add>}
<add>
<ide> func (sf *StreamFormatter) FormatStatus(id, format string, a ...interface{}) []byte {
<ide> sf.used = true
<ide> str := fmt.Sprintf(format, a...) | 4 |
Ruby | Ruby | use --time-cond when caching the formula api json | 8993ebca88e6462502d2bddae5393c54ba876a3d | <ide><path>Library/Homebrew/api/formula.rb
<ide> def all_formulae
<ide> if cached_formula_json_file.exist?
<ide> last_modified = cached_formula_json_file.mtime.utc
<ide> last_modified = last_modified.strftime("%a, %d %b %Y %H:%M:%S GMT")
<del> curl_args = ["--header", "If-Modified-Since: #{last_modified}", *curl_args]
<add> curl_args = ["--time-cond", last_modified, *curl_args] unless cached_formula_json_file.empty?
<ide> end
<ide> curl_download(*curl_args, to: HOMEBREW_CACHE_API/"#{formula_api_path}.json", max_time: 5)
<ide> | 1 |
Ruby | Ruby | fix word casing of `xhtml` and `xml builder` | c38d585ef042926a9e99775f092dea0543833110 | <ide><path>actionview/lib/action_view/helpers/atom_feed_helper.rb
<ide> module AtomFeedHelper
<ide> # end
<ide> #
<ide> # The Atom spec defines five elements (content rights title subtitle
<del> # summary) which may directly contain xhtml content if type: 'xhtml'
<add> # summary) which may directly contain XHTML content if type: 'xhtml'
<ide> # is specified as an attribute. If so, this helper will take care of
<del> # the enclosing div and xhtml namespace declaration. Example usage:
<add> # the enclosing div and XHTML namespace declaration. Example usage:
<ide> #
<ide> # entry.summary type: 'xhtml' do |xhtml|
<ide> # xhtml.p pluralize(order.line_items.count, "line item")
<ide> def initialize(xml)
<ide> end
<ide>
<ide> private
<del> # Delegate to xml builder, first wrapping the element in an xhtml
<add> # Delegate to XML Builder, first wrapping the element in an XHTML
<ide> # namespaced div element if the method and arguments indicate
<ide> # that an xhtml_block? is desired.
<ide> def method_missing(method, *arguments, &block) | 1 |
Ruby | Ruby | remove meaningless check | 7a0fe78d08c93574430be3304e83555602f1d875 | <ide><path>activesupport/lib/active_support/railtie.rb
<ide> class Railtie < Rails::Railtie # :nodoc:
<ide> end
<ide>
<ide> initializer "active_support.set_hash_digest_class" do |app|
<del> if app.config.active_support.respond_to?(:hash_digest_class) && app.config.active_support.hash_digest_class
<add> if app.config.active_support.hash_digest_class
<ide> ActiveSupport::Digest.hash_digest_class =
<ide> app.config.active_support.hash_digest_class
<ide> end | 1 |
Javascript | Javascript | add generated file | 762f984dfb36f9a272eb9b7be24bfb252d88099e | <ide><path>d3.js
<ide> d3 = function() {
<ide> };
<ide> var d3_svg_brushResizes = [ [ "n", "e", "s", "w", "nw", "ne", "se", "sw" ], [ "e", "w" ], [ "n", "s" ], [] ];
<ide> var d3_time = d3.time = {}, d3_date = Date, d3_time_daySymbols = [ "Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday" ];
<del> function d3_time_utc() {
<add> function d3_date_utc() {
<ide> this._ = new Date(arguments.length > 1 ? Date.UTC.apply(this, arguments) : arguments[0]);
<ide> }
<del> d3_time_utc.prototype = {
<add> d3_date_utc.prototype = {
<ide> getDate: function() {
<ide> return this._.getUTCDate();
<ide> },
<ide> d3 = function() {
<ide> }
<ide> function range_utc(t0, t1, dt) {
<ide> try {
<del> d3_date = d3_time_utc;
<del> var utc = new d3_time_utc();
<add> d3_date = d3_date_utc;
<add> var utc = new d3_date_utc();
<ide> utc._ = t0;
<ide> return range(utc, t1, dt);
<ide> } finally {
<ide> d3 = function() {
<ide> function d3_time_interval_utc(method) {
<ide> return function(date, k) {
<ide> try {
<del> d3_date = d3_time_utc;
<del> var utc = new d3_time_utc();
<add> d3_date = d3_date_utc;
<add> var utc = new d3_date_utc();
<ide> utc._ = date;
<ide> return method(utc, k)._;
<ide> } finally {
<ide> d3 = function() {
<ide> var local = d3_time_format(template);
<ide> function format(date) {
<ide> try {
<del> d3_date = d3_time_utc;
<add> d3_date = d3_date_utc;
<ide> var utc = new d3_date();
<ide> utc._ = date;
<ide> return local(utc);
<ide> d3 = function() {
<ide> }
<ide> format.parse = function(string) {
<ide> try {
<del> d3_date = d3_time_utc;
<add> d3_date = d3_date_utc;
<ide> var date = local.parse(string);
<ide> return date && date._;
<ide> } finally { | 1 |
Java | Java | remove use of simple executor in websocket clients | 9552c82e2d81bcb6c781793e1fe14708bd4db25b | <ide><path>spring-websocket/src/main/java/org/springframework/web/socket/client/jetty/JettyWebSocketClient.java
<ide> import org.eclipse.jetty.websocket.client.WebSocketClient;
<ide> import org.springframework.context.SmartLifecycle;
<ide> import org.springframework.core.task.AsyncListenableTaskExecutor;
<del>import org.springframework.core.task.SimpleAsyncTaskExecutor;
<ide> import org.springframework.core.task.TaskExecutor;
<ide> import org.springframework.http.HttpHeaders;
<del>import org.springframework.util.Assert;
<ide> import org.springframework.util.concurrent.ListenableFuture;
<add>import org.springframework.util.concurrent.ListenableFutureTask;
<ide> import org.springframework.web.socket.WebSocketHandler;
<ide> import org.springframework.web.socket.WebSocketSession;
<ide> import org.springframework.web.socket.adapter.jetty.JettyWebSocketHandlerAdapter;
<ide> public class JettyWebSocketClient extends AbstractWebSocketClient implements Sma
<ide>
<ide> private final Object lifecycleMonitor = new Object();
<ide>
<del> private AsyncListenableTaskExecutor taskExecutor = new SimpleAsyncTaskExecutor("WebSocketClient-");
<add> private AsyncListenableTaskExecutor taskExecutor;
<ide>
<ide>
<ide> /**
<ide> * Default constructor that creates an instance of
<del> * {@link org.eclipse.jetty.websocket.client.WebSocketClient} with default settings.
<add> * {@link org.eclipse.jetty.websocket.client.WebSocketClient}.
<ide> */
<ide> public JettyWebSocketClient() {
<ide> this.client = new org.eclipse.jetty.websocket.client.WebSocketClient();
<ide> }
<ide>
<ide> /**
<del> * Constructor that accepts a pre-configured {@link WebSocketClient}.
<add> * Constructor that accepts an existing
<add> * {@link org.eclipse.jetty.websocket.client.WebSocketClient} instance.
<ide> */
<ide> public JettyWebSocketClient(WebSocketClient client) {
<del> super();
<ide> this.client = client;
<ide> }
<ide>
<ide>
<ide> /**
<del> * Set a {@link TaskExecutor} to use to open the connection.
<del> * By default {@link SimpleAsyncTaskExecutor} is used.
<add> * Set an {@link AsyncListenableTaskExecutor} to use when opening connections.
<add> *
<add> * <p>If this property is not configured, calls to any of the
<add> * {@code doHandshake} methods will block until the connection is established.
<ide> */
<ide> public void setTaskExecutor(AsyncListenableTaskExecutor taskExecutor) {
<del> Assert.notNull(taskExecutor, "TaskExecutor must not be null");
<ide> this.taskExecutor = taskExecutor;
<ide> }
<ide>
<ide> public ListenableFuture<WebSocketSession> doHandshakeInternal(WebSocketHandler w
<ide> final JettyWebSocketSession wsSession = new JettyWebSocketSession(handshakeAttributes, user);
<ide> final JettyWebSocketHandlerAdapter listener = new JettyWebSocketHandlerAdapter(wsHandler, wsSession);
<ide>
<del> return this.taskExecutor.submitListenable(new Callable<WebSocketSession>() {
<add> Callable<WebSocketSession> connectTask = new Callable<WebSocketSession>() {
<ide> @Override
<ide> public WebSocketSession call() throws Exception {
<ide> Future<Session> future = client.connect(listener, uri, request);
<ide> future.get();
<ide> return wsSession;
<ide> }
<del> });
<add> };
<add>
<add> if (this.taskExecutor != null) {
<add> return this.taskExecutor.submitListenable(connectTask);
<add> }
<add> else {
<add> ListenableFutureTask<WebSocketSession> task = new ListenableFutureTask<WebSocketSession>(connectTask);
<add> task.run();
<add> return task;
<add> }
<ide> }
<ide>
<ide> /**
<ide><path>spring-websocket/src/main/java/org/springframework/web/socket/client/standard/StandardWebSocketClient.java
<ide> import javax.websocket.WebSocketContainer;
<ide>
<ide> import org.springframework.core.task.AsyncListenableTaskExecutor;
<del>import org.springframework.core.task.SimpleAsyncTaskExecutor;
<ide> import org.springframework.core.task.TaskExecutor;
<ide> import org.springframework.http.HttpHeaders;
<ide> import org.springframework.util.Assert;
<ide> import org.springframework.util.concurrent.ListenableFuture;
<add>import org.springframework.util.concurrent.ListenableFutureTask;
<ide> import org.springframework.web.socket.WebSocketExtension;
<ide> import org.springframework.web.socket.WebSocketHandler;
<ide> import org.springframework.web.socket.WebSocketSession;
<ide> public class StandardWebSocketClient extends AbstractWebSocketClient {
<ide>
<ide> private final WebSocketContainer webSocketContainer;
<ide>
<del> private AsyncListenableTaskExecutor taskExecutor = new SimpleAsyncTaskExecutor("WebSocketClient-");
<add> private AsyncListenableTaskExecutor taskExecutor;
<ide>
<ide>
<ide> /**
<ide> * Default constructor that calls {@code ContainerProvider.getWebSocketContainer()}
<del> * to obtain a {@link WebSocketContainer} instance.
<add> * to obtain a (new) {@link WebSocketContainer} instance. Also see constructor
<add> * accepting existing {@code WebSocketContainer} instance.
<ide> */
<ide> public StandardWebSocketClient() {
<ide> this.webSocketContainer = ContainerProvider.getWebSocketContainer();
<ide> }
<ide>
<ide> /**
<del> * Constructor that accepts a pre-configured {@link WebSocketContainer} instance.
<del> * If using XML configuration see {@link WebSocketContainerFactoryBean}. In Java
<add> * Constructor accepting an existing {@link WebSocketContainer} instance.
<add> *
<add> * <p>For XML configuration see {@link WebSocketContainerFactoryBean}. For Java
<ide> * configuration use {@code ContainerProvider.getWebSocketContainer()} to obtain
<del> * a container instance.
<add> * the {@code WebSocketContainer} instance.
<ide> */
<ide> public StandardWebSocketClient(WebSocketContainer webSocketContainer) {
<ide> Assert.notNull(webSocketContainer, "WebSocketContainer must not be null");
<ide> public StandardWebSocketClient(WebSocketContainer webSocketContainer) {
<ide>
<ide>
<ide> /**
<del> * Set a {@link TaskExecutor} to use to open the connection.
<del> * By default {@link SimpleAsyncTaskExecutor} is used.
<add> * Set an {@link AsyncListenableTaskExecutor} to use when opening connections.
<add> *
<add> * <p>If this property is not configured, calls to any of the
<add> * {@code doHandshake} methods will block until the connection is established.
<ide> */
<ide> public void setTaskExecutor(AsyncListenableTaskExecutor taskExecutor) {
<del> Assert.notNull(taskExecutor, "TaskExecutor must not be null");
<ide> this.taskExecutor = taskExecutor;
<ide> }
<ide>
<ide> protected ListenableFuture<WebSocketSession> doHandshakeInternal(WebSocketHandle
<ide> configBuidler.extensions(adaptExtensions(extensions));
<ide> final Endpoint endpoint = new StandardWebSocketHandlerAdapter(webSocketHandler, session);
<ide>
<del> return this.taskExecutor.submitListenable(new Callable<WebSocketSession>() {
<add> Callable<WebSocketSession> connectTask = new Callable<WebSocketSession>() {
<ide> @Override
<ide> public WebSocketSession call() throws Exception {
<ide> webSocketContainer.connectToServer(endpoint, configBuidler.build(), uri);
<ide> return session;
<ide> }
<del> });
<add> };
<add>
<add> if (this.taskExecutor != null) {
<add> return this.taskExecutor.submitListenable(connectTask);
<add> }
<add> else {
<add> ListenableFutureTask<WebSocketSession> task = new ListenableFutureTask<WebSocketSession>(connectTask);
<add> task.run();
<add> return task;
<add> }
<ide> }
<ide>
<ide> private static List<Extension> adaptExtensions(List<WebSocketExtension> extensions) {
<ide><path>spring-websocket/src/test/java/org/springframework/web/socket/client/jetty/JettyWebSocketClientTests.java
<ide> import org.junit.After;
<ide> import org.junit.Before;
<ide> import org.junit.Test;
<add>import org.springframework.core.task.SimpleAsyncTaskExecutor;
<ide> import org.springframework.util.CollectionUtils;
<ide> import org.springframework.util.SocketUtils;
<ide> import org.springframework.web.socket.WebSocketHandler;
<ide> public void doHandshake() throws Exception {
<ide> assertEquals("echo", this.wsSession.getAcceptedProtocol());
<ide> }
<ide>
<add> @Test
<add> public void doHandshakeWithTaskExecutor() throws Exception {
<add>
<add> WebSocketHttpHeaders headers = new WebSocketHttpHeaders();
<add> headers.setSecWebSocketProtocol(Arrays.asList("echo"));
<add>
<add> this.client.setTaskExecutor(new SimpleAsyncTaskExecutor());
<add> this.wsSession = this.client.doHandshake(new TextWebSocketHandler(), headers, new URI(this.wsUrl)).get();
<add>
<add> assertEquals(this.wsUrl, this.wsSession.getUri().toString());
<add> assertEquals("echo", this.wsSession.getAcceptedProtocol());
<add> }
<add>
<ide>
<ide> private static class TestJettyWebSocketServer {
<ide>
<ide><path>spring-websocket/src/test/java/org/springframework/web/socket/client/standard/StandardWebSocketClientTests.java
<ide> /*
<del> * Copyright 2002-2013 the original author or authors.
<add> * Copyright 2002-2014 the original author or authors.
<ide> *
<ide> * Licensed under the Apache License, Version 2.0 (the "License");
<ide> * you may not use this file except in compliance with the License.
<ide> import org.junit.Test;
<ide> import org.mockito.ArgumentCaptor;
<ide>
<add>import org.springframework.core.task.AsyncListenableTaskExecutor;
<add>import org.springframework.core.task.SimpleAsyncTaskExecutor;
<add>import org.springframework.core.task.TaskExecutor;
<ide> import org.springframework.web.socket.WebSocketHandler;
<ide> import org.springframework.web.socket.WebSocketSession;
<ide> import org.springframework.web.socket.handler.AbstractWebSocketHandler;
<ide> public void headersClientEndpointConfigurator() throws Exception {
<ide> assertEquals(Collections.singletonMap("foo", Arrays.asList("bar")), map);
<ide> }
<ide>
<add> @Test
<add> public void taskExecutor() throws Exception {
<add>
<add> URI uri = new URI("ws://example.com/abc");
<add> this.wsClient.setTaskExecutor(new SimpleAsyncTaskExecutor());
<add> WebSocketSession session = this.wsClient.doHandshake(this.wsHandler, this.headers, uri).get();
<add>
<add> assertNotNull(session);
<add> }
<add>
<ide> } | 4 |
Javascript | Javascript | use spread operator on cluster | 12845a8bd1a71f2cf26ae43adef76353dabd09b9 | <ide><path>lib/internal/cluster/master.js
<ide> cluster.setupMaster = function(options) {
<ide> // process has its own memory mappings.)
<ide> if (settings.execArgv.some((s) => s.startsWith('--prof')) &&
<ide> !settings.execArgv.some((s) => s.startsWith('--logfile='))) {
<del> settings.execArgv = settings.execArgv.concat(['--logfile=v8-%p.log']);
<add> settings.execArgv = [...settings.execArgv, '--logfile=v8-%p.log'];
<ide> }
<ide>
<ide> cluster.settings = settings;
<ide> function setupSettingsNT(settings) {
<ide>
<ide> function createWorkerProcess(id, env) {
<ide> const workerEnv = { ...process.env, ...env, NODE_UNIQUE_ID: `${id}` };
<del> const execArgv = cluster.settings.execArgv.slice();
<add> const execArgv = [...cluster.settings.execArgv];
<ide> const debugArgRegex = /--inspect(?:-brk|-port)?|--debug-port/;
<ide> const nodeOptions = process.env.NODE_OPTIONS ?
<ide> process.env.NODE_OPTIONS : ''; | 1 |
Text | Text | add v4.8.0-beta.3 to changelog | 46774eba9a2e8956dd7227cdbd08aad96fe74b26 | <ide><path>CHANGELOG.md
<ide> # Ember Changelog
<ide>
<add>### v4.8.0-beta.3 (September 19, 2022)
<add>
<add>- [#20194](https://github.com/emberjs/ember.js/pull/20194) [BUGFIX] Provide a `.d.ts` file at types/stable
<add>- [#20196](https://github.com/emberjs/ember.js/pull/20196) [BUGFIX] types imports are at 'ember-source/types'
<add>
<ide> ### v4.8.0-beta.2 (September 13, 2022)
<ide>
<ide> - [#20186](https://github.com/emberjs/ember.js/pull/20186) [BUGFIX] Fix `@ember/runloop` type tests folder name so that the tests are properly excluded from the build | 1 |
Go | Go | fix flaky testserviceupdatesecrets | fc21fcc90e5e1270aeb60f8f871adfd18e618c21 | <ide><path>integration-cli/docker_cli_service_update_test.go
<ide> func (s *DockerSwarmSuite) TestServiceUpdateSecrets(c *check.C) {
<ide> c.Assert(err, checker.IsNil, check.Commentf(out))
<ide>
<ide> // add secret
<del> out, err = d.Cmd("service", "update", "test", "--secret-add", fmt.Sprintf("source=%s,target=%s", testName, testTarget))
<add> out, err = d.cmdRetryOutOfSequence("service", "update", "test", "--secret-add", fmt.Sprintf("source=%s,target=%s", testName, testTarget))
<ide> c.Assert(err, checker.IsNil, check.Commentf(out))
<ide>
<ide> out, err = d.Cmd("service", "inspect", "--format", "{{ json .Spec.TaskTemplate.ContainerSpec.Secrets }}", serviceName)
<ide> func (s *DockerSwarmSuite) TestServiceUpdateSecrets(c *check.C) {
<ide> c.Assert(refs[0].Target.Name, checker.Equals, testTarget)
<ide>
<ide> // remove
<del> out, err = d.Cmd("service", "update", "test", "--secret-rm", testName)
<add> out, err = d.cmdRetryOutOfSequence("service", "update", "test", "--secret-rm", testName)
<ide> c.Assert(err, checker.IsNil, check.Commentf(out))
<ide>
<ide> out, err = d.Cmd("service", "inspect", "--format", "{{ json .Spec.TaskTemplate.ContainerSpec.Secrets }}", serviceName) | 1 |
Go | Go | fix race conditions in logs api | 2c252a48c252749d41079cf8c450d00a5c18296e | <ide><path>daemon/logs.go
<ide> import (
<ide> //
<ide> // if it returns nil, the config channel will be active and return log
<ide> // messages until it runs out or the context is canceled.
<del>func (daemon *Daemon) ContainerLogs(ctx context.Context, containerName string, config *types.ContainerLogsOptions) (<-chan *backend.LogMessage, bool, error) {
<add>func (daemon *Daemon) ContainerLogs(ctx context.Context, containerName string, config *types.ContainerLogsOptions) (messages <-chan *backend.LogMessage, isTTY bool, retErr error) {
<ide> lg := logrus.WithFields(logrus.Fields{
<ide> "module": "daemon",
<ide> "method": "(*Daemon).ContainerLogs",
<ide> func (daemon *Daemon) ContainerLogs(ctx context.Context, containerName string, c
<ide> }
<ide> if cLogCreated {
<ide> defer func() {
<del> if err = cLog.Close(); err != nil {
<del> logrus.Errorf("Error closing logger: %v", err)
<add> if retErr != nil {
<add> if err = cLog.Close(); err != nil {
<add> logrus.Errorf("Error closing logger: %v", err)
<add> }
<ide> }
<ide> }()
<ide> }
<ide> func (daemon *Daemon) ContainerLogs(ctx context.Context, containerName string, c
<ide> // this goroutine functions as a shim between the logger and the caller.
<ide> messageChan := make(chan *backend.LogMessage, 1)
<ide> go func() {
<add> if cLogCreated {
<add> defer func() {
<add> if err = cLog.Close(); err != nil {
<add> logrus.Errorf("Error closing logger: %v", err)
<add> }
<add> }()
<add> }
<ide> // set up some defers
<ide> defer logs.Close()
<ide> | 1 |
Javascript | Javascript | replace double with single quotes | 6928b84f9244c5be300dce4d41709c3da83e6661 | <ide><path>src/lib/create/check-overflow.js
<del>import { daysInMonth } from "../units/month";
<del>import { YEAR, MONTH, DATE, HOUR, MINUTE, SECOND, MILLISECOND } from "../units/constants";
<add>import { daysInMonth } from '../units/month';
<add>import { YEAR, MONTH, DATE, HOUR, MINUTE, SECOND, MILLISECOND } from '../units/constants';
<ide>
<ide> export default function checkOverflow (m) {
<ide> var overflow;
<ide><path>src/lib/create/from-anything.js
<del>import defaultParsingFlags from "./default-parsing-flags";
<del>import isArray from "../utils/is-array";
<del>import isDate from "../utils/is-date";
<del>import map from "../utils/map";
<del>import { createInvalid } from "./valid";
<del>import { Moment, isMoment } from "../moment/constructor";
<del>import { getLocale } from "../locale/locales";
<del>import { hooks } from "../utils/hooks";
<del>import checkOverflow from "./check-overflow";
<add>import defaultParsingFlags from './default-parsing-flags';
<add>import isArray from '../utils/is-array';
<add>import isDate from '../utils/is-date';
<add>import map from '../utils/map';
<add>import { createInvalid } from './valid';
<add>import { Moment, isMoment } from '../moment/constructor';
<add>import { getLocale } from '../locale/locales';
<add>import { hooks } from '../utils/hooks';
<add>import checkOverflow from './check-overflow';
<ide>
<del>import { configFromStringAndArray } from "./from-string-and-array";
<del>import { configFromStringAndFormat } from "./from-string-and-format";
<del>import { configFromString } from "./from-string";
<del>import { configFromArray } from "./from-array";
<del>import { configFromObject } from "./from-object";
<add>import { configFromStringAndArray } from './from-string-and-array';
<add>import { configFromStringAndFormat } from './from-string-and-format';
<add>import { configFromString } from './from-string';
<add>import { configFromArray } from './from-array';
<add>import { configFromObject } from './from-object';
<ide>
<ide> function createFromConfig (config) {
<ide> var input = config._i,
<ide><path>src/lib/create/from-array.js
<del>import { createDate, createUTCDate } from "./date-from-array";
<del>import { daysInYear } from "../units/year";
<del>import { weekOfYear } from "../units/week";
<del>import { dayOfYearFromWeeks } from "../units/day-of-year";
<del>import { YEAR, MONTH, DATE, HOUR, MINUTE, SECOND, MILLISECOND } from "../units/constants";
<del>import { createLocal } from "./local";
<del>import defaults from "../utils/defaults";
<add>import { createDate, createUTCDate } from './date-from-array';
<add>import { daysInYear } from '../units/year';
<add>import { weekOfYear } from '../units/week';
<add>import { dayOfYearFromWeeks } from '../units/day-of-year';
<add>import { YEAR, MONTH, DATE, HOUR, MINUTE, SECOND, MILLISECOND } from '../units/constants';
<add>import { createLocal } from './local';
<add>import defaults from '../utils/defaults';
<ide>
<ide> function currentDateArray(config) {
<ide> var now = new Date();
<ide><path>src/lib/create/from-object.js
<del>import { normalizeObjectUnits } from "../units/aliases";
<del>import { configFromArray } from "./from-array";
<add>import { normalizeObjectUnits } from '../units/aliases';
<add>import { configFromArray } from './from-array';
<ide>
<ide> export function configFromObject(config) {
<ide> if (config._d) {
<ide><path>src/lib/create/from-string-and-array.js
<del>import { copyConfig } from "../moment/constructor";
<del>import { configFromStringAndFormat } from "./from-string-and-format";
<del>import defaultParsingFlags from "./default-parsing-flags";
<del>import { isValid } from "./valid";
<del>import extend from "../utils/extend";
<add>import { copyConfig } from '../moment/constructor';
<add>import { configFromStringAndFormat } from './from-string-and-format';
<add>import defaultParsingFlags from './default-parsing-flags';
<add>import { isValid } from './valid';
<add>import extend from '../utils/extend';
<ide>
<ide> // date from string and array of format strings
<ide> export function configFromStringAndArray(config) {
<ide><path>src/lib/create/from-string-and-format.js
<del>import { configFromISO } from "./from-string";
<del>import { configFromArray } from "./from-array";
<del>import { getParseRegexForToken } from "../parse/regex";
<del>import { addTimeToArrayFromToken } from "../parse/token";
<del>import { expandFormat, formatTokenFunctions, formattingTokens } from "../format/format";
<del>import checkOverflow from "./check-overflow";
<del>import { HOUR } from "../units/constants";
<del>import { hooks } from "../utils/hooks";
<add>import { configFromISO } from './from-string';
<add>import { configFromArray } from './from-array';
<add>import { getParseRegexForToken } from '../parse/regex';
<add>import { addTimeToArrayFromToken } from '../parse/token';
<add>import { expandFormat, formatTokenFunctions, formattingTokens } from '../format/format';
<add>import checkOverflow from './check-overflow';
<add>import { HOUR } from '../units/constants';
<add>import { hooks } from '../utils/hooks';
<ide>
<ide> // constant that refers to the ISO standard
<ide> hooks.ISO_8601 = function () {};
<ide><path>src/lib/create/from-string.js
<del>import { matchOffset } from "../parse/regex";
<del>import { configFromStringAndFormat } from "./from-string-and-format";
<del>import { hooks } from "../utils/hooks";
<del>import { deprecate } from "../utils/deprecate";
<add>import { matchOffset } from '../parse/regex';
<add>import { configFromStringAndFormat } from './from-string-and-format';
<add>import { hooks } from '../utils/hooks';
<add>import { deprecate } from '../utils/deprecate';
<ide>
<ide> // iso 8601 regex
<ide> // 0000-00-00 0000-W00 or 0000-W00-0 + T + 00 or 00:00 or 00:00:00 or 00:00:00.000 + +00:00 or +0000 or +00)
<ide><path>src/lib/create/local.js
<del>import { createLocalOrUTC } from "./from-anything";
<add>import { createLocalOrUTC } from './from-anything';
<ide>
<ide> export function createLocal (input, format, locale, strict) {
<ide> return createLocalOrUTC(input, format, locale, strict, false);
<ide><path>src/lib/create/utc.js
<del>import { createLocalOrUTC } from "./from-anything";
<add>import { createLocalOrUTC } from './from-anything';
<ide>
<ide> export function createUTC (input, format, locale, strict) {
<ide> return createLocalOrUTC(input, format, locale, strict, true).utc();
<ide><path>src/lib/create/valid.js
<del>import extend from "../utils/extend";
<del>import { createUTC } from "./utc";
<add>import extend from '../utils/extend';
<add>import { createUTC } from './utc';
<ide>
<ide> export function isValid(m) {
<ide> if (m._isValid == null) {
<ide><path>src/lib/duration/add-subtract.js
<del>import { createDuration } from "./create";
<add>import { createDuration } from './create';
<ide>
<ide> function addSubtract (duration, input, value, direction) {
<ide> var other = createDuration(input, value);
<ide><path>src/lib/duration/as.js
<del>import { daysToYears, yearsToDays } from "./bubble";
<del>import { normalizeUnits } from "../units/aliases";
<del>import toInt from "../utils/to-int";
<add>import { daysToYears, yearsToDays } from './bubble';
<add>import { normalizeUnits } from '../units/aliases';
<add>import toInt from '../utils/to-int';
<ide>
<ide> export function as (units) {
<ide> var days;
<ide> export function as (units) {
<ide>
<ide> units = normalizeUnits(units);
<ide>
<del> if (units === "month" || units === "year") {
<add> if (units === 'month' || units === 'year') {
<ide> days = this._days + milliseconds / 864e5;
<ide> months = this._months + daysToYears(days) * 12;
<del> return units === "month" ? months : months / 12;
<add> return units === 'month' ? months : months / 12;
<ide> } else {
<ide> // handle milliseconds separately because of floating point math errors (issue #1867)
<ide> days = this._days + Math.round(yearsToDays(this._months / 12));
<ide> switch (units) {
<del> case "week" : return days / 7 + milliseconds / 6048e5;
<del> case "day" : return days + milliseconds / 864e5;
<del> case "hour" : return days * 24 + milliseconds / 36e5;
<del> case "minute" : return days * 24 * 60 + milliseconds / 6e4;
<del> case "second" : return days * 24 * 60 * 60 + milliseconds / 1000;
<add> case 'week' : return days / 7 + milliseconds / 6048e5;
<add> case 'day' : return days + milliseconds / 864e5;
<add> case 'hour' : return days * 24 + milliseconds / 36e5;
<add> case 'minute' : return days * 24 * 60 + milliseconds / 6e4;
<add> case 'second' : return days * 24 * 60 * 60 + milliseconds / 1000;
<ide> // Math.floor prevents floating point math errors here
<del> case "millisecond": return Math.floor(days * 24 * 60 * 60 * 1000) + milliseconds;
<del> default: throw new Error("Unknown unit " + units);
<add> case 'millisecond': return Math.floor(days * 24 * 60 * 60 * 1000) + milliseconds;
<add> default: throw new Error('Unknown unit ' + units);
<ide> }
<ide> }
<ide> }
<ide> function makeAs (alias) {
<ide> };
<ide> }
<ide>
<del>export var asMilliseconds = makeAs("ms");
<del>export var asSeconds = makeAs("s");
<del>export var asMinutes = makeAs("m");
<del>export var asHours = makeAs("h");
<del>export var asDays = makeAs("d");
<del>export var asWeeks = makeAs("w");
<del>export var asMonths = makeAs("M");
<del>export var asYears = makeAs("y");
<add>export var asMilliseconds = makeAs('ms');
<add>export var asSeconds = makeAs('s');
<add>export var asMinutes = makeAs('m');
<add>export var asHours = makeAs('h');
<add>export var asDays = makeAs('d');
<add>export var asWeeks = makeAs('w');
<add>export var asMonths = makeAs('M');
<add>export var asYears = makeAs('y');
<ide><path>src/lib/duration/bubble.js
<del>import absFloor from "../utils/abs-floor";
<add>import absFloor from '../utils/abs-floor';
<ide>
<ide> export function bubble () {
<ide> var milliseconds = this._milliseconds;
<ide><path>src/lib/duration/constructor.js
<del>import { normalizeObjectUnits } from "../units/aliases";
<del>import { getLocale } from "../locale/locales";
<add>import { normalizeObjectUnits } from '../units/aliases';
<add>import { getLocale } from '../locale/locales';
<ide>
<ide> export function Duration (duration) {
<ide> var normalizedInput = normalizeObjectUnits(duration),
<ide><path>src/lib/duration/create.js
<del>import { Duration, isDuration } from "./constructor";
<del>import toInt from "../utils/to-int";
<del>import hasOwnProp from "../utils/has-own-prop";
<del>import { DATE, HOUR, MINUTE, SECOND, MILLISECOND } from "../units/constants";
<del>import { cloneWithOffset } from "../units/offset";
<del>import { createLocal } from "../create/local";
<add>import { Duration, isDuration } from './constructor';
<add>import toInt from '../utils/to-int';
<add>import hasOwnProp from '../utils/has-own-prop';
<add>import { DATE, HOUR, MINUTE, SECOND, MILLISECOND } from '../units/constants';
<add>import { cloneWithOffset } from '../units/offset';
<add>import { createLocal } from '../create/local';
<ide>
<ide> // ASP.NET json date format regex
<ide> var aspNetRegex = /(\-)?(?:(\d*)\.)?(\d+)\:(\d+)(?:\:(\d+)\.?(\d{3})?)?/;
<ide><path>src/lib/duration/duration.js
<ide> // Side effect imports
<del>import "./prototype";
<add>import './prototype';
<ide>
<del>import { createDuration } from "./create";
<del>import { isDuration } from "./constructor";
<del>import { getSetRelativeTimeThreshold } from "./humanize";
<add>import { createDuration } from './create';
<add>import { isDuration } from './constructor';
<add>import { getSetRelativeTimeThreshold } from './humanize';
<ide>
<ide> export {
<ide> createDuration,
<ide><path>src/lib/duration/get.js
<del>import { normalizeUnits } from "../units/aliases";
<del>import absFloor from "../utils/abs-floor";
<add>import { normalizeUnits } from '../units/aliases';
<add>import absFloor from '../utils/abs-floor';
<ide>
<ide> export function get (units) {
<ide> units = normalizeUnits(units);
<ide><path>src/lib/duration/humanize.js
<del>import { createDuration } from "./create";
<add>import { createDuration } from './create';
<ide>
<ide> var round = Math.round;
<ide> var thresholds = {
<ide><path>src/lib/duration/prototype.js
<del>import { Duration } from "./constructor";
<add>import { Duration } from './constructor';
<ide>
<ide> var proto = Duration.prototype;
<ide>
<del>import { abs } from "./abs";
<del>import { add, subtract } from "./add-subtract";
<del>import { as, asMilliseconds, asSeconds, asMinutes, asHours, asDays, asWeeks, asMonths, asYears, valueOf } from "./as";
<del>import { bubble } from "./bubble";
<del>import { get, milliseconds, seconds, minutes, hours, days, months, years, weeks } from "./get";
<del>import { humanize } from "./humanize";
<del>import { toISOString } from "./iso-string";
<del>import { lang, locale, localeData } from "../moment/locale";
<add>import { abs } from './abs';
<add>import { add, subtract } from './add-subtract';
<add>import { as, asMilliseconds, asSeconds, asMinutes, asHours, asDays, asWeeks, asMonths, asYears, valueOf } from './as';
<add>import { bubble } from './bubble';
<add>import { get, milliseconds, seconds, minutes, hours, days, months, years, weeks } from './get';
<add>import { humanize } from './humanize';
<add>import { toISOString } from './iso-string';
<add>import { lang, locale, localeData } from '../moment/locale';
<ide>
<ide> proto.abs = abs;
<ide> proto.add = add;
<ide> proto.locale = locale;
<ide> proto.localeData = localeData;
<ide>
<ide> // Deprecations
<del>import { deprecate } from "../utils/deprecate";
<add>import { deprecate } from '../utils/deprecate';
<ide>
<ide> proto.toIsoString = deprecate('toIsoString() is deprecated. Please use toISOString() instead (notice the capitals)', toISOString);
<ide> proto.lang = lang;
<ide><path>src/lib/format/format.js
<del>import zeroFill from "../utils/zero-fill";
<add>import zeroFill from '../utils/zero-fill';
<ide>
<ide> export var formattingTokens = /(\[[^\[]*\])|(\\)?(Mo|MM?M?M?|Do|DDDo|DD?D?D?|ddd?d?|do?|w[o|w]?|W[o|W]?|Q|YYYYYY|YYYYY|YYYY|YY|gg(ggg?)?|GG(GGG?)?|e|E|a|A|hh?|HH?|mm?|ss?|S{1,4}|x|X|zz?|ZZ?|.)/g;
<ide>
<ide> var formatFunctions = {};
<ide>
<ide> export var formatTokenFunctions = {};
<ide>
<del>// token: "M"
<del>// padded: ["MM", 2]
<del>// ordinal: "Mo"
<add>// token: 'M'
<add>// padded: ['MM', 2]
<add>// ordinal: 'Mo'
<ide> // callback: function () { this.month() + 1 }
<ide> export function addFormatToken (token, padded, ordinal, callback) {
<ide> var func = callback;
<del> if (typeof callback === "string") {
<add> if (typeof callback === 'string') {
<ide> func = function () {
<ide> return this[callback]();
<ide> };
<ide><path>src/lib/locale/en.js
<del>import "./prototype";
<del>import { getSetGlobalLocale } from "./locales";
<del>import toInt from "../utils/to-int";
<add>import './prototype';
<add>import { getSetGlobalLocale } from './locales';
<add>import toInt from '../utils/to-int';
<ide>
<ide> getSetGlobalLocale('en', {
<ide> ordinalParse: /\d{1,2}(th|st|nd|rd)/,
<ide><path>src/lib/locale/lists.js
<del>import { getLocale } from "./locales";
<del>import { createUTC } from "../create/utc";
<add>import { getLocale } from './locales';
<add>import { createUTC } from '../create/utc';
<ide>
<ide> function get (format, index, field, setter) {
<ide> var locale = getLocale();
<ide> function list (format, index, field, count, setter) {
<ide> }
<ide>
<ide> export function listMonths (format, index) {
<del> return list(format, index, "months", 12, "month");
<add> return list(format, index, 'months', 12, 'month');
<ide> }
<ide>
<ide> export function listMonthsShort (format, index) {
<del> return list(format, index, "monthsShort", 12, "month");
<add> return list(format, index, 'monthsShort', 12, 'month');
<ide> }
<ide>
<ide> export function listWeekdays (format, index) {
<del> return list(format, index, "weekdays", 7, "day");
<add> return list(format, index, 'weekdays', 7, 'day');
<ide> }
<ide>
<ide> export function listWeekdaysShort (format, index) {
<del> return list(format, index, "weekdaysShort", 7, "day");
<add> return list(format, index, 'weekdaysShort', 7, 'day');
<ide> }
<ide>
<ide> export function listWeekdaysMin (format, index) {
<del> return list(format, index, "weekdaysMin", 7, "day");
<add> return list(format, index, 'weekdaysMin', 7, 'day');
<ide> }
<ide><path>src/lib/locale/locale.js
<ide> // Side effect imports
<del>import "./prototype";
<add>import './prototype';
<ide>
<ide> import {
<ide> getSetGlobalLocale,
<ide> defineLocale,
<ide> getLocale
<del>} from "./locales";
<add>} from './locales';
<ide>
<ide> import {
<ide> listMonths,
<ide> listMonthsShort,
<ide> listWeekdays,
<ide> listWeekdaysShort,
<ide> listWeekdaysMin
<del>} from "./lists";
<add>} from './lists';
<ide>
<ide> export {
<ide> getSetGlobalLocale,
<ide> export {
<ide> listWeekdaysMin
<ide> };
<ide>
<del>import { deprecate } from "../utils/deprecate";
<del>import { hooks } from "../utils/hooks";
<add>import { deprecate } from '../utils/deprecate';
<add>import { hooks } from '../utils/hooks';
<ide>
<ide> hooks.lang = deprecate('moment.lang is deprecated. Use moment.locale instead.', getSetGlobalLocale);
<ide> hooks.langData = deprecate('moment.langData is deprecated. Use moment.localeData instead.', getLocale);
<ide>
<del>import "./en";
<add>import './en';
<ide><path>src/lib/locale/locales.js
<del>import isArray from "../utils/is-array";
<del>import compareArrays from "../utils/compare-arrays";
<del>import { Locale } from "./constructor";
<add>import isArray from '../utils/is-array';
<add>import compareArrays from '../utils/compare-arrays';
<add>import { Locale } from './constructor';
<ide>
<ide> // internal storage for locale config files
<ide> var locales = {};
<ide><path>src/lib/locale/prototype.js
<del>import { Locale } from "./constructor";
<add>import { Locale } from './constructor';
<ide>
<ide> var proto = Locale.prototype;
<ide>
<del>import { defaultCalendar, calendar } from "./calendar";
<del>import { defaultLongDateFormat, longDateFormat } from "./formats";
<del>import { defaultInvalidDate, invalidDate } from "./invalid";
<del>import { defaultOrdinal, ordinal, defaultOrdinalParse } from "./ordinal";
<del>import { preParsePostFormat } from "./pre-post-format";
<del>import { defaultRelativeTime, relativeTime, pastFuture } from "./relative";
<del>import { set } from "./set";
<add>import { defaultCalendar, calendar } from './calendar';
<add>import { defaultLongDateFormat, longDateFormat } from './formats';
<add>import { defaultInvalidDate, invalidDate } from './invalid';
<add>import { defaultOrdinal, ordinal, defaultOrdinalParse } from './ordinal';
<add>import { preParsePostFormat } from './pre-post-format';
<add>import { defaultRelativeTime, relativeTime, pastFuture } from './relative';
<add>import { set } from './set';
<ide>
<ide> proto._calendar = defaultCalendar;
<ide> proto.calendar = calendar;
<ide> import {
<ide> localeMonthsParse,
<ide> defaultLocaleMonths, localeMonths,
<ide> defaultLocaleMonthsShort, localeMonthsShort
<del>} from "../units/month";
<add>} from '../units/month';
<ide>
<ide> proto.months = localeMonths;
<ide> proto._months = defaultLocaleMonths;
<ide> proto._monthsShort = defaultLocaleMonthsShort;
<ide> proto.monthsParse = localeMonthsParse;
<ide>
<ide> // Week
<del>import { localeWeek, defaultLocaleWeek, localeFirstDayOfYear, localeFirstDayOfWeek } from "../units/week";
<add>import { localeWeek, defaultLocaleWeek, localeFirstDayOfYear, localeFirstDayOfWeek } from '../units/week';
<ide> proto.week = localeWeek;
<ide> proto._week = defaultLocaleWeek;
<ide> proto.firstDayOfYear = localeFirstDayOfYear;
<ide> import {
<ide> defaultLocaleWeekdays, localeWeekdays,
<ide> defaultLocaleWeekdaysMin, localeWeekdaysMin,
<ide> defaultLocaleWeekdaysShort, localeWeekdaysShort
<del>} from "../units/day-of-week";
<add>} from '../units/day-of-week';
<ide>
<ide> proto.weekdays = localeWeekdays;
<ide> proto._weekdays = defaultLocaleWeekdays;
<ide> proto._weekdaysShort = defaultLocaleWeekdaysShort;
<ide> proto.weekdaysParse = localeWeekdaysParse;
<ide>
<ide> // Hours
<del>import { localeIsPM, defaultLocaleMeridiemParse, localeMeridiem } from "../units/hour";
<add>import { localeIsPM, defaultLocaleMeridiemParse, localeMeridiem } from '../units/hour';
<ide>
<ide> proto.isPM = localeIsPM;
<ide> proto._meridiemParse = defaultLocaleMeridiemParse;
<ide><path>src/lib/moment/add-subtract.js
<del>import { get, set } from "./get-set";
<del>import { setMonth } from "../units/month";
<del>import { createDuration } from "../duration/create";
<del>import { deprecateSimple } from "../utils/deprecate";
<del>import { hooks } from "../utils/hooks";
<add>import { get, set } from './get-set';
<add>import { setMonth } from '../units/month';
<add>import { createDuration } from '../duration/create';
<add>import { deprecateSimple } from '../utils/deprecate';
<add>import { hooks } from '../utils/hooks';
<ide>
<ide> // TODO: remove 'name' arg after deprecation is removed
<ide> function createAdder(direction, name) {
<ide><path>src/lib/moment/calendar.js
<del>import { createLocal } from "../create/local";
<del>import { cloneWithOffset } from "../units/offset";
<add>import { createLocal } from '../create/local';
<add>import { cloneWithOffset } from '../units/offset';
<ide>
<ide> export function calendar (time) {
<ide> // We want to compare the start of today, vs this.
<ide><path>src/lib/moment/clone.js
<del>import { Moment } from "./constructor";
<add>import { Moment } from './constructor';
<ide>
<ide> export function clone () {
<ide> return new Moment(this);
<ide><path>src/lib/moment/compare.js
<del>import { isMoment } from "./constructor";
<del>import { normalizeUnits } from "../units/aliases";
<del>import { createLocal } from "../create/local";
<add>import { isMoment } from './constructor';
<add>import { normalizeUnits } from '../units/aliases';
<add>import { createLocal } from '../create/local';
<ide>
<ide> export function isAfter (input, units) {
<ide> var inputMs;
<ide><path>src/lib/moment/constructor.js
<del>import { hooks } from "../utils/hooks";
<del>import hasOwnProp from "../utils/has-own-prop";
<add>import { hooks } from '../utils/hooks';
<add>import hasOwnProp from '../utils/has-own-prop';
<ide>
<ide> // Plugins that add properties should also add the key here (null value),
<ide> // so we can properly clone ourselves.
<ide><path>src/lib/moment/diff.js
<del>import absFloor from "../utils/abs-floor";
<del>import { cloneWithOffset } from "../units/offset";
<del>import { normalizeUnits } from "../units/aliases";
<add>import absFloor from '../utils/abs-floor';
<add>import { cloneWithOffset } from '../units/offset';
<add>import { normalizeUnits } from '../units/aliases';
<ide>
<ide> export function diff (input, units, asFloat) {
<ide> var that = cloneWithOffset(input, this),
<ide><path>src/lib/moment/format.js
<del>import { formatMoment } from "../format/format";
<del>import { hooks } from "../utils/hooks";
<add>import { formatMoment } from '../format/format';
<add>import { hooks } from '../utils/hooks';
<ide>
<ide> hooks.defaultFormat = 'YYYY-MM-DDTHH:mm:ssZ';
<ide>
<ide><path>src/lib/moment/from.js
<del>import { createDuration } from "../duration/create";
<del>import { createLocal } from "../create/local";
<add>import { createDuration } from '../duration/create';
<add>import { createLocal } from '../create/local';
<ide>
<ide> export function from (time, withoutSuffix) {
<ide> return createDuration({to: this, from: time}).locale(this.locale()).humanize(!withoutSuffix);
<ide><path>src/lib/moment/get-set.js
<del>import { normalizeUnits } from "../units/aliases";
<del>import { hooks } from "../utils/hooks";
<add>import { normalizeUnits } from '../units/aliases';
<add>import { hooks } from '../utils/hooks';
<ide>
<ide> export function makeGetSet (unit, keepTime) {
<ide> return function (value) {
<ide><path>src/lib/moment/locale.js
<del>import { getLocale } from "../locale/locales";
<del>import { deprecate } from "../utils/deprecate";
<add>import { getLocale } from '../locale/locales';
<add>import { deprecate } from '../utils/deprecate';
<ide>
<ide> // If passed a locale key, it will set the locale for this
<ide> // instance. Otherwise, it will return the locale configuration
<ide><path>src/lib/moment/min-max.js
<del>import { deprecate } from "../utils/deprecate";
<del>import isArray from "../utils/is-array";
<del>import { createLocal } from "../create/local";
<add>import { deprecate } from '../utils/deprecate';
<add>import isArray from '../utils/is-array';
<add>import { createLocal } from '../create/local';
<ide>
<ide> export var prototypeMin = deprecate(
<ide> 'moment().min is deprecated, use moment.min instead. https://github.com/moment/moment/issues/1548',
<ide><path>src/lib/moment/moment.js
<del>import { createLocal } from "../create/local";
<del>import { createUTC } from "../create/utc";
<del>import { createInvalid } from "../create/valid";
<del>import { isMoment } from "./constructor";
<del>import { min, max } from "./min-max";
<del>import momentPrototype from "./prototype";
<add>import { createLocal } from '../create/local';
<add>import { createUTC } from '../create/utc';
<add>import { createInvalid } from '../create/valid';
<add>import { isMoment } from './constructor';
<add>import { min, max } from './min-max';
<add>import momentPrototype from './prototype';
<ide>
<ide> function createUnix (input) {
<ide> return createLocal(input * 1000);
<ide><path>src/lib/moment/prototype.js
<del>import { Moment } from "./constructor";
<add>import { Moment } from './constructor';
<ide>
<ide> var proto = Moment.prototype;
<ide>
<del>import { add, subtract } from "./add-subtract";
<del>import { calendar } from "./calendar";
<del>import { clone } from "./clone";
<del>import { isBefore, isBetween, isSame, isAfter } from "./compare";
<del>import { diff } from "./diff";
<del>import { format, toString, toISOString } from "./format";
<del>import { from, fromNow } from "./from";
<del>import { getSet } from "./get-set";
<del>import { locale, localeData, lang } from "./locale";
<del>import { prototypeMin, prototypeMax } from "./min-max";
<del>import { startOf, endOf } from "./start-end-of";
<del>import { valueOf, toDate, toArray, unix } from "./to-type";
<del>import { isValid, parsingFlags, invalidAt } from "./valid";
<add>import { add, subtract } from './add-subtract';
<add>import { calendar } from './calendar';
<add>import { clone } from './clone';
<add>import { isBefore, isBetween, isSame, isAfter } from './compare';
<add>import { diff } from './diff';
<add>import { format, toString, toISOString } from './format';
<add>import { from, fromNow } from './from';
<add>import { getSet } from './get-set';
<add>import { locale, localeData, lang } from './locale';
<add>import { prototypeMin, prototypeMax } from './min-max';
<add>import { startOf, endOf } from './start-end-of';
<add>import { valueOf, toDate, toArray, unix } from './to-type';
<add>import { isValid, parsingFlags, invalidAt } from './valid';
<ide>
<ide> proto.add = add;
<ide> proto.calendar = calendar;
<ide> proto.unix = unix;
<ide> proto.valueOf = valueOf;
<ide>
<ide> // Year
<del>import { getSetYear, getIsLeapYear } from "../units/year";
<add>import { getSetYear, getIsLeapYear } from '../units/year';
<ide> proto.year = getSetYear;
<ide> proto.isLeapYear = getIsLeapYear;
<ide>
<ide> // Week Year
<del>import { getSetWeekYear, getSetISOWeekYear, getWeeksInYear, getISOWeeksInYear } from "../units/week-year";
<add>import { getSetWeekYear, getSetISOWeekYear, getWeeksInYear, getISOWeeksInYear } from '../units/week-year';
<ide> proto.weekYear = getSetWeekYear;
<ide> proto.isoWeekYear = getSetISOWeekYear;
<ide>
<ide> // Quarter
<del>import { getSetQuarter } from "../units/quarter";
<add>import { getSetQuarter } from '../units/quarter';
<ide> proto.quarter = proto.quarters = getSetQuarter;
<ide>
<ide> // Month
<del>import { getSetMonth, getDaysInMonth } from "../units/month";
<add>import { getSetMonth, getDaysInMonth } from '../units/month';
<ide> proto.month = getSetMonth;
<ide> proto.daysInMonth = getDaysInMonth;
<ide>
<ide> // Week
<del>import { getSetWeek, getSetISOWeek } from "../units/week";
<add>import { getSetWeek, getSetISOWeek } from '../units/week';
<ide> proto.week = proto.weeks = getSetWeek;
<ide> proto.isoWeek = proto.isoWeeks = getSetISOWeek;
<ide> proto.weeksInYear = getWeeksInYear;
<ide> proto.isoWeeksInYear = getISOWeeksInYear;
<ide>
<ide> // Day
<del>import { getSetDayOfMonth } from "../units/day-of-month";
<del>import { getSetDayOfWeek, getSetISODayOfWeek, getSetLocaleDayOfWeek } from "../units/day-of-week";
<del>import { getSetDayOfYear } from "../units/day-of-year";
<add>import { getSetDayOfMonth } from '../units/day-of-month';
<add>import { getSetDayOfWeek, getSetISODayOfWeek, getSetLocaleDayOfWeek } from '../units/day-of-week';
<add>import { getSetDayOfYear } from '../units/day-of-year';
<ide> proto.date = getSetDayOfMonth;
<ide> proto.day = proto.days = getSetDayOfWeek;
<ide> proto.weekday = getSetLocaleDayOfWeek;
<ide> proto.isoWeekday = getSetISODayOfWeek;
<ide> proto.dayOfYear = getSetDayOfYear;
<ide>
<ide> // Hour
<del>import { getSetHour } from "../units/hour";
<add>import { getSetHour } from '../units/hour';
<ide> proto.hour = proto.hours = getSetHour;
<ide>
<ide> // Minute
<del>import { getSetMinute } from "../units/minute";
<add>import { getSetMinute } from '../units/minute';
<ide> proto.minute = proto.minutes = getSetMinute;
<ide>
<ide> // Second
<del>import { getSetSecond } from "../units/second";
<add>import { getSetSecond } from '../units/second';
<ide> proto.second = proto.seconds = getSetSecond;
<ide>
<ide> // Millisecond
<del>import { getSetMillisecond } from "../units/millisecond";
<add>import { getSetMillisecond } from '../units/millisecond';
<ide> proto.millisecond = proto.milliseconds = getSetMillisecond;
<ide>
<ide> // Offset
<ide> import {
<ide> isLocal,
<ide> isUtcOffset,
<ide> isUtc
<del>} from "../units/offset";
<add>} from '../units/offset';
<ide> proto.utcOffset = getSetOffset;
<ide> proto.utc = setOffsetToUTC;
<ide> proto.local = setOffsetToLocal;
<ide> proto.isUtc = isUtc;
<ide> proto.isUTC = isUtc;
<ide>
<ide> // Timezone
<del>import { getZoneAbbr, getZoneName } from "../units/timezone";
<add>import { getZoneAbbr, getZoneName } from '../units/timezone';
<ide> proto.zoneAbbr = getZoneAbbr;
<ide> proto.zoneName = getZoneName;
<ide>
<ide> // Deprecations
<del>import { deprecate } from "../utils/deprecate";
<add>import { deprecate } from '../utils/deprecate';
<ide> proto.dates = deprecate('dates accessor is deprecated. Use date instead.', getSetDayOfMonth);
<ide> proto.months = deprecate('months accessor is deprecated. Use month instead', getSetMonth);
<ide> proto.years = deprecate('years accessor is deprecated. Use year instead', getSetYear);
<ide><path>src/lib/moment/start-end-of.js
<del>import { normalizeUnits } from "../units/aliases";
<add>import { normalizeUnits } from '../units/aliases';
<ide>
<ide> export function startOf (units) {
<ide> units = normalizeUnits(units);
<ide><path>src/lib/moment/valid.js
<del>import { isValid as _isValid } from "../create/valid";
<del>import extend from "../utils/extend";
<add>import { isValid as _isValid } from '../create/valid';
<add>import extend from '../utils/extend';
<ide>
<ide> export function isValid () {
<ide> return _isValid(this);
<ide><path>src/lib/parse/regex.js
<ide> export var matchTimestamp = /[+-]?\d+(\.\d{1,3})?/; // 123456789 123456789.123
<ide> // any word (or two) characters or numbers including two/three word month in arabic.
<ide> export var matchWord = /[0-9]*['a-z\u00A0-\u05FF\u0700-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF]+|[\u0600-\u06FF\/]+(\s*?[\u0600-\u06FF]+){1,2}/i;
<ide>
<del>import hasOwnProp from "../utils/has-own-prop";
<add>import hasOwnProp from '../utils/has-own-prop';
<ide>
<ide> var regexes = {};
<ide>
<ide> export function addRegexToken (token, regex, strictRegex) {
<del> regexes[token] = typeof regex === "function" ? regex : function (isStrict) {
<add> regexes[token] = typeof regex === 'function' ? regex : function (isStrict) {
<ide> return (isStrict && strictRegex) ? strictRegex : regex;
<ide> };
<ide> }
<ide><path>src/lib/parse/token.js
<del>import hasOwnProp from "../utils/has-own-prop";
<del>import toInt from "../utils/to-int";
<add>import hasOwnProp from '../utils/has-own-prop';
<add>import toInt from '../utils/to-int';
<ide>
<ide> var tokens = {};
<ide>
<ide> export function addParseToken (token, callback) {
<ide> var i, func = callback;
<del> if (typeof token === "string") {
<add> if (typeof token === 'string') {
<ide> token = [token];
<ide> }
<del> if (typeof callback === "number") {
<add> if (typeof callback === 'number') {
<ide> func = function (input, array) {
<ide> array[callback] = toInt(input);
<ide> };
<ide><path>src/lib/units/aliases.js
<del>import hasOwnProp from "../utils/has-own-prop";
<add>import hasOwnProp from '../utils/has-own-prop';
<ide>
<ide> var aliases = {};
<ide>
<ide> export function addUnitAlias (unit, shorthand) {
<ide> }
<ide>
<ide> export function normalizeUnits(units) {
<del> return typeof units === "string" ? aliases[units] || aliases[units.toLowerCase()] : undefined;
<add> return typeof units === 'string' ? aliases[units] || aliases[units.toLowerCase()] : undefined;
<ide> }
<ide>
<ide> export function normalizeObjectUnits(inputObject) {
<ide><path>src/lib/units/day-of-month.js
<del>import { makeGetSet } from "../moment/get-set";
<del>import { addFormatToken } from "../format/format";
<del>import { addUnitAlias } from "./aliases";
<del>import { addRegexToken, match1to2, match2 } from "../parse/regex";
<del>import { addParseToken } from "../parse/token";
<del>import { DATE } from "./constants";
<del>import toInt from "../utils/to-int";
<add>import { makeGetSet } from '../moment/get-set';
<add>import { addFormatToken } from '../format/format';
<add>import { addUnitAlias } from './aliases';
<add>import { addRegexToken, match1to2, match2 } from '../parse/regex';
<add>import { addParseToken } from '../parse/token';
<add>import { DATE } from './constants';
<add>import toInt from '../utils/to-int';
<ide>
<ide> // FORMATTING
<ide>
<del>addFormatToken("D", ["DD", 2], "Do", "date");
<add>addFormatToken('D', ['DD', 2], 'Do', 'date');
<ide>
<ide> // ALIASES
<ide>
<del>addUnitAlias("date", "D");
<add>addUnitAlias('date', 'D');
<ide>
<ide> // PARSING
<ide>
<del>addRegexToken("D", match1to2);
<del>addRegexToken("DD", match1to2, match2);
<del>addRegexToken("Do", function (isStrict, locale) {
<add>addRegexToken('D', match1to2);
<add>addRegexToken('DD', match1to2, match2);
<add>addRegexToken('Do', function (isStrict, locale) {
<ide> return isStrict ? locale._ordinalParse : locale._ordinalParseLenient;
<ide> });
<ide>
<del>addParseToken(["D", "DD"], DATE);
<del>addParseToken("Do", function (input, array) {
<add>addParseToken(['D', 'DD'], DATE);
<add>addParseToken('Do', function (input, array) {
<ide> array[DATE] = toInt(input.match(match1to2)[0], 10);
<ide> });
<ide>
<ide><path>src/lib/units/day-of-week.js
<del>import { addFormatToken } from "../format/format";
<del>import { addUnitAlias } from "./aliases";
<del>import { addRegexToken, match1to2, matchWord } from "../parse/regex";
<del>import { addWeekParseToken } from "../parse/token";
<del>import toInt from "../utils/to-int";
<del>import { createLocal } from "../create/local";
<add>import { addFormatToken } from '../format/format';
<add>import { addUnitAlias } from './aliases';
<add>import { addRegexToken, match1to2, matchWord } from '../parse/regex';
<add>import { addWeekParseToken } from '../parse/token';
<add>import toInt from '../utils/to-int';
<add>import { createLocal } from '../create/local';
<ide>
<ide> // FORMATTING
<ide>
<del>addFormatToken("d", 0, "do", "day");
<add>addFormatToken('d', 0, 'do', 'day');
<ide>
<del>addFormatToken("dd", 0, 0, function (format) {
<add>addFormatToken('dd', 0, 0, function (format) {
<ide> return this.localeData().weekdaysMin(this, format);
<ide> });
<ide>
<del>addFormatToken("ddd", 0, 0, function (format) {
<add>addFormatToken('ddd', 0, 0, function (format) {
<ide> return this.localeData().weekdaysShort(this, format);
<ide> });
<ide>
<del>addFormatToken("dddd", 0, 0, function (format) {
<add>addFormatToken('dddd', 0, 0, function (format) {
<ide> return this.localeData().weekdays(this, format);
<ide> });
<ide>
<del>addFormatToken("e", 0, 0, "weekday");
<del>addFormatToken("E", 0, 0, "isoWeekday");
<add>addFormatToken('e', 0, 0, 'weekday');
<add>addFormatToken('E', 0, 0, 'isoWeekday');
<ide>
<ide> // ALIASES
<ide>
<del>addUnitAlias("day", "d");
<del>addUnitAlias("weekday", "e");
<del>addUnitAlias("isoWeekday", "E");
<add>addUnitAlias('day', 'd');
<add>addUnitAlias('weekday', 'e');
<add>addUnitAlias('isoWeekday', 'E');
<ide>
<ide> // PARSING
<ide>
<del>addRegexToken("d", match1to2);
<del>addRegexToken("e", match1to2);
<del>addRegexToken("E", match1to2);
<del>addRegexToken("dd", matchWord);
<del>addRegexToken("ddd", matchWord);
<del>addRegexToken("dddd", matchWord);
<add>addRegexToken('d', match1to2);
<add>addRegexToken('e', match1to2);
<add>addRegexToken('E', match1to2);
<add>addRegexToken('dd', matchWord);
<add>addRegexToken('ddd', matchWord);
<add>addRegexToken('dddd', matchWord);
<ide>
<del>addWeekParseToken(["dd", "ddd", "dddd"], function (input, week, config) {
<add>addWeekParseToken(['dd', 'ddd', 'dddd'], function (input, week, config) {
<ide> var weekday = config._locale.weekdaysParse(input);
<ide> // if we didn't get a weekday name, mark the date as invalid
<ide> if (weekday != null) {
<ide> addWeekParseToken(["dd", "ddd", "dddd"], function (input, week, config) {
<ide> }
<ide> });
<ide>
<del>addWeekParseToken(["d", "e", "E"], function (input, week, config, token) {
<add>addWeekParseToken(['d', 'e', 'E'], function (input, week, config, token) {
<ide> week[token] = toInt(input);
<ide> });
<ide>
<ide><path>src/lib/units/day-of-year.js
<del>import { addFormatToken } from "../format/format";
<del>import { addUnitAlias } from "./aliases";
<del>import { addRegexToken, match3, match1to3 } from "../parse/regex";
<del>import { daysInYear } from "./year";
<del>import { createUTCDate } from "../create/date-from-array";
<del>import { addParseToken } from "../parse/token";
<del>import toInt from "../utils/to-int";
<add>import { addFormatToken } from '../format/format';
<add>import { addUnitAlias } from './aliases';
<add>import { addRegexToken, match3, match1to3 } from '../parse/regex';
<add>import { daysInYear } from './year';
<add>import { createUTCDate } from '../create/date-from-array';
<add>import { addParseToken } from '../parse/token';
<add>import toInt from '../utils/to-int';
<ide>
<ide> // FORMATTING
<ide>
<del>addFormatToken("DDD", ["DDDD", 3], "DDDo", "dayOfYear");
<add>addFormatToken('DDD', ['DDDD', 3], 'DDDo', 'dayOfYear');
<ide>
<ide> // ALIASES
<ide>
<del>addUnitAlias("dayOfYear", "DDD");
<add>addUnitAlias('dayOfYear', 'DDD');
<ide>
<ide> // PARSING
<ide>
<del>addRegexToken("DDD", match1to3);
<del>addRegexToken("DDDD", match3);
<del>addParseToken(["DDD", "DDDD"], function (input, array, config) {
<add>addRegexToken('DDD', match1to3);
<add>addRegexToken('DDDD', match3);
<add>addParseToken(['DDD', 'DDDD'], function (input, array, config) {
<ide> config._dayOfYear = toInt(input);
<ide> });
<ide>
<ide><path>src/lib/units/hour.js
<del>import { makeGetSet } from "../moment/get-set";
<del>import { addFormatToken } from "../format/format";
<del>import { addUnitAlias } from "./aliases";
<del>import { addRegexToken, match1to2, match2 } from "../parse/regex";
<del>import { addParseToken } from "../parse/token";
<del>import { HOUR } from "./constants";
<del>import toInt from "../utils/to-int";
<add>import { makeGetSet } from '../moment/get-set';
<add>import { addFormatToken } from '../format/format';
<add>import { addUnitAlias } from './aliases';
<add>import { addRegexToken, match1to2, match2 } from '../parse/regex';
<add>import { addParseToken } from '../parse/token';
<add>import { HOUR } from './constants';
<add>import toInt from '../utils/to-int';
<ide>
<ide> // FORMATTING
<ide>
<del>addFormatToken("H", ["HH", 2], 0, "hour");
<del>addFormatToken("h", ["hh", 2], 0, function () {
<add>addFormatToken('H', ['HH', 2], 0, 'hour');
<add>addFormatToken('h', ['hh', 2], 0, function () {
<ide> return this.hours() % 12 || 12;
<ide> });
<ide>
<ide> meridiem('A', false);
<ide>
<ide> // ALIASES
<ide>
<del>addUnitAlias("hour", "h");
<add>addUnitAlias('hour', 'h');
<ide>
<ide> // PARSING
<ide>
<ide> function matchMeridiem (isStrict, locale) {
<ide> return locale._meridiemParse;
<ide> }
<ide>
<del>addRegexToken("a", matchMeridiem);
<del>addRegexToken("A", matchMeridiem);
<del>addRegexToken("H", match1to2);
<del>addRegexToken("h", match1to2);
<del>addRegexToken("HH", match1to2, match2);
<del>addRegexToken("hh", match1to2, match2);
<add>addRegexToken('a', matchMeridiem);
<add>addRegexToken('A', matchMeridiem);
<add>addRegexToken('H', match1to2);
<add>addRegexToken('h', match1to2);
<add>addRegexToken('HH', match1to2, match2);
<add>addRegexToken('hh', match1to2, match2);
<ide>
<del>addParseToken(["H", "HH"], HOUR);
<del>addParseToken(["a", "A"], function (input, array, config) {
<add>addParseToken(['H', 'HH'], HOUR);
<add>addParseToken(['a', 'A'], function (input, array, config) {
<ide> config._isPm = config._locale.isPM(input);
<ide> config._meridiem = input;
<ide> });
<del>addParseToken(["h", "hh"], function (input, array, config) {
<add>addParseToken(['h', 'hh'], function (input, array, config) {
<ide> array[HOUR] = toInt(input);
<ide> config._pf.bigHour = true;
<ide> });
<ide><path>src/lib/units/millisecond.js
<del>import { makeGetSet } from "../moment/get-set";
<del>import { addFormatToken } from "../format/format";
<del>import { addUnitAlias } from "./aliases";
<del>import { addRegexToken, match1, match2, match3, match1to3, matchUnsigned } from "../parse/regex";
<del>import { addParseToken } from "../parse/token";
<del>import { MILLISECOND } from "./constants";
<del>import toInt from "../utils/to-int";
<add>import { makeGetSet } from '../moment/get-set';
<add>import { addFormatToken } from '../format/format';
<add>import { addUnitAlias } from './aliases';
<add>import { addRegexToken, match1, match2, match3, match1to3, matchUnsigned } from '../parse/regex';
<add>import { addParseToken } from '../parse/token';
<add>import { MILLISECOND } from './constants';
<add>import toInt from '../utils/to-int';
<ide>
<ide> // FORMATTING
<ide>
<del>addFormatToken("S", 0, 0, function () {
<add>addFormatToken('S', 0, 0, function () {
<ide> return ~~(this.millisecond() / 100);
<ide> });
<ide>
<del>addFormatToken(0, ["SS", 2], 0, function () {
<add>addFormatToken(0, ['SS', 2], 0, function () {
<ide> return ~~(this.millisecond() / 10);
<ide> });
<ide>
<ide> function milliseconds (token) {
<del> addFormatToken(0, [token, 3], 0, "millisecond");
<add> addFormatToken(0, [token, 3], 0, 'millisecond');
<ide> }
<ide>
<del>milliseconds("SSS");
<del>milliseconds("SSSS");
<add>milliseconds('SSS');
<add>milliseconds('SSSS');
<ide>
<ide> // ALIASES
<ide>
<del>addUnitAlias("millisecond", "ms");
<add>addUnitAlias('millisecond', 'ms');
<ide>
<ide> // PARSING
<ide>
<del>addRegexToken("S", match1to3, match1);
<del>addRegexToken("SS", match1to3, match2);
<del>addRegexToken("SSS", match1to3, match3);
<del>addRegexToken("SSSS", matchUnsigned);
<del>addParseToken(["S", "SS", "SSS", "SSSS"], function (input, array) {
<add>addRegexToken('S', match1to3, match1);
<add>addRegexToken('SS', match1to3, match2);
<add>addRegexToken('SSS', match1to3, match3);
<add>addRegexToken('SSSS', matchUnsigned);
<add>addParseToken(['S', 'SS', 'SSS', 'SSSS'], function (input, array) {
<ide> array[MILLISECOND] = toInt(('0.' + input) * 1000);
<ide> });
<ide>
<ide><path>src/lib/units/minute.js
<del>import { makeGetSet } from "../moment/get-set";
<del>import { addFormatToken } from "../format/format";
<del>import { addUnitAlias } from "./aliases";
<del>import { addRegexToken, match1to2, match2 } from "../parse/regex";
<del>import { addParseToken } from "../parse/token";
<del>import { MINUTE } from "./constants";
<add>import { makeGetSet } from '../moment/get-set';
<add>import { addFormatToken } from '../format/format';
<add>import { addUnitAlias } from './aliases';
<add>import { addRegexToken, match1to2, match2 } from '../parse/regex';
<add>import { addParseToken } from '../parse/token';
<add>import { MINUTE } from './constants';
<ide>
<ide> // FORMATTING
<ide>
<del>addFormatToken("m", ["mm", 2], 0, "minute");
<add>addFormatToken('m', ['mm', 2], 0, 'minute');
<ide>
<ide> // ALIASES
<ide>
<del>addUnitAlias("minute", "m");
<add>addUnitAlias('minute', 'm');
<ide>
<ide> // PARSING
<ide>
<del>addRegexToken("m", match1to2);
<del>addRegexToken("mm", match1to2, match2);
<del>addParseToken(["m", "mm"], MINUTE);
<add>addRegexToken('m', match1to2);
<add>addRegexToken('mm', match1to2, match2);
<add>addParseToken(['m', 'mm'], MINUTE);
<ide>
<ide> // MOMENTS
<ide>
<ide><path>src/lib/units/month.js
<del>import { get } from "../moment/get-set";
<del>import { addFormatToken } from "../format/format";
<del>import { addUnitAlias } from "./aliases";
<del>import { addRegexToken, match1to2, match2, matchWord } from "../parse/regex";
<del>import { addParseToken } from "../parse/token";
<del>import { hooks } from "../utils/hooks";
<del>import { MONTH } from "./constants";
<del>import toInt from "../utils/to-int";
<del>import { createUTC } from "../create/utc";
<add>import { get } from '../moment/get-set';
<add>import { addFormatToken } from '../format/format';
<add>import { addUnitAlias } from './aliases';
<add>import { addRegexToken, match1to2, match2, matchWord } from '../parse/regex';
<add>import { addParseToken } from '../parse/token';
<add>import { hooks } from '../utils/hooks';
<add>import { MONTH } from './constants';
<add>import toInt from '../utils/to-int';
<add>import { createUTC } from '../create/utc';
<ide>
<ide> export function daysInMonth(year, month) {
<ide> return new Date(Date.UTC(year, month + 1, 0)).getUTCDate();
<ide> }
<ide>
<ide> // FORMATTING
<ide>
<del>addFormatToken("M", ["MM", 2], "Mo", function () {
<add>addFormatToken('M', ['MM', 2], 'Mo', function () {
<ide> return this.month() + 1;
<ide> });
<ide>
<del>addFormatToken("MMM", 0, 0, function (format) {
<add>addFormatToken('MMM', 0, 0, function (format) {
<ide> return this.localeData().monthsShort(this, format);
<ide> });
<ide>
<del>addFormatToken("MMMM", 0, 0, function (format) {
<add>addFormatToken('MMMM', 0, 0, function (format) {
<ide> return this.localeData().months(this, format);
<ide> });
<ide>
<ide> // ALIASES
<ide>
<del>addUnitAlias("month", "M");
<add>addUnitAlias('month', 'M');
<ide>
<ide> // PARSING
<ide>
<del>addRegexToken("M", match1to2);
<del>addRegexToken("MM", match1to2, match2);
<del>addRegexToken("MMM", matchWord);
<del>addRegexToken("MMMM", matchWord);
<add>addRegexToken('M', match1to2);
<add>addRegexToken('MM', match1to2, match2);
<add>addRegexToken('MMM', matchWord);
<add>addRegexToken('MMMM', matchWord);
<ide>
<del>addParseToken(["M", "MM"], function (input, array) {
<add>addParseToken(['M', 'MM'], function (input, array) {
<ide> array[MONTH] = toInt(input) - 1;
<ide> });
<ide>
<del>addParseToken(["MMM", "MMMM"], function (input, array, config, token) {
<add>addParseToken(['MMM', 'MMMM'], function (input, array, config, token) {
<ide> var month = config._locale.monthsParse(input, token, config._strict);
<ide> // if we didn't find a month name, mark the date as invalid.
<ide> if (month != null) {
<ide> export function getSetMonth (value) {
<ide> hooks.updateOffset(this, true);
<ide> return this;
<ide> } else {
<del> return get(this, "Month");
<add> return get(this, 'Month');
<ide> }
<ide> }
<ide>
<ide><path>src/lib/units/offset.js
<del>import zeroFill from "../utils/zero-fill";
<del>import { createDuration } from "../duration/create";
<del>import { addSubtract } from "../moment/add-subtract";
<del>import { isMoment } from "../moment/constructor";
<del>import { addFormatToken } from "../format/format";
<del>import { addRegexToken, matchOffset } from "../parse/regex";
<del>import { addParseToken } from "../parse/token";
<del>import { createLocal } from "../create/local";
<del>import { createUTC } from "../create/utc";
<del>import isDate from "../utils/is-date";
<del>import toInt from "../utils/to-int";
<del>import compareArrays from "../utils/compare-arrays";
<del>import { hooks } from "../utils/hooks";
<add>import zeroFill from '../utils/zero-fill';
<add>import { createDuration } from '../duration/create';
<add>import { addSubtract } from '../moment/add-subtract';
<add>import { isMoment } from '../moment/constructor';
<add>import { addFormatToken } from '../format/format';
<add>import { addRegexToken, matchOffset } from '../parse/regex';
<add>import { addParseToken } from '../parse/token';
<add>import { createLocal } from '../create/local';
<add>import { createUTC } from '../create/utc';
<add>import isDate from '../utils/is-date';
<add>import toInt from '../utils/to-int';
<add>import compareArrays from '../utils/compare-arrays';
<add>import { hooks } from '../utils/hooks';
<ide>
<ide> // FORMATTING
<ide>
<ide> function offset (token, separator) {
<ide> });
<ide> }
<ide>
<del>offset("Z", ":");
<del>offset("ZZ", "");
<add>offset('Z', ':');
<add>offset('ZZ', '');
<ide>
<ide> // PARSING
<ide>
<del>addRegexToken("Z", matchOffset);
<del>addRegexToken("ZZ", matchOffset);
<del>addParseToken(["Z", "ZZ"], function (input, array, config) {
<add>addRegexToken('Z', matchOffset);
<add>addRegexToken('ZZ', matchOffset);
<add>addParseToken(['Z', 'ZZ'], function (input, array, config) {
<ide> config._useUTC = true;
<ide> config._tzm = offsetFromString(input);
<ide> });
<ide> addParseToken(["Z", "ZZ"], function (input, array, config) {
<ide> var chunkOffset = /([\+\-]|\d\d)/gi;
<ide>
<ide> function offsetFromString(string) {
<del> var matches = ((string || "").match(matchOffset) || []);
<add> var matches = ((string || '').match(matchOffset) || []);
<ide> var chunk = matches[matches.length - 1] || [];
<ide> var parts = (chunk + '').match(chunkOffset) || ['-', 0, 0];
<ide> var minutes = +(parts[1] * 60) + toInt(parts[2]);
<ide><path>src/lib/units/quarter.js
<del>import { addFormatToken } from "../format/format";
<del>import { addUnitAlias } from "./aliases";
<del>import { addRegexToken, match1 } from "../parse/regex";
<del>import { addParseToken } from "../parse/token";
<del>import { MONTH } from "./constants";
<del>import toInt from "../utils/to-int";
<add>import { addFormatToken } from '../format/format';
<add>import { addUnitAlias } from './aliases';
<add>import { addRegexToken, match1 } from '../parse/regex';
<add>import { addParseToken } from '../parse/token';
<add>import { MONTH } from './constants';
<add>import toInt from '../utils/to-int';
<ide>
<ide> // FORMATTING
<ide>
<del>addFormatToken("Q", 0, 0, "quarter");
<add>addFormatToken('Q', 0, 0, 'quarter');
<ide>
<ide> // ALIASES
<ide>
<del>addUnitAlias("quarter", "Q");
<add>addUnitAlias('quarter', 'Q');
<ide>
<ide> // PARSING
<ide>
<del>addRegexToken("Q", match1);
<del>addParseToken("Q", function (input, array) {
<add>addRegexToken('Q', match1);
<add>addParseToken('Q', function (input, array) {
<ide> array[MONTH] = (toInt(input) - 1) * 3;
<ide> });
<ide>
<ide><path>src/lib/units/second.js
<del>import { makeGetSet } from "../moment/get-set";
<del>import { addFormatToken } from "../format/format";
<del>import { addUnitAlias } from "./aliases";
<del>import { addRegexToken, match1to2, match2 } from "../parse/regex";
<del>import { addParseToken } from "../parse/token";
<del>import { SECOND } from "./constants";
<add>import { makeGetSet } from '../moment/get-set';
<add>import { addFormatToken } from '../format/format';
<add>import { addUnitAlias } from './aliases';
<add>import { addRegexToken, match1to2, match2 } from '../parse/regex';
<add>import { addParseToken } from '../parse/token';
<add>import { SECOND } from './constants';
<ide>
<ide> // FORMATTING
<ide>
<del>addFormatToken("s", ["ss", 2], 0, "second");
<add>addFormatToken('s', ['ss', 2], 0, 'second');
<ide>
<ide> // ALIASES
<ide>
<del>addUnitAlias("second", "s");
<add>addUnitAlias('second', 's');
<ide>
<ide> // PARSING
<ide>
<del>addRegexToken("s", match1to2);
<del>addRegexToken("ss", match1to2, match2);
<del>addParseToken(["s", "ss"], SECOND);
<add>addRegexToken('s', match1to2);
<add>addRegexToken('ss', match1to2, match2);
<add>addParseToken(['s', 'ss'], SECOND);
<ide>
<ide> // MOMENTS
<ide>
<ide><path>src/lib/units/timestamp.js
<del>import { addFormatToken } from "../format/format";
<del>import { addRegexToken, matchTimestamp, matchSigned } from "../parse/regex";
<del>import { addParseToken } from "../parse/token";
<del>import toInt from "../utils/to-int";
<add>import { addFormatToken } from '../format/format';
<add>import { addRegexToken, matchTimestamp, matchSigned } from '../parse/regex';
<add>import { addParseToken } from '../parse/token';
<add>import toInt from '../utils/to-int';
<ide>
<ide> // FORMATTING
<ide>
<del>addFormatToken("X", 0, 0, "unix");
<del>addFormatToken("x", 0, 0, "valueOf");
<add>addFormatToken('X', 0, 0, 'unix');
<add>addFormatToken('x', 0, 0, 'valueOf');
<ide>
<ide> // PARSING
<ide>
<del>addRegexToken("x", matchSigned);
<del>addRegexToken("X", matchTimestamp);
<del>addParseToken("X", function (input, array, config) {
<add>addRegexToken('x', matchSigned);
<add>addRegexToken('X', matchTimestamp);
<add>addParseToken('X', function (input, array, config) {
<ide> config._d = new Date(parseFloat(input, 10) * 1000);
<ide> });
<del>addParseToken("x", function (input, array, config) {
<add>addParseToken('x', function (input, array, config) {
<ide> config._d = new Date(toInt(input));
<ide> });
<ide><path>src/lib/units/timezone.js
<del>import { addFormatToken } from "../format/format";
<add>import { addFormatToken } from '../format/format';
<ide>
<ide> // FORMATTING
<ide>
<del>addFormatToken("z", 0, 0, "zoneAbbr");
<del>addFormatToken("zz", 0, 0, "zoneName");
<add>addFormatToken('z', 0, 0, 'zoneAbbr');
<add>addFormatToken('zz', 0, 0, 'zoneName');
<ide>
<ide> // MOMENTS
<ide>
<ide><path>src/lib/units/units.js
<ide> // Side effect imports
<del>import "./day-of-month";
<del>import "./day-of-week";
<del>import "./day-of-year";
<del>import "./hour";
<del>import "./millisecond";
<del>import "./minute";
<del>import "./month";
<del>import "./offset";
<del>import "./quarter";
<del>import "./second";
<del>import "./timestamp";
<del>import "./timezone";
<del>import "./week-year";
<del>import "./week";
<del>import "./year";
<add>import './day-of-month';
<add>import './day-of-week';
<add>import './day-of-year';
<add>import './hour';
<add>import './millisecond';
<add>import './minute';
<add>import './month';
<add>import './offset';
<add>import './quarter';
<add>import './second';
<add>import './timestamp';
<add>import './timezone';
<add>import './week-year';
<add>import './week';
<add>import './year';
<ide>
<del>import { normalizeUnits } from "./aliases";
<add>import { normalizeUnits } from './aliases';
<ide>
<ide> export { normalizeUnits };
<ide><path>src/lib/units/week-year.js
<del>import { addFormatToken } from "../format/format";
<del>import { addUnitAlias } from "./aliases";
<del>import { addRegexToken, match1to2, match1to4, match1to6, match2, match4, match6, matchSigned } from "../parse/regex";
<del>import { addWeekParseToken } from "../parse/token";
<del>import { weekOfYear } from "./week";
<del>import toInt from "../utils/to-int";
<del>import { hooks } from "../utils/hooks";
<del>import { createLocal } from "../create/local";
<add>import { addFormatToken } from '../format/format';
<add>import { addUnitAlias } from './aliases';
<add>import { addRegexToken, match1to2, match1to4, match1to6, match2, match4, match6, matchSigned } from '../parse/regex';
<add>import { addWeekParseToken } from '../parse/token';
<add>import { weekOfYear } from './week';
<add>import toInt from '../utils/to-int';
<add>import { hooks } from '../utils/hooks';
<add>import { createLocal } from '../create/local';
<ide>
<ide> // FORMATTING
<ide>
<del>addFormatToken(0, ["gg", 2], 0, function () {
<add>addFormatToken(0, ['gg', 2], 0, function () {
<ide> return this.weekYear() % 100;
<ide> });
<ide>
<del>addFormatToken(0, ["GG", 2], 0, function () {
<add>addFormatToken(0, ['GG', 2], 0, function () {
<ide> return this.isoWeekYear() % 100;
<ide> });
<ide>
<ide> function addWeekYearFormatToken (token, getter) {
<ide> addFormatToken(0, [token, token.length], 0, getter);
<ide> }
<ide>
<del>addWeekYearFormatToken("gggg", "weekYear");
<del>addWeekYearFormatToken("ggggg", "weekYear");
<del>addWeekYearFormatToken("GGGG", "isoWeekYear");
<del>addWeekYearFormatToken("GGGGG", "isoWeekYear");
<add>addWeekYearFormatToken('gggg', 'weekYear');
<add>addWeekYearFormatToken('ggggg', 'weekYear');
<add>addWeekYearFormatToken('GGGG', 'isoWeekYear');
<add>addWeekYearFormatToken('GGGGG', 'isoWeekYear');
<ide>
<ide> // ALIASES
<ide>
<del>addUnitAlias("weekYear", "gg");
<del>addUnitAlias("isoWeekYear", "GG");
<add>addUnitAlias('weekYear', 'gg');
<add>addUnitAlias('isoWeekYear', 'GG');
<ide>
<ide> // PARSING
<ide>
<del>addRegexToken("G", matchSigned);
<del>addRegexToken("g", matchSigned);
<del>addRegexToken("GG", match1to2, match2);
<del>addRegexToken("gg", match1to2, match2);
<del>addRegexToken("GGGG", match1to4, match4);
<del>addRegexToken("gggg", match1to4, match4);
<del>addRegexToken("GGGGG", match1to6, match6);
<del>addRegexToken("ggggg", match1to6, match6);
<add>addRegexToken('G', matchSigned);
<add>addRegexToken('g', matchSigned);
<add>addRegexToken('GG', match1to2, match2);
<add>addRegexToken('gg', match1to2, match2);
<add>addRegexToken('GGGG', match1to4, match4);
<add>addRegexToken('gggg', match1to4, match4);
<add>addRegexToken('GGGGG', match1to6, match6);
<add>addRegexToken('ggggg', match1to6, match6);
<ide>
<del>addWeekParseToken(["gggg", "ggggg", "GGGG", "GGGGG"], function (input, week, config, token) {
<add>addWeekParseToken(['gggg', 'ggggg', 'GGGG', 'GGGGG'], function (input, week, config, token) {
<ide> week[token.substr(0, 2)] = toInt(input);
<ide> });
<ide>
<del>addWeekParseToken(["gg", "GG"], function (input, week, config, token) {
<add>addWeekParseToken(['gg', 'GG'], function (input, week, config, token) {
<ide> week[token] = hooks.parseTwoDigitYear(input);
<ide> });
<ide>
<ide><path>src/lib/units/week.js
<del>import { addFormatToken } from "../format/format";
<del>import { addUnitAlias } from "./aliases";
<del>import { addRegexToken, match1to2, match2 } from "../parse/regex";
<del>import { addWeekParseToken } from "../parse/token";
<del>import toInt from "../utils/to-int";
<del>import { createLocal } from "../create/local";
<add>import { addFormatToken } from '../format/format';
<add>import { addUnitAlias } from './aliases';
<add>import { addRegexToken, match1to2, match2 } from '../parse/regex';
<add>import { addWeekParseToken } from '../parse/token';
<add>import toInt from '../utils/to-int';
<add>import { createLocal } from '../create/local';
<ide>
<ide> // FORMATTING
<ide>
<del>addFormatToken("w", ["ww", 2], "wo", "week");
<del>addFormatToken("W", ["WW", 2], "Wo", "isoWeek");
<add>addFormatToken('w', ['ww', 2], 'wo', 'week');
<add>addFormatToken('W', ['WW', 2], 'Wo', 'isoWeek');
<ide>
<ide> // ALIASES
<ide>
<del>addUnitAlias("week", "w");
<del>addUnitAlias("isoWeek", "W");
<add>addUnitAlias('week', 'w');
<add>addUnitAlias('isoWeek', 'W');
<ide>
<ide> // PARSING
<ide>
<del>addRegexToken("w", match1to2);
<del>addRegexToken("ww", match1to2, match2);
<del>addRegexToken("W", match1to2);
<del>addRegexToken("WW", match1to2, match2);
<add>addRegexToken('w', match1to2);
<add>addRegexToken('ww', match1to2, match2);
<add>addRegexToken('W', match1to2);
<add>addRegexToken('WW', match1to2, match2);
<ide>
<del>addWeekParseToken(["w", "ww", "W", "WW"], function (input, week, config, token) {
<add>addWeekParseToken(['w', 'ww', 'W', 'WW'], function (input, week, config, token) {
<ide> week[token.substr(0, 1)] = toInt(input);
<ide> });
<ide>
<ide><path>src/lib/units/year.js
<del>import { makeGetSet } from "../moment/get-set";
<del>import { addFormatToken } from "../format/format";
<del>import { addUnitAlias } from "./aliases";
<del>import { addRegexToken, match1to2, match1to4, match1to6, match2, match4, match6, matchSigned } from "../parse/regex";
<del>import { addParseToken } from "../parse/token";
<del>import { hooks } from "../utils/hooks";
<del>import { YEAR } from "./constants";
<del>import toInt from "../utils/to-int";
<add>import { makeGetSet } from '../moment/get-set';
<add>import { addFormatToken } from '../format/format';
<add>import { addUnitAlias } from './aliases';
<add>import { addRegexToken, match1to2, match1to4, match1to6, match2, match4, match6, matchSigned } from '../parse/regex';
<add>import { addParseToken } from '../parse/token';
<add>import { hooks } from '../utils/hooks';
<add>import { YEAR } from './constants';
<add>import toInt from '../utils/to-int';
<ide>
<ide> // FORMATTING
<ide>
<del>addFormatToken(0, ["YY", 2], 0, function () {
<add>addFormatToken(0, ['YY', 2], 0, function () {
<ide> return this.year() % 100;
<ide> });
<ide>
<del>addFormatToken(0, ["YYYY", 4], 0, "year");
<del>addFormatToken(0, ["YYYYY", 5], 0, "year");
<del>addFormatToken(0, ["YYYYYY", 6, true], 0, "year");
<add>addFormatToken(0, ['YYYY', 4], 0, 'year');
<add>addFormatToken(0, ['YYYYY', 5], 0, 'year');
<add>addFormatToken(0, ['YYYYYY', 6, true], 0, 'year');
<ide>
<ide> // ALIASES
<ide>
<del>addUnitAlias("year", "y");
<add>addUnitAlias('year', 'y');
<ide>
<ide> // PARSING
<ide>
<del>addRegexToken("Y", matchSigned);
<del>addRegexToken("YY", match1to2, match2);
<del>addRegexToken("YYYY", match1to4, match4);
<del>addRegexToken("YYYYY", match1to6, match6);
<del>addRegexToken("YYYYYY", match1to6, match6);
<add>addRegexToken('Y', matchSigned);
<add>addRegexToken('YY', match1to2, match2);
<add>addRegexToken('YYYY', match1to4, match4);
<add>addRegexToken('YYYYY', match1to6, match6);
<add>addRegexToken('YYYYYY', match1to6, match6);
<ide>
<del>addParseToken(["YYYY", "YYYYY", "YYYYYY"], YEAR);
<del>addParseToken("YY", function (input, array) {
<add>addParseToken(['YYYY', 'YYYYY', 'YYYYYY'], YEAR);
<add>addParseToken('YY', function (input, array) {
<ide> array[YEAR] = hooks.parseTwoDigitYear(input);
<ide> });
<ide>
<ide><path>src/lib/utils/compare-arrays.js
<del>import toInt from "./to-int";
<add>import toInt from './to-int';
<ide>
<ide> // compare two arrays, return the number of differences
<ide> export default function compareArrays(array1, array2, dontConvert) {
<ide><path>src/lib/utils/deprecate.js
<del>import extend from "./extend";
<del>import { hooks } from "./hooks";
<add>import extend from './extend';
<add>import { hooks } from './hooks';
<ide>
<ide> function warn(msg) {
<ide> if (hooks.suppressDeprecationWarnings === false && typeof console !== 'undefined' && console.warn) {
<ide><path>src/lib/utils/extend.js
<del>import hasOwnProp from "./has-own-prop";
<add>import hasOwnProp from './has-own-prop';
<ide>
<ide> export default function extend(a, b) {
<ide> for (var i in b) {
<ide><path>src/locale/af.js
<ide> //! locale : afrikaans (af)
<ide> //! author : Werner Mollentze : https://github.com/wernerm
<ide>
<del>import moment from "../moment";
<add>import moment from '../moment';
<ide>
<ide> export default moment.defineLocale('af', {
<ide> months : 'Januarie_Februarie_Maart_April_Mei_Junie_Julie_Augustus_September_Oktober_November_Desember'.split('_'),
<ide><path>src/locale/ar-ma.js
<ide> //! author : ElFadili Yassine : https://github.com/ElFadiliY
<ide> //! author : Abdel Said : https://github.com/abdelsaid
<ide>
<del>import moment from "../moment";
<add>import moment from '../moment';
<ide>
<ide> export default moment.defineLocale('ar-ma', {
<ide> months : 'يناير_فبراير_مارس_أبريل_ماي_يونيو_يوليوز_غشت_شتنبر_أكتوبر_نونبر_دجنبر'.split('_'),
<ide><path>src/locale/ar-sa.js
<ide> //! locale : Arabic Saudi Arabia (ar-sa)
<ide> //! author : Suhail Alkowaileet : https://github.com/xsoh
<ide>
<del>import moment from "../moment";
<add>import moment from '../moment';
<ide>
<ide> var symbolMap = {
<ide> '1': '١',
<ide><path>src/locale/ar-tn.js
<ide> //! moment.js locale configuration
<ide> //! locale : Tunisian Arabic (ar-tn)
<ide>
<del>import moment from "../moment";
<add>import moment from '../moment';
<ide>
<ide> export default moment.defineLocale('ar-tn', {
<ide> months: 'جانفي_فيفري_مارس_أفريل_ماي_جوان_جويلية_أوت_سبتمبر_أكتوبر_نوفمبر_ديسمبر'.split('_'),
<ide><path>src/locale/ar.js
<ide> //! Changes in months, weekdays: Ahmed Elkhatib
<ide> //! Native plural forms: forabi https://github.com/forabi
<ide>
<del>import moment from "../moment";
<add>import moment from '../moment';
<ide>
<ide> var symbolMap = {
<ide> '1': '١',
<ide><path>src/locale/az.js
<ide> //! locale : azerbaijani (az)
<ide> //! author : topchiyev : https://github.com/topchiyev
<ide>
<del>import moment from "../moment";
<add>import moment from '../moment';
<ide>
<ide> var suffixes = {
<ide> 1: '-inci',
<ide><path>src/locale/be.js
<ide> //! author: Praleska: http://praleska.pro/
<ide> //! Author : Menelion Elensúle : https://github.com/Oire
<ide>
<del>import moment from "../moment";
<add>import moment from '../moment';
<ide>
<ide> function plural(word, num) {
<ide> var forms = word.split('_');
<ide><path>src/locale/bg.js
<ide> //! locale : bulgarian (bg)
<ide> //! author : Krasen Borisov : https://github.com/kraz
<ide>
<del>import moment from "../moment";
<add>import moment from '../moment';
<ide>
<ide> export default moment.defineLocale('bg', {
<ide> months : 'януари_февруари_март_април_май_юни_юли_август_септември_октомври_ноември_декември'.split('_'),
<ide><path>src/locale/bn.js
<ide> //! locale : Bengali (bn)
<ide> //! author : Kaushik Gandhi : https://github.com/kaushikgandhi
<ide>
<del>import moment from "../moment";
<add>import moment from '../moment';
<ide>
<ide> var symbolMap = {
<ide> '1': '১',
<ide><path>src/locale/bo.js
<ide> //! locale : tibetan (bo)
<ide> //! author : Thupten N. Chakrishar : https://github.com/vajradog
<ide>
<del>import moment from "../moment";
<add>import moment from '../moment';
<ide>
<ide> var symbolMap = {
<ide> '1': '༡',
<ide><path>src/locale/br.js
<ide> //! locale : breton (br)
<ide> //! author : Jean-Baptiste Le Duigou : https://github.com/jbleduigou
<ide>
<del>import moment from "../moment";
<add>import moment from '../moment';
<ide>
<ide> function relativeTimeWithMutation(number, withoutSuffix, key) {
<ide> var format = {
<ide><path>src/locale/bs.js
<ide> //! author : Nedim Cholich : https://github.com/frontyard
<ide> //! based on (hr) translation by Bojan Marković
<ide>
<del>import moment from "../moment";
<add>import moment from '../moment';
<ide>
<ide> function translate(number, withoutSuffix, key) {
<ide> var result = number + ' ';
<ide><path>src/locale/ca.js
<ide> //! locale : catalan (ca)
<ide> //! author : Juan G. Hurtado : https://github.com/juanghurtado
<ide>
<del>import moment from "../moment";
<add>import moment from '../moment';
<ide>
<ide> export default moment.defineLocale('ca', {
<ide> months : 'gener_febrer_març_abril_maig_juny_juliol_agost_setembre_octubre_novembre_desembre'.split('_'),
<ide><path>src/locale/cs.js
<ide> //! locale : czech (cs)
<ide> //! author : petrbela : https://github.com/petrbela
<ide>
<del>import moment from "../moment";
<add>import moment from '../moment';
<ide>
<ide> var months = 'leden_únor_březen_duben_květen_červen_červenec_srpen_září_říjen_listopad_prosinec'.split('_'),
<ide> monthsShort = 'led_úno_bře_dub_kvě_čvn_čvc_srp_zář_říj_lis_pro'.split('_');
<ide><path>src/locale/cv.js
<ide> //! locale : chuvash (cv)
<ide> //! author : Anatoly Mironov : https://github.com/mirontoli
<ide>
<del>import moment from "../moment";
<add>import moment from '../moment';
<ide>
<ide> export default moment.defineLocale('cv', {
<ide> months : 'кăрлач_нарăс_пуш_ака_май_çĕртме_утă_çурла_авăн_юпа_чӳк_раштав'.split('_'),
<ide><path>src/locale/cy.js
<ide> //! locale : Welsh (cy)
<ide> //! author : Robert Allen
<ide>
<del>import moment from "../moment";
<add>import moment from '../moment';
<ide>
<ide> export default moment.defineLocale('cy', {
<ide> months: 'Ionawr_Chwefror_Mawrth_Ebrill_Mai_Mehefin_Gorffennaf_Awst_Medi_Hydref_Tachwedd_Rhagfyr'.split('_'),
<ide><path>src/locale/da.js
<ide> //! locale : danish (da)
<ide> //! author : Ulrik Nielsen : https://github.com/mrbase
<ide>
<del>import moment from "../moment";
<add>import moment from '../moment';
<ide>
<ide> export default moment.defineLocale('da', {
<ide> months : 'januar_februar_marts_april_maj_juni_juli_august_september_oktober_november_december'.split('_'),
<ide><path>src/locale/de-at.js
<ide> //! author: Menelion Elensúle: https://github.com/Oire
<ide> //! author : Martin Groller : https://github.com/MadMG
<ide>
<del>import moment from "../moment";
<add>import moment from '../moment';
<ide>
<ide> function processRelativeTime(number, withoutSuffix, key, isFuture) {
<ide> var format = {
<ide><path>src/locale/de.js
<ide> //! author : lluchs : https://github.com/lluchs
<ide> //! author: Menelion Elensúle: https://github.com/Oire
<ide>
<del>import moment from "../moment";
<add>import moment from '../moment';
<ide>
<ide> function processRelativeTime(number, withoutSuffix, key, isFuture) {
<ide> var format = {
<ide><path>src/locale/el.js
<ide> //! locale : modern greek (el)
<ide> //! author : Aggelos Karalias : https://github.com/mehiel
<ide>
<del>import moment from "../moment";
<add>import moment from '../moment';
<ide>
<ide> export default moment.defineLocale('el', {
<ide> monthsNominativeEl : 'Ιανουάριος_Φεβρουάριος_Μάρτιος_Απρίλιος_Μάιος_Ιούνιος_Ιούλιος_Αύγουστος_Σεπτέμβριος_Οκτώβριος_Νοέμβριος_Δεκέμβριος'.split('_'),
<ide><path>src/locale/en-au.js
<ide> //! moment.js locale configuration
<ide> //! locale : australian english (en-au)
<ide>
<del>import moment from "../moment";
<add>import moment from '../moment';
<ide>
<ide> export default moment.defineLocale('en-au', {
<ide> months : 'January_February_March_April_May_June_July_August_September_October_November_December'.split('_'),
<ide><path>src/locale/en-ca.js
<ide> //! locale : canadian english (en-ca)
<ide> //! author : Jonathan Abourbih : https://github.com/jonbca
<ide>
<del>import moment from "../moment";
<add>import moment from '../moment';
<ide>
<ide> export default moment.defineLocale('en-ca', {
<ide> months : 'January_February_March_April_May_June_July_August_September_October_November_December'.split('_'),
<ide><path>src/locale/en-gb.js
<ide> //! locale : great britain english (en-gb)
<ide> //! author : Chris Gedrim : https://github.com/chrisgedrim
<ide>
<del>import moment from "../moment";
<add>import moment from '../moment';
<ide>
<ide> export default moment.defineLocale('en-gb', {
<ide> months : 'January_February_March_April_May_June_July_August_September_October_November_December'.split('_'),
<ide><path>src/locale/eo.js
<ide> //! komento: Mi estas malcerta se mi korekte traktis akuzativojn en tiu traduko.
<ide> //! Se ne, bonvolu korekti kaj avizi min por ke mi povas lerni!
<ide>
<del>import moment from "../moment";
<add>import moment from '../moment';
<ide>
<ide> export default moment.defineLocale('eo', {
<ide> months : 'januaro_februaro_marto_aprilo_majo_junio_julio_aŭgusto_septembro_oktobro_novembro_decembro'.split('_'),
<ide><path>src/locale/es.js
<ide> //! locale : spanish (es)
<ide> //! author : Julio Napurí : https://github.com/julionc
<ide>
<del>import moment from "../moment";
<add>import moment from '../moment';
<ide>
<ide> var monthsShortDot = 'ene._feb._mar._abr._may._jun._jul._ago._sep._oct._nov._dic.'.split('_'),
<ide> monthsShort = 'ene_feb_mar_abr_may_jun_jul_ago_sep_oct_nov_dic'.split('_');
<ide><path>src/locale/et.js
<ide> //! author : Henry Kehlmann : https://github.com/madhenry
<ide> //! improvements : Illimar Tambek : https://github.com/ragulka
<ide>
<del>import moment from "../moment";
<add>import moment from '../moment';
<ide>
<ide> function processRelativeTime(number, withoutSuffix, key, isFuture) {
<ide> var format = {
<ide><path>src/locale/eu.js
<ide> //! locale : euskara (eu)
<ide> //! author : Eneko Illarramendi : https://github.com/eillarra
<ide>
<del>import moment from "../moment";
<add>import moment from '../moment';
<ide>
<ide> export default moment.defineLocale('eu', {
<ide> months : 'urtarrila_otsaila_martxoa_apirila_maiatza_ekaina_uztaila_abuztua_iraila_urria_azaroa_abendua'.split('_'),
<ide><path>src/locale/fa.js
<ide> //! locale : Persian (fa)
<ide> //! author : Ebrahim Byagowi : https://github.com/ebraminio
<ide>
<del>import moment from "../moment";
<add>import moment from '../moment';
<ide>
<ide> var symbolMap = {
<ide> '1': '۱',
<ide><path>src/locale/fi.js
<ide> //! locale : finnish (fi)
<ide> //! author : Tarmo Aidantausta : https://github.com/bleadof
<ide>
<del>import moment from "../moment";
<add>import moment from '../moment';
<ide>
<ide> var numbersPast = 'nolla yksi kaksi kolme neljä viisi kuusi seitsemän kahdeksan yhdeksän'.split(' '),
<ide> numbersFuture = [
<ide><path>src/locale/fo.js
<ide> //! locale : faroese (fo)
<ide> //! author : Ragnar Johannesen : https://github.com/ragnar123
<ide>
<del>import moment from "../moment";
<add>import moment from '../moment';
<ide>
<ide> export default moment.defineLocale('fo', {
<ide> months : 'januar_februar_mars_apríl_mai_juni_juli_august_september_oktober_november_desember'.split('_'),
<ide><path>src/locale/fr-ca.js
<ide> //! locale : canadian french (fr-ca)
<ide> //! author : Jonathan Abourbih : https://github.com/jonbca
<ide>
<del>import moment from "../moment";
<add>import moment from '../moment';
<ide>
<ide> export default moment.defineLocale('fr-ca', {
<ide> months : 'janvier_février_mars_avril_mai_juin_juillet_août_septembre_octobre_novembre_décembre'.split('_'),
<ide><path>src/locale/fr.js
<ide> //! locale : french (fr)
<ide> //! author : John Fischer : https://github.com/jfroffice
<ide>
<del>import moment from "../moment";
<add>import moment from '../moment';
<ide>
<ide> export default moment.defineLocale('fr', {
<ide> months : 'janvier_février_mars_avril_mai_juin_juillet_août_septembre_octobre_novembre_décembre'.split('_'),
<ide><path>src/locale/fy.js
<ide> //! locale : frisian (fy)
<ide> //! author : Robin van der Vliet : https://github.com/robin0van0der0v
<ide>
<del>import moment from "../moment";
<add>import moment from '../moment';
<ide>
<ide> var monthsShortWithDots = 'jan._feb._mrt._apr._mai_jun._jul._aug._sep._okt._nov._des.'.split('_'),
<ide> monthsShortWithoutDots = 'jan_feb_mrt_apr_mai_jun_jul_aug_sep_okt_nov_des'.split('_');
<ide><path>src/locale/gl.js
<ide> //! locale : galician (gl)
<ide> //! author : Juan G. Hurtado : https://github.com/juanghurtado
<ide>
<del>import moment from "../moment";
<add>import moment from '../moment';
<ide>
<ide> export default moment.defineLocale('gl', {
<ide> months : 'Xaneiro_Febreiro_Marzo_Abril_Maio_Xuño_Xullo_Agosto_Setembro_Outubro_Novembro_Decembro'.split('_'),
<ide><path>src/locale/he.js
<ide> //! author : Moshe Simantov : https://github.com/DevelopmentIL
<ide> //! author : Tal Ater : https://github.com/TalAter
<ide>
<del>import moment from "../moment";
<add>import moment from '../moment';
<ide>
<ide> export default moment.defineLocale('he', {
<ide> months : 'ינואר_פברואר_מרץ_אפריל_מאי_יוני_יולי_אוגוסט_ספטמבר_אוקטובר_נובמבר_דצמבר'.split('_'),
<ide><path>src/locale/hi.js
<ide> //! locale : hindi (hi)
<ide> //! author : Mayank Singhal : https://github.com/mayanksinghal
<ide>
<del>import moment from "../moment";
<add>import moment from '../moment';
<ide>
<ide> var symbolMap = {
<ide> '1': '१',
<ide><path>src/locale/hr.js
<ide> //! locale : hrvatski (hr)
<ide> //! author : Bojan Marković : https://github.com/bmarkovic
<ide>
<del>import moment from "../moment";
<add>import moment from '../moment';
<ide>
<ide> function translate(number, withoutSuffix, key) {
<ide> var result = number + ' ';
<ide><path>src/locale/hu.js
<ide> //! locale : hungarian (hu)
<ide> //! author : Adam Brunner : https://github.com/adambrunner
<ide>
<del>import moment from "../moment";
<add>import moment from '../moment';
<ide>
<ide> var weekEndings = 'vasárnap hétfőn kedden szerdán csütörtökön pénteken szombaton'.split(' ');
<ide> function translate(number, withoutSuffix, key, isFuture) {
<ide><path>src/locale/hy-am.js
<ide> //! locale : Armenian (hy-am)
<ide> //! author : Armendarabyan : https://github.com/armendarabyan
<ide>
<del>import moment from "../moment";
<add>import moment from '../moment';
<ide>
<ide> function monthsCaseReplace(m, format) {
<ide> var months = {
<ide><path>src/locale/id.js
<ide> //! author : Mohammad Satrio Utomo : https://github.com/tyok
<ide> //! reference: http://id.wikisource.org/wiki/Pedoman_Umum_Ejaan_Bahasa_Indonesia_yang_Disempurnakan
<ide>
<del>import moment from "../moment";
<add>import moment from '../moment';
<ide>
<ide> export default moment.defineLocale('id', {
<ide> months : 'Januari_Februari_Maret_April_Mei_Juni_Juli_Agustus_September_Oktober_November_Desember'.split('_'),
<ide><path>src/locale/is.js
<ide> //! locale : icelandic (is)
<ide> //! author : Hinrik Örn Sigurðsson : https://github.com/hinrik
<ide>
<del>import moment from "../moment";
<add>import moment from '../moment';
<ide>
<ide> function plural(n) {
<ide> if (n % 100 === 11) {
<ide><path>src/locale/it.js
<ide> //! author : Lorenzo : https://github.com/aliem
<ide> //! author: Mattia Larentis: https://github.com/nostalgiaz
<ide>
<del>import moment from "../moment";
<add>import moment from '../moment';
<ide>
<ide> export default moment.defineLocale('it', {
<ide> months : 'gennaio_febbraio_marzo_aprile_maggio_giugno_luglio_agosto_settembre_ottobre_novembre_dicembre'.split('_'),
<ide><path>src/locale/ja.js
<ide> //! locale : japanese (ja)
<ide> //! author : LI Long : https://github.com/baryon
<ide>
<del>import moment from "../moment";
<add>import moment from '../moment';
<ide>
<ide> export default moment.defineLocale('ja', {
<ide> months : '1月_2月_3月_4月_5月_6月_7月_8月_9月_10月_11月_12月'.split('_'),
<ide><path>src/locale/ka.js
<ide> //! locale : Georgian (ka)
<ide> //! author : Irakli Janiashvili : https://github.com/irakli-janiashvili
<ide>
<del>import moment from "../moment";
<add>import moment from '../moment';
<ide>
<ide> function monthsCaseReplace(m, format) {
<ide> var months = {
<ide><path>src/locale/km.js
<ide> //! locale : khmer (km)
<ide> //! author : Kruy Vanna : https://github.com/kruyvanna
<ide>
<del>import moment from "../moment";
<add>import moment from '../moment';
<ide>
<ide> export default moment.defineLocale('km', {
<ide> months: 'មករា_កុម្ភៈ_មិនា_មេសា_ឧសភា_មិថុនា_កក្កដា_សីហា_កញ្ញា_តុលា_វិច្ឆិកា_ធ្នូ'.split('_'),
<ide><path>src/locale/ko.js
<ide> //! - Kyungwook, Park : https://github.com/kyungw00k
<ide> //! - Jeeeyul Lee <jeeeyul@gmail.com>
<ide>
<del>import moment from "../moment";
<add>import moment from '../moment';
<ide>
<ide> export default moment.defineLocale('ko', {
<ide> months : '1월_2월_3월_4월_5월_6월_7월_8월_9월_10월_11월_12월'.split('_'),
<ide><path>src/locale/lb.js
<ide> //! locale : Luxembourgish (lb)
<ide> //! author : mweimerskirch : https://github.com/mweimerskirch, David Raison : https://github.com/kwisatz
<ide>
<del>import moment from "../moment";
<add>import moment from '../moment';
<ide>
<ide> function processRelativeTime(number, withoutSuffix, key, isFuture) {
<ide> var format = {
<ide><path>src/locale/lt.js
<ide> //! locale : Lithuanian (lt)
<ide> //! author : Mindaugas Mozūras : https://github.com/mmozuras
<ide>
<del>import moment from "../moment";
<add>import moment from '../moment';
<ide>
<ide> var units = {
<ide> 'm' : 'minutė_minutės_minutę',
<ide><path>src/locale/lv.js
<ide> //! locale : latvian (lv)
<ide> //! author : Kristaps Karlsons : https://github.com/skakri
<ide>
<del>import moment from "../moment";
<add>import moment from '../moment';
<ide>
<ide> var units = {
<ide> 'mm': 'minūti_minūtes_minūte_minūtes',
<ide><path>src/locale/mk.js
<ide> //! locale : macedonian (mk)
<ide> //! author : Borislav Mickov : https://github.com/B0k0
<ide>
<del>import moment from "../moment";
<add>import moment from '../moment';
<ide>
<ide> export default moment.defineLocale('mk', {
<ide> months : 'јануари_февруари_март_април_мај_јуни_јули_август_септември_октомври_ноември_декември'.split('_'),
<ide><path>src/locale/ml.js
<ide> //! locale : malayalam (ml)
<ide> //! author : Floyd Pink : https://github.com/floydpink
<ide>
<del>import moment from "../moment";
<add>import moment from '../moment';
<ide>
<ide> export default moment.defineLocale('ml', {
<ide> months : 'ജനുവരി_ഫെബ്രുവരി_മാർച്ച്_ഏപ്രിൽ_മേയ്_ജൂൺ_ജൂലൈ_ഓഗസ്റ്റ്_സെപ്റ്റംബർ_ഒക്ടോബർ_നവംബർ_ഡിസംബർ'.split('_'),
<ide><path>src/locale/mr.js
<ide> //! locale : Marathi (mr)
<ide> //! author : Harshad Kale : https://github.com/kalehv
<ide>
<del>import moment from "../moment";
<add>import moment from '../moment';
<ide>
<ide> var symbolMap = {
<ide> '1': '१',
<ide><path>src/locale/ms-my.js
<ide> //! locale : Bahasa Malaysia (ms-MY)
<ide> //! author : Weldan Jamili : https://github.com/weldan
<ide>
<del>import moment from "../moment";
<add>import moment from '../moment';
<ide>
<ide> export default moment.defineLocale('ms-my', {
<ide> months : 'Januari_Februari_Mac_April_Mei_Jun_Julai_Ogos_September_Oktober_November_Disember'.split('_'),
<ide><path>src/locale/my.js
<ide> //! locale : Burmese (my)
<ide> //! author : Squar team, mysquar.com
<ide>
<del>import moment from "../moment";
<add>import moment from '../moment';
<ide>
<ide> var symbolMap = {
<ide> '1': '၁',
<ide><path>src/locale/nb.js
<ide> //! authors : Espen Hovlandsdal : https://github.com/rexxars
<ide> //! Sigurd Gartmann : https://github.com/sigurdga
<ide>
<del>import moment from "../moment";
<add>import moment from '../moment';
<ide>
<ide> export default moment.defineLocale('nb', {
<ide> months : 'januar_februar_mars_april_mai_juni_juli_august_september_oktober_november_desember'.split('_'),
<ide><path>src/locale/ne.js
<ide> //! locale : nepali/nepalese
<ide> //! author : suvash : https://github.com/suvash
<ide>
<del>import moment from "../moment";
<add>import moment from '../moment';
<ide>
<ide> var symbolMap = {
<ide> '1': '१',
<ide><path>src/locale/nl.js
<ide> //! locale : dutch (nl)
<ide> //! author : Joris Röling : https://github.com/jjupiter
<ide>
<del>import moment from "../moment";
<add>import moment from '../moment';
<ide>
<ide> var monthsShortWithDots = 'jan._feb._mrt._apr._mei_jun._jul._aug._sep._okt._nov._dec.'.split('_'),
<ide> monthsShortWithoutDots = 'jan_feb_mrt_apr_mei_jun_jul_aug_sep_okt_nov_dec'.split('_');
<ide><path>src/locale/nn.js
<ide> //! locale : norwegian nynorsk (nn)
<ide> //! author : https://github.com/mechuwind
<ide>
<del>import moment from "../moment";
<add>import moment from '../moment';
<ide>
<ide> export default moment.defineLocale('nn', {
<ide> months : 'januar_februar_mars_april_mai_juni_juli_august_september_oktober_november_desember'.split('_'),
<ide><path>src/locale/pl.js
<ide> //! locale : polish (pl)
<ide> //! author : Rafal Hirsz : https://github.com/evoL
<ide>
<del>import moment from "../moment";
<add>import moment from '../moment';
<ide>
<ide> var monthsNominative = 'styczeń_luty_marzec_kwiecień_maj_czerwiec_lipiec_sierpień_wrzesień_październik_listopad_grudzień'.split('_'),
<ide> monthsSubjective = 'stycznia_lutego_marca_kwietnia_maja_czerwca_lipca_sierpnia_września_października_listopada_grudnia'.split('_');
<ide><path>src/locale/pt-br.js
<ide> //! locale : brazilian portuguese (pt-br)
<ide> //! author : Caio Ribeiro Pereira : https://github.com/caio-ribeiro-pereira
<ide>
<del>import moment from "../moment";
<add>import moment from '../moment';
<ide>
<ide> export default moment.defineLocale('pt-br', {
<ide> months : 'janeiro_fevereiro_março_abril_maio_junho_julho_agosto_setembro_outubro_novembro_dezembro'.split('_'),
<ide><path>src/locale/pt.js
<ide> //! locale : portuguese (pt)
<ide> //! author : Jefferson : https://github.com/jalex79
<ide>
<del>import moment from "../moment";
<add>import moment from '../moment';
<ide>
<ide> export default moment.defineLocale('pt', {
<ide> months : 'janeiro_fevereiro_março_abril_maio_junho_julho_agosto_setembro_outubro_novembro_dezembro'.split('_'),
<ide><path>src/locale/ro.js
<ide> //! author : Vlad Gurdiga : https://github.com/gurdiga
<ide> //! author : Valentin Agachi : https://github.com/avaly
<ide>
<del>import moment from "../moment";
<add>import moment from '../moment';
<ide>
<ide> function relativeTimeWithPlural(number, withoutSuffix, key) {
<ide> var format = {
<ide><path>src/locale/ru.js
<ide> //! author : Viktorminator : https://github.com/Viktorminator
<ide> //! Author : Menelion Elensúle : https://github.com/Oire
<ide>
<del>import moment from "../moment";
<add>import moment from '../moment';
<ide>
<ide> function plural(word, num) {
<ide> var forms = word.split('_');
<ide><path>src/locale/sk.js
<ide> //! author : Martin Minka : https://github.com/k2s
<ide> //! based on work of petrbela : https://github.com/petrbela
<ide>
<del>import moment from "../moment";
<add>import moment from '../moment';
<ide>
<ide> var months = 'január_február_marec_apríl_máj_jún_júl_august_september_október_november_december'.split('_'),
<ide> monthsShort = 'jan_feb_mar_apr_máj_jún_júl_aug_sep_okt_nov_dec'.split('_');
<ide><path>src/locale/sl.js
<ide> //! locale : slovenian (sl)
<ide> //! author : Robert Sedovšek : https://github.com/sedovsek
<ide>
<del>import moment from "../moment";
<add>import moment from '../moment';
<ide>
<ide> function translate(number, withoutSuffix, key) {
<ide> var result = number + ' ';
<ide><path>src/locale/sq.js
<ide> //! author: Menelion Elensúle: https://github.com/Oire (tests)
<ide> //! author : Oerd Cukalla : https://github.com/oerd (fixes)
<ide>
<del>import moment from "../moment";
<add>import moment from '../moment';
<ide>
<ide> export default moment.defineLocale('sq', {
<ide> months : 'Janar_Shkurt_Mars_Prill_Maj_Qershor_Korrik_Gusht_Shtator_Tetor_Nëntor_Dhjetor'.split('_'),
<ide><path>src/locale/sr-cyrl.js
<ide> //! locale : Serbian-cyrillic (sr-cyrl)
<ide> //! author : Milan Janačković<milanjanackovic@gmail.com> : https://github.com/milan-j
<ide>
<del>import moment from "../moment";
<add>import moment from '../moment';
<ide>
<ide> var translator = {
<ide> words: { //Different grammatical cases
<ide><path>src/locale/sr.js
<ide> //! locale : Serbian-latin (sr)
<ide> //! author : Milan Janačković<milanjanackovic@gmail.com> : https://github.com/milan-j
<ide>
<del>import moment from "../moment";
<add>import moment from '../moment';
<ide>
<ide> var translator = {
<ide> words: { //Different grammatical cases
<ide><path>src/locale/sv.js
<ide> //! locale : swedish (sv)
<ide> //! author : Jens Alm : https://github.com/ulmus
<ide>
<del>import moment from "../moment";
<add>import moment from '../moment';
<ide>
<ide> export default moment.defineLocale('sv', {
<ide> months : 'januari_februari_mars_april_maj_juni_juli_augusti_september_oktober_november_december'.split('_'),
<ide><path>src/locale/ta.js
<ide> //! locale : tamil (ta)
<ide> //! author : Arjunkumar Krishnamoorthy : https://github.com/tk120404
<ide>
<del>import moment from "../moment";
<add>import moment from '../moment';
<ide>
<ide> export default moment.defineLocale('ta', {
<ide> months : 'ஜனவரி_பிப்ரவரி_மார்ச்_ஏப்ரல்_மே_ஜூன்_ஜூலை_ஆகஸ்ட்_செப்டெம்பர்_அக்டோபர்_நவம்பர்_டிசம்பர்'.split('_'),
<ide><path>src/locale/th.js
<ide> //! locale : thai (th)
<ide> //! author : Kridsada Thanabulpong : https://github.com/sirn
<ide>
<del>import moment from "../moment";
<add>import moment from '../moment';
<ide>
<ide> export default moment.defineLocale('th', {
<ide> months : 'มกราคม_กุมภาพันธ์_มีนาคม_เมษายน_พฤษภาคม_มิถุนายน_กรกฎาคม_สิงหาคม_กันยายน_ตุลาคม_พฤศจิกายน_ธันวาคม'.split('_'),
<ide><path>src/locale/tl-ph.js
<ide> //! locale : Tagalog/Filipino (tl-ph)
<ide> //! author : Dan Hagman
<ide>
<del>import moment from "../moment";
<add>import moment from '../moment';
<ide>
<ide> export default moment.defineLocale('tl-ph', {
<ide> months : 'Enero_Pebrero_Marso_Abril_Mayo_Hunyo_Hulyo_Agosto_Setyembre_Oktubre_Nobyembre_Disyembre'.split('_'),
<ide><path>src/locale/tr.js
<ide> //! authors : Erhan Gundogan : https://github.com/erhangundogan,
<ide> //! Burak Yiğit Kaya: https://github.com/BYK
<ide>
<del>import moment from "../moment";
<add>import moment from '../moment';
<ide>
<ide> var suffixes = {
<ide> 1: '\'inci',
<ide><path>src/locale/tzm-latn.js
<ide> //! locale : Morocco Central Atlas Tamaziɣt in Latin (tzm-latn)
<ide> //! author : Abdel Said : https://github.com/abdelsaid
<ide>
<del>import moment from "../moment";
<add>import moment from '../moment';
<ide>
<ide> export default moment.defineLocale('tzm-latn', {
<ide> months : 'innayr_brˤayrˤ_marˤsˤ_ibrir_mayyw_ywnyw_ywlywz_ɣwšt_šwtanbir_ktˤwbrˤ_nwwanbir_dwjnbir'.split('_'),
<ide><path>src/locale/tzm.js
<ide> //! locale : Morocco Central Atlas Tamaziɣt (tzm)
<ide> //! author : Abdel Said : https://github.com/abdelsaid
<ide>
<del>import moment from "../moment";
<add>import moment from '../moment';
<ide>
<ide> export default moment.defineLocale('tzm', {
<ide> months : 'ⵉⵏⵏⴰⵢⵔ_ⴱⵕⴰⵢⵕ_ⵎⴰⵕⵚ_ⵉⴱⵔⵉⵔ_ⵎⴰⵢⵢⵓ_ⵢⵓⵏⵢⵓ_ⵢⵓⵍⵢⵓⵣ_ⵖⵓⵛⵜ_ⵛⵓⵜⴰⵏⴱⵉⵔ_ⴽⵟⵓⴱⵕ_ⵏⵓⵡⴰⵏⴱⵉⵔ_ⴷⵓⵊⵏⴱⵉⵔ'.split('_'),
<ide><path>src/locale/uk.js
<ide> //! author : zemlanin : https://github.com/zemlanin
<ide> //! Author : Menelion Elensúle : https://github.com/Oire
<ide>
<del>import moment from "../moment";
<add>import moment from '../moment';
<ide>
<ide> function plural(word, num) {
<ide> var forms = word.split('_');
<ide><path>src/locale/uz.js
<ide> //! locale : uzbek (uz)
<ide> //! author : Sardor Muminov : https://github.com/muminoff
<ide>
<del>import moment from "../moment";
<add>import moment from '../moment';
<ide>
<ide> export default moment.defineLocale('uz', {
<ide> months : 'январь_февраль_март_апрель_май_июнь_июль_август_сентябрь_октябрь_ноябрь_декабрь'.split('_'),
<ide><path>src/locale/vi.js
<ide> //! locale : vietnamese (vi)
<ide> //! author : Bang Nguyen : https://github.com/bangnk
<ide>
<del>import moment from "../moment";
<add>import moment from '../moment';
<ide>
<ide> export default moment.defineLocale('vi', {
<ide> months : 'tháng 1_tháng 2_tháng 3_tháng 4_tháng 5_tháng 6_tháng 7_tháng 8_tháng 9_tháng 10_tháng 11_tháng 12'.split('_'),
<ide><path>src/locale/zh-cn.js
<ide> //! author : suupic : https://github.com/suupic
<ide> //! author : Zeno Zeng : https://github.com/zenozeng
<ide>
<del>import moment from "../moment";
<add>import moment from '../moment';
<ide>
<ide> export default moment.defineLocale('zh-cn', {
<ide> months : '一月_二月_三月_四月_五月_六月_七月_八月_九月_十月_十一月_十二月'.split('_'),
<ide><path>src/locale/zh-tw.js
<ide> //! locale : traditional chinese (zh-tw)
<ide> //! author : Ben : https://github.com/ben-lin
<ide>
<del>import moment from "../moment";
<add>import moment from '../moment';
<ide>
<ide> export default moment.defineLocale('zh-tw', {
<ide> months : '一月_二月_三月_四月_五月_六月_七月_八月_九月_十月_十一月_十二月'.split('_'),
<ide><path>src/moment.js
<ide> //! license : MIT
<ide> //! momentjs.com
<ide>
<del>import { hooks as moment, setHookCallback } from "./lib/utils/hooks";
<add>import { hooks as moment, setHookCallback } from './lib/utils/hooks';
<ide>
<ide> moment.version = '2.9.0';
<ide>
<ide> import {
<ide> createLocal as local,
<ide> createInvalid as invalid,
<ide> createInZone as parseZone
<del>} from "./lib/moment/moment";
<add>} from './lib/moment/moment';
<ide>
<ide> import {
<ide> defineLocale,
<ide> import {
<ide> listWeekdays as weekdays,
<ide> listWeekdaysMin as weekdaysMin,
<ide> listWeekdaysShort as weekdaysShort
<del>} from "./lib/locale/locale";
<add>} from './lib/locale/locale';
<ide>
<ide> import {
<ide> isDuration,
<ide> createDuration as duration,
<ide> getSetRelativeTimeThreshold as relativeTimeThreshold
<del>} from "./lib/duration/duration";
<add>} from './lib/duration/duration';
<ide>
<del>import { normalizeUnits } from "./lib/units/units";
<add>import { normalizeUnits } from './lib/units/units';
<ide>
<del>import isDate from "./lib/utils/is-date";
<add>import isDate from './lib/utils/is-date';
<ide>
<ide> setHookCallback(local);
<ide>
<ide><path>src/test/locale/af.js
<del>import {localeModule, test} from "../qunit";
<del>import {moment} from "../../moment";
<del>localeModule("af");
<add>import {localeModule, test} from '../qunit';
<add>import {moment} from '../../moment';
<add>localeModule('af');
<ide>
<del>test("parse", function (assert) {
<add>test('parse', function (assert) {
<ide> var tests = 'Januarie Jan_Februarie Feb_Maart Mar_April Apr_Mei Mei_Junie Jun_Julie Jul_Augustus Aug_September Sep_Oktober Okt_November Nov_Desember Des'.split('_'), i;
<ide> function equalTest(input, mmm, i) {
<ide> assert.equal(moment(input, mmm).month(), i, input + ' should be month ' + (i + 1));
<ide> test("parse", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("format", function (assert) {
<add>test('format', function (assert) {
<ide> var a = [
<ide> ['dddd, MMMM Do YYYY, h:mm:ss a', 'Sondag, Februarie 14de 2010, 3:25:50 nm'],
<ide> ['ddd, hA', 'Son, 3NM'],
<ide> test("format", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("format ordinal", function (assert) {
<add>test('format ordinal', function (assert) {
<ide> assert.equal(moment([2011, 0, 1]).format('DDDo'), '1ste', '1ste');
<ide> assert.equal(moment([2011, 0, 2]).format('DDDo'), '2de', '2de');
<ide> assert.equal(moment([2011, 0, 3]).format('DDDo'), '3de', '3de');
<ide> test("format ordinal", function (assert) {
<ide> assert.equal(moment([2011, 0, 31]).format('DDDo'), '31ste', '31ste');
<ide> });
<ide>
<del>test("format month", function (assert) {
<add>test('format month', function (assert) {
<ide> var expected = 'Januarie Jan_Februarie Feb_Maart Mar_April Apr_Mei Mei_Junie Jun_Julie Jul_Augustus Aug_September Sep_Oktober Okt_November Nov_Desember Des'.split('_'), i;
<ide> for (i = 0; i < expected.length; i++) {
<ide> assert.equal(moment([2011, i, 1]).format('MMMM MMM'), expected[i], expected[i]);
<ide> }
<ide> });
<ide>
<del>test("format week", function (assert) {
<add>test('format week', function (assert) {
<ide> var expected = 'Sondag Son So_Maandag Maa Ma_Dinsdag Din Di_Woensdag Woe Wo_Donderdag Don Do_Vrydag Vry Vr_Saterdag Sat Sa'.split('_'), i;
<ide> for (i = 0; i < expected.length; i++) {
<ide> assert.equal(moment([2011, 0, 2 + i]).format('dddd ddd dd'), expected[i], expected[i]);
<ide> }
<ide> });
<ide>
<del>test("from", function (assert) {
<add>test('from', function (assert) {
<ide> var start = moment([2007, 1, 28]);
<ide> assert.equal(start.from(moment([2007, 1, 28]).add({s: 44}), true), '\'n paar sekondes', '44 seconds = a few seconds');
<ide> assert.equal(start.from(moment([2007, 1, 28]).add({s: 45}), true), '\'n minuut', '45 seconds = a minute');
<ide> test("from", function (assert) {
<ide> assert.equal(start.from(moment([2007, 1, 28]).add({y: 5}), true), '5 jaar', '5 years = 5 years');
<ide> });
<ide>
<del>test("suffix", function (assert) {
<add>test('suffix', function (assert) {
<ide> assert.equal(moment(30000).from(0), 'oor \'n paar sekondes', 'prefix');
<ide> assert.equal(moment(0).from(30000), '\'n paar sekondes gelede', 'suffix');
<ide> });
<ide>
<del>test("now from now", function (assert) {
<add>test('now from now', function (assert) {
<ide> assert.equal(moment().fromNow(), '\'n paar sekondes gelede', 'now from now should display as in the past');
<ide> });
<ide>
<del>test("fromNow", function (assert) {
<add>test('fromNow', function (assert) {
<ide> assert.equal(moment().add({s: 30}).fromNow(), 'oor \'n paar sekondes', 'in a few seconds');
<ide> assert.equal(moment().add({d: 5}).fromNow(), 'oor 5 dae', 'in 5 days');
<ide> });
<ide>
<del>test("calendar day", function (assert) {
<add>test('calendar day', function (assert) {
<ide> var a = moment().hours(2).minutes(0).seconds(0);
<ide>
<ide> assert.equal(moment(a).calendar(), 'Vandag om 02:00', 'today at the same time');
<ide> test("calendar day", function (assert) {
<ide> assert.equal(moment(a).subtract({d: 1}).calendar(), 'Gister om 02:00', 'yesterday at the same time');
<ide> });
<ide>
<del>test("calendar next week", function (assert) {
<add>test('calendar next week', function (assert) {
<ide> var i, m;
<ide> for (i = 2; i < 7; i++) {
<ide> m = moment().add({d: i});
<ide> test("calendar next week", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("calendar last week", function (assert) {
<add>test('calendar last week', function (assert) {
<ide> var i, m;
<ide> for (i = 2; i < 7; i++) {
<ide> m = moment().subtract({d: i});
<ide> test("calendar last week", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("calendar all else", function (assert) {
<add>test('calendar all else', function (assert) {
<ide> var weeksAgo = moment().subtract({w: 1}),
<ide> weeksFromNow = moment().add({w: 1});
<ide>
<ide> test("calendar all else", function (assert) {
<ide> assert.equal(weeksFromNow.calendar(), weeksFromNow.format('L'), 'in 2 weeks');
<ide> });
<ide>
<del>test("weeks year starting sunday", function (assert) {
<add>test('weeks year starting sunday', function (assert) {
<ide> assert.equal(moment([2012, 0, 1]).week(), 52, 'Jan 1 2012 should be week 52');
<ide> assert.equal(moment([2012, 0, 2]).week(), 1, 'Jan 2 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 8]).week(), 1, 'Jan 8 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 9]).week(), 2, 'Jan 9 2012 should be week 2');
<ide> assert.equal(moment([2012, 0, 15]).week(), 2, 'Jan 15 2012 should be week 2');
<ide> });
<ide>
<del>test("weeks year starting monday", function (assert) {
<add>test('weeks year starting monday', function (assert) {
<ide> assert.equal(moment([2007, 0, 1]).week(), 1, 'Jan 1 2007 should be week 1');
<ide> assert.equal(moment([2007, 0, 7]).week(), 1, 'Jan 7 2007 should be week 1');
<ide> assert.equal(moment([2007, 0, 8]).week(), 2, 'Jan 8 2007 should be week 2');
<ide> assert.equal(moment([2007, 0, 14]).week(), 2, 'Jan 14 2007 should be week 2');
<ide> assert.equal(moment([2007, 0, 15]).week(), 3, 'Jan 15 2007 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting tuesday", function (assert) {
<add>test('weeks year starting tuesday', function (assert) {
<ide> assert.equal(moment([2007, 11, 31]).week(), 1, 'Dec 31 2007 should be week 1');
<ide> assert.equal(moment([2008, 0, 1]).week(), 1, 'Jan 1 2008 should be week 1');
<ide> assert.equal(moment([2008, 0, 6]).week(), 1, 'Jan 6 2008 should be week 1');
<ide> test("weeks year starting tuesday", function (assert) {
<ide> assert.equal(moment([2008, 0, 14]).week(), 3, 'Jan 14 2008 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting wednesday", function (assert) {
<add>test('weeks year starting wednesday', function (assert) {
<ide> assert.equal(moment([2002, 11, 30]).week(), 1, 'Dec 30 2002 should be week 1');
<ide> assert.equal(moment([2003, 0, 1]).week(), 1, 'Jan 1 2003 should be week 1');
<ide> assert.equal(moment([2003, 0, 5]).week(), 1, 'Jan 5 2003 should be week 1');
<ide> test("weeks year starting wednesday", function (assert) {
<ide> assert.equal(moment([2003, 0, 13]).week(), 3, 'Jan 13 2003 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting thursday", function (assert) {
<add>test('weeks year starting thursday', function (assert) {
<ide> assert.equal(moment([2008, 11, 29]).week(), 1, 'Dec 29 2008 should be week 1');
<ide> assert.equal(moment([2009, 0, 1]).week(), 1, 'Jan 1 2009 should be week 1');
<ide> assert.equal(moment([2009, 0, 4]).week(), 1, 'Jan 4 2009 should be week 1');
<ide> test("weeks year starting thursday", function (assert) {
<ide> assert.equal(moment([2009, 0, 13]).week(), 3, 'Jan 12 2009 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting friday", function (assert) {
<add>test('weeks year starting friday', function (assert) {
<ide> assert.equal(moment([2009, 11, 28]).week(), 53, 'Dec 28 2009 should be week 53');
<ide> assert.equal(moment([2010, 0, 1]).week(), 53, 'Jan 1 2010 should be week 53');
<ide> assert.equal(moment([2010, 0, 3]).week(), 53, 'Jan 3 2010 should be week 53');
<ide> test("weeks year starting friday", function (assert) {
<ide> assert.equal(moment([2010, 0, 11]).week(), 2, 'Jan 11 2010 should be week 2');
<ide> });
<ide>
<del>test("weeks year starting saturday", function (assert) {
<add>test('weeks year starting saturday', function (assert) {
<ide> assert.equal(moment([2010, 11, 27]).week(), 52, 'Dec 27 2010 should be week 52');
<ide> assert.equal(moment([2011, 0, 1]).week(), 52, 'Jan 1 2011 should be week 52');
<ide> assert.equal(moment([2011, 0, 2]).week(), 52, 'Jan 2 2011 should be week 52');
<ide> test("weeks year starting saturday", function (assert) {
<ide> assert.equal(moment([2011, 0, 10]).week(), 2, 'Jan 10 2011 should be week 2');
<ide> });
<ide>
<del>test("weeks year starting sunday formatted", function (assert) {
<add>test('weeks year starting sunday formatted', function (assert) {
<ide> assert.equal(moment([2012, 0, 1]).format('w ww wo'), '52 52 52ste', 'Jan 1 2012 should be week 52');
<ide> assert.equal(moment([2012, 0, 2]).format('w ww wo'), '1 01 1ste', 'Jan 2 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 8]).format('w ww wo'), '1 01 1ste', 'Jan 8 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 9]).format('w ww wo'), '2 02 2de', 'Jan 9 2012 should be week 2');
<ide> assert.equal(moment([2012, 0, 15]).format('w ww wo'), '2 02 2de', 'Jan 15 2012 should be week 2');
<ide> });
<ide>
<del>test("lenient ordinal parsing", function (assert) {
<add>test('lenient ordinal parsing', function (assert) {
<ide> var i, ordinalStr, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> ordinalStr = moment([2014, 0, i]).format('YYYY MM Do');
<ide> test("lenient ordinal parsing", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("lenient ordinal parsing of number", function (assert) {
<add>test('lenient ordinal parsing of number', function (assert) {
<ide> var i, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> testMoment = moment('2014 01 ' + i, 'YYYY MM Do');
<ide> test("lenient ordinal parsing of number", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("strict ordinal parsing", function (assert) {
<add>test('strict ordinal parsing', function (assert) {
<ide> var i, ordinalStr, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> ordinalStr = moment([2014, 0, i]).format('YYYY MM Do');
<ide><path>src/test/locale/ar-ma.js
<del>import {localeModule, test} from "../qunit";
<del>import {moment} from "../../moment";
<del>localeModule("ar-ma");
<add>import {localeModule, test} from '../qunit';
<add>import {moment} from '../../moment';
<add>localeModule('ar-ma');
<ide>
<del>test("parse", function (assert) {
<add>test('parse', function (assert) {
<ide> var tests = 'يناير:يناير_فبراير:فبراير_مارس:مارس_أبريل:أبريل_ماي:ماي_يونيو:يونيو_يوليوز:يوليوز_غشت:غشت_شتنبر:شتنبر_أكتوبر:أكتوبر_نونبر:نونبر_دجنبر:دجنبر'.split('_'), i;
<ide> function equalTest(input, mmm, i) {
<ide> assert.equal(moment(input, mmm).month(), i, input + ' should be month ' + (i + 1));
<ide> test("parse", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("format", function (assert) {
<add>test('format', function (assert) {
<ide> var a = [
<ide> ['dddd, MMMM Do YYYY, h:mm:ss a', 'الأحد, فبراير 14 2010, 3:25:50 pm'],
<ide> ['ddd, hA', 'احد, 3PM'],
<ide> test("format", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("format ordinal", function (assert) {
<add>test('format ordinal', function (assert) {
<ide> assert.equal(moment([2011, 0, 1]).format('DDDo'), '1', '1');
<ide> assert.equal(moment([2011, 0, 2]).format('DDDo'), '2', '2');
<ide> assert.equal(moment([2011, 0, 3]).format('DDDo'), '3', '3');
<ide> test("format ordinal", function (assert) {
<ide> assert.equal(moment([2011, 0, 31]).format('DDDo'), '31', '31');
<ide> });
<ide>
<del>test("format month", function (assert) {
<add>test('format month', function (assert) {
<ide> var expected = 'يناير يناير_فبراير فبراير_مارس مارس_أبريل أبريل_ماي ماي_يونيو يونيو_يوليوز يوليوز_غشت غشت_شتنبر شتنبر_أكتوبر أكتوبر_نونبر نونبر_دجنبر دجنبر'.split('_'), i;
<ide> for (i = 0; i < expected.length; i++) {
<ide> assert.equal(moment([2011, i, 1]).format('MMMM MMM'), expected[i], expected[i]);
<ide> }
<ide> });
<ide>
<del>test("format week", function (assert) {
<add>test('format week', function (assert) {
<ide> var expected = 'الأحد احد ح_الإتنين اتنين ن_الثلاثاء ثلاثاء ث_الأربعاء اربعاء ر_الخميس خميس خ_الجمعة جمعة ج_السبت سبت س'.split('_'), i;
<ide> for (i = 0; i < expected.length; i++) {
<ide> assert.equal(moment([2011, 0, 2 + i]).format('dddd ddd dd'), expected[i], expected[i]);
<ide> }
<ide> });
<ide>
<del>test("from", function (assert) {
<add>test('from', function (assert) {
<ide> var start = moment([2007, 1, 28]);
<ide> assert.equal(start.from(moment([2007, 1, 28]).add({s: 44}), true), 'ثوان', '44 seconds = a few seconds');
<ide> assert.equal(start.from(moment([2007, 1, 28]).add({s: 45}), true), 'دقيقة', '45 seconds = a minute');
<ide> test("from", function (assert) {
<ide> assert.equal(start.from(moment([2007, 1, 28]).add({y: 5}), true), '5 سنوات', '5 years = 5 years');
<ide> });
<ide>
<del>test("suffix", function (assert) {
<add>test('suffix', function (assert) {
<ide> assert.equal(moment(30000).from(0), 'في ثوان', 'prefix');
<ide> assert.equal(moment(0).from(30000), 'منذ ثوان', 'suffix');
<ide> });
<ide>
<del>test("now from now", function (assert) {
<add>test('now from now', function (assert) {
<ide> assert.equal(moment().fromNow(), 'منذ ثوان', 'now from now should display as in the past');
<ide> });
<ide>
<del>test("fromNow", function (assert) {
<add>test('fromNow', function (assert) {
<ide> assert.equal(moment().add({s: 30}).fromNow(), 'في ثوان', 'in a few seconds');
<ide> assert.equal(moment().add({d: 5}).fromNow(), 'في 5 أيام', 'in 5 days');
<ide> });
<ide>
<del>test("calendar day", function (assert) {
<add>test('calendar day', function (assert) {
<ide> var a = moment().hours(2).minutes(0).seconds(0);
<ide>
<ide> assert.equal(moment(a).calendar(), 'اليوم على الساعة 02:00', 'today at the same time');
<ide> test("calendar day", function (assert) {
<ide> assert.equal(moment(a).subtract({d: 1}).calendar(), 'أمس على الساعة 02:00', 'yesterday at the same time');
<ide> });
<ide>
<del>test("calendar next week", function (assert) {
<add>test('calendar next week', function (assert) {
<ide> var i, m;
<ide> for (i = 2; i < 7; i++) {
<ide> m = moment().add({d: i});
<ide> test("calendar next week", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("calendar last week", function (assert) {
<add>test('calendar last week', function (assert) {
<ide> var i, m;
<ide> for (i = 2; i < 7; i++) {
<ide> m = moment().subtract({d: i});
<ide> test("calendar last week", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("calendar all else", function (assert) {
<add>test('calendar all else', function (assert) {
<ide> var weeksAgo = moment().subtract({w: 1}),
<ide> weeksFromNow = moment().add({w: 1});
<ide>
<ide> test("calendar all else", function (assert) {
<ide> assert.equal(weeksFromNow.calendar(), weeksFromNow.format('L'), 'in 2 weeks');
<ide> });
<ide>
<del>test("weeks year starting sunday", function (assert) {
<add>test('weeks year starting sunday', function (assert) {
<ide> assert.equal(moment([2011, 11, 31]).week(), 1, 'Dec 31 2011 should be week 1');
<ide> assert.equal(moment([2012, 0, 6]).week(), 1, 'Jan 6 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 7]).week(), 2, 'Jan 7 2012 should be week 2');
<ide> assert.equal(moment([2012, 0, 13]).week(), 2, 'Jan 13 2012 should be week 2');
<ide> assert.equal(moment([2012, 0, 14]).week(), 3, 'Jan 14 2012 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting monday", function (assert) {
<add>test('weeks year starting monday', function (assert) {
<ide> assert.equal(moment([2006, 11, 30]).week(), 1, 'Dec 30 2006 should be week 1');
<ide> assert.equal(moment([2007, 0, 5]).week(), 1, 'Jan 5 2007 should be week 1');
<ide> assert.equal(moment([2007, 0, 6]).week(), 2, 'Jan 6 2007 should be week 2');
<ide> assert.equal(moment([2007, 0, 12]).week(), 2, 'Jan 12 2007 should be week 2');
<ide> assert.equal(moment([2007, 0, 13]).week(), 3, 'Jan 13 2007 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting tuesday", function (assert) {
<add>test('weeks year starting tuesday', function (assert) {
<ide> assert.equal(moment([2007, 11, 29]).week(), 1, 'Dec 29 2007 should be week 1');
<ide> assert.equal(moment([2008, 0, 1]).week(), 1, 'Jan 1 2008 should be week 1');
<ide> assert.equal(moment([2008, 0, 4]).week(), 1, 'Jan 4 2008 should be week 1');
<ide> test("weeks year starting tuesday", function (assert) {
<ide> assert.equal(moment([2008, 0, 12]).week(), 3, 'Jan 12 2008 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting wednesday", function (assert) {
<add>test('weeks year starting wednesday', function (assert) {
<ide> assert.equal(moment([2002, 11, 28]).week(), 1, 'Dec 28 2002 should be week 1');
<ide> assert.equal(moment([2003, 0, 1]).week(), 1, 'Jan 1 2003 should be week 1');
<ide> assert.equal(moment([2003, 0, 3]).week(), 1, 'Jan 3 2003 should be week 1');
<ide> test("weeks year starting wednesday", function (assert) {
<ide> assert.equal(moment([2003, 0, 11]).week(), 3, 'Jan 11 2003 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting thursday", function (assert) {
<add>test('weeks year starting thursday', function (assert) {
<ide> assert.equal(moment([2008, 11, 27]).week(), 1, 'Dec 27 2008 should be week 1');
<ide> assert.equal(moment([2009, 0, 1]).week(), 1, 'Jan 1 2009 should be week 1');
<ide> assert.equal(moment([2009, 0, 2]).week(), 1, 'Jan 2 2009 should be week 1');
<ide> test("weeks year starting thursday", function (assert) {
<ide> assert.equal(moment([2009, 0, 10]).week(), 3, 'Jan 10 2009 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting friday", function (assert) {
<add>test('weeks year starting friday', function (assert) {
<ide> assert.equal(moment([2009, 11, 26]).week(), 1, 'Dec 26 2009 should be week 1');
<ide> assert.equal(moment([2010, 0, 1]).week(), 1, 'Jan 1 2010 should be week 1');
<ide> assert.equal(moment([2010, 0, 2]).week(), 2, 'Jan 2 2010 should be week 2');
<ide> assert.equal(moment([2010, 0, 8]).week(), 2, 'Jan 8 2010 should be week 2');
<ide> assert.equal(moment([2010, 0, 9]).week(), 3, 'Jan 9 2010 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting saturday", function (assert) {
<add>test('weeks year starting saturday', function (assert) {
<ide> assert.equal(moment([2011, 0, 1]).week(), 1, 'Jan 1 2011 should be week 1');
<ide> assert.equal(moment([2011, 0, 7]).week(), 1, 'Jan 7 2011 should be week 1');
<ide> assert.equal(moment([2011, 0, 8]).week(), 2, 'Jan 8 2011 should be week 2');
<ide> assert.equal(moment([2011, 0, 14]).week(), 2, 'Jan 14 2011 should be week 2');
<ide> assert.equal(moment([2011, 0, 15]).week(), 3, 'Jan 15 2011 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting sunday formatted", function (assert) {
<add>test('weeks year starting sunday formatted', function (assert) {
<ide> assert.equal(moment([2011, 11, 31]).format('w ww wo'), '1 01 1', 'Dec 31 2011 should be week 1');
<ide> assert.equal(moment([2012, 0, 6]).format('w ww wo'), '1 01 1', 'Jan 6 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 7]).format('w ww wo'), '2 02 2', 'Jan 7 2012 should be week 2');
<ide> assert.equal(moment([2012, 0, 13]).format('w ww wo'), '2 02 2', 'Jan 13 2012 should be week 2');
<ide> assert.equal(moment([2012, 0, 14]).format('w ww wo'), '3 03 3', 'Jan 14 2012 should be week 3');
<ide> });
<ide>
<del>test("lenient ordinal parsing", function (assert) {
<add>test('lenient ordinal parsing', function (assert) {
<ide> var i, ordinalStr, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> ordinalStr = moment([2014, 0, i]).format('YYYY MM Do');
<ide> test("lenient ordinal parsing", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("lenient ordinal parsing of number", function (assert) {
<add>test('lenient ordinal parsing of number', function (assert) {
<ide> var i, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> testMoment = moment('2014 01 ' + i, 'YYYY MM Do');
<ide> test("lenient ordinal parsing of number", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("strict ordinal parsing", function (assert) {
<add>test('strict ordinal parsing', function (assert) {
<ide> var i, ordinalStr, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> ordinalStr = moment([2014, 0, i]).format('YYYY MM Do');
<ide><path>src/test/locale/ar-sa.js
<del>import {localeModule, test} from "../qunit";
<del>import {moment} from "../../moment";
<del>localeModule("ar-sa");
<add>import {localeModule, test} from '../qunit';
<add>import {moment} from '../../moment';
<add>localeModule('ar-sa');
<ide>
<del>test("parse", function (assert) {
<add>test('parse', function (assert) {
<ide> var tests = 'يناير:يناير_فبراير:فبراير_مارس:مارس_أبريل:أبريل_مايو:مايو_يونيو:يونيو_يوليو:يوليو_أغسطس:أغسطس_سبتمبر:سبتمبر_أكتوبر:أكتوبر_نوفمبر:نوفمبر_ديسمبر:ديسمبر'.split('_'), i;
<ide> function equalTest(input, mmm, i) {
<ide> assert.equal(moment(input, mmm).month(), i, input + ' should be month ' + (i + 1) + ' instead is month ' + moment(input, mmm).month());
<ide> test("parse", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("format", function (assert) {
<add>test('format', function (assert) {
<ide> var a = [
<ide> ['dddd, MMMM Do YYYY, h:mm:ss a', 'الأحد، فبراير ١٤ ٢٠١٠، ٣:٢٥:٥٠ م'],
<ide> ['ddd, hA', 'أحد، ٣م'],
<ide> test("format", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("format ordinal", function (assert) {
<add>test('format ordinal', function (assert) {
<ide> assert.equal(moment([2011, 0, 1]).format('DDDo'), '١', '1');
<ide> assert.equal(moment([2011, 0, 2]).format('DDDo'), '٢', '2');
<ide> assert.equal(moment([2011, 0, 3]).format('DDDo'), '٣', '3');
<ide> test("format ordinal", function (assert) {
<ide> assert.equal(moment([2011, 0, 31]).format('DDDo'), '٣١', '31');
<ide> });
<ide>
<del>test("format month", function (assert) {
<add>test('format month', function (assert) {
<ide> var expected = 'يناير يناير_فبراير فبراير_مارس مارس_أبريل أبريل_مايو مايو_يونيو يونيو_يوليو يوليو_أغسطس أغسطس_سبتمبر سبتمبر_أكتوبر أكتوبر_نوفمبر نوفمبر_ديسمبر ديسمبر'.split('_'), i;
<ide> for (i = 0; i < expected.length; i++) {
<ide> assert.equal(moment([2011, i, 1]).format('MMMM MMM'), expected[i], expected[i]);
<ide> }
<ide> });
<ide>
<del>test("format week", function (assert) {
<add>test('format week', function (assert) {
<ide> var expected = 'الأحد أحد ح_الإثنين إثنين ن_الثلاثاء ثلاثاء ث_الأربعاء أربعاء ر_الخميس خميس خ_الجمعة جمعة ج_السبت سبت س'.split('_'), i;
<ide> for (i = 0; i < expected.length; i++) {
<ide> assert.equal(moment([2011, 0, 2 + i]).format('dddd ddd dd'), expected[i], expected[i]);
<ide> }
<ide> });
<ide>
<del>test("from", function (assert) {
<add>test('from', function (assert) {
<ide> var start = moment([2007, 1, 28]);
<ide> assert.equal(start.from(moment([2007, 1, 28]).add({s: 44}), true), 'ثوان', '44 seconds = a few seconds');
<ide> assert.equal(start.from(moment([2007, 1, 28]).add({s: 45}), true), 'دقيقة', '45 seconds = a minute');
<ide> test("from", function (assert) {
<ide> assert.equal(start.from(moment([2007, 1, 28]).add({y: 5}), true), '٥ سنوات', '5 years = 5 years');
<ide> });
<ide>
<del>test("suffix", function (assert) {
<add>test('suffix', function (assert) {
<ide> assert.equal(moment(30000).from(0), 'في ثوان', 'prefix');
<ide> assert.equal(moment(0).from(30000), 'منذ ثوان', 'suffix');
<ide> });
<ide>
<del>test("now from now", function (assert) {
<add>test('now from now', function (assert) {
<ide> assert.equal(moment().fromNow(), 'منذ ثوان', 'now from now should display as in the past');
<ide> });
<ide>
<del>test("fromNow", function (assert) {
<add>test('fromNow', function (assert) {
<ide> assert.equal(moment().add({s: 30}).fromNow(), 'في ثوان', 'in a few seconds');
<ide> assert.equal(moment().add({d: 5}).fromNow(), 'في ٥ أيام', 'in 5 days');
<ide> });
<ide>
<del>test("calendar day", function (assert) {
<add>test('calendar day', function (assert) {
<ide> var a = moment().hours(2).minutes(0).seconds(0);
<ide>
<ide> assert.equal(moment(a).calendar(), 'اليوم على الساعة ٠٢:٠٠', 'today at the same time');
<ide> test("calendar day", function (assert) {
<ide> assert.equal(moment(a).subtract({d: 1}).calendar(), 'أمس على الساعة ٠٢:٠٠', 'yesterday at the same time');
<ide> });
<ide>
<del>test("calendar next week", function (assert) {
<add>test('calendar next week', function (assert) {
<ide> var i, m;
<ide> for (i = 2; i < 7; i++) {
<ide> m = moment().add({d: i});
<ide> test("calendar next week", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("calendar last week", function (assert) {
<add>test('calendar last week', function (assert) {
<ide> var i, m;
<ide> for (i = 2; i < 7; i++) {
<ide> m = moment().subtract({d: i});
<ide> test("calendar last week", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("calendar all else", function (assert) {
<add>test('calendar all else', function (assert) {
<ide> var weeksAgo = moment().subtract({w: 1}),
<ide> weeksFromNow = moment().add({w: 1});
<ide>
<ide> test("calendar all else", function (assert) {
<ide> assert.equal(weeksFromNow.calendar(), weeksFromNow.format('L'), 'in 2 weeks');
<ide> });
<ide>
<del>test("weeks year starting sunday", function (assert) {
<add>test('weeks year starting sunday', function (assert) {
<ide> assert.equal(moment([2011, 11, 31]).week(), 1, 'Dec 31 2011 should be week 1');
<ide> assert.equal(moment([2012, 0, 6]).week(), 1, 'Jan 6 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 7]).week(), 2, 'Jan 7 2012 should be week 2');
<ide> assert.equal(moment([2012, 0, 13]).week(), 2, 'Jan 13 2012 should be week 2');
<ide> assert.equal(moment([2012, 0, 14]).week(), 3, 'Jan 14 2012 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting monday", function (assert) {
<add>test('weeks year starting monday', function (assert) {
<ide> assert.equal(moment([2006, 11, 30]).week(), 1, 'Dec 30 2006 should be week 1');
<ide> assert.equal(moment([2007, 0, 5]).week(), 1, 'Jan 5 2007 should be week 1');
<ide> assert.equal(moment([2007, 0, 6]).week(), 2, 'Jan 6 2007 should be week 2');
<ide> assert.equal(moment([2007, 0, 12]).week(), 2, 'Jan 12 2007 should be week 2');
<ide> assert.equal(moment([2007, 0, 13]).week(), 3, 'Jan 13 2007 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting tuesday", function (assert) {
<add>test('weeks year starting tuesday', function (assert) {
<ide> assert.equal(moment([2007, 11, 29]).week(), 1, 'Dec 29 2007 should be week 1');
<ide> assert.equal(moment([2008, 0, 1]).week(), 1, 'Jan 1 2008 should be week 1');
<ide> assert.equal(moment([2008, 0, 4]).week(), 1, 'Jan 4 2008 should be week 1');
<ide> test("weeks year starting tuesday", function (assert) {
<ide> assert.equal(moment([2008, 0, 12]).week(), 3, 'Jan 12 2008 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting wednesday", function (assert) {
<add>test('weeks year starting wednesday', function (assert) {
<ide> assert.equal(moment([2002, 11, 28]).week(), 1, 'Dec 28 2002 should be week 1');
<ide> assert.equal(moment([2003, 0, 1]).week(), 1, 'Jan 1 2003 should be week 1');
<ide> assert.equal(moment([2003, 0, 3]).week(), 1, 'Jan 3 2003 should be week 1');
<ide> test("weeks year starting wednesday", function (assert) {
<ide> assert.equal(moment('2003 1 0', 'gggg w e').format('gggg w e'), '٢٠٠٣ ١ ٠', '1st day of week 1 of 2003 parsed should be formatted as 2003 1 0');
<ide> });
<ide>
<del>test("weeks year starting thursday", function (assert) {
<add>test('weeks year starting thursday', function (assert) {
<ide> assert.equal(moment([2008, 11, 27]).week(), 1, 'Dec 27 2008 should be week 1');
<ide> assert.equal(moment([2009, 0, 1]).week(), 1, 'Jan 1 2009 should be week 1');
<ide> assert.equal(moment([2009, 0, 2]).week(), 1, 'Jan 2 2009 should be week 1');
<ide> test("weeks year starting thursday", function (assert) {
<ide> assert.equal(moment([2009, 0, 10]).week(), 3, 'Jan 10 2009 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting friday", function (assert) {
<add>test('weeks year starting friday', function (assert) {
<ide> assert.equal(moment([2009, 11, 26]).week(), 1, 'Dec 26 2009 should be week 1');
<ide> assert.equal(moment([2010, 0, 1]).week(), 1, 'Jan 1 2010 should be week 1');
<ide> assert.equal(moment([2010, 0, 2]).week(), 2, 'Jan 2 2010 should be week 2');
<ide> assert.equal(moment([2010, 0, 8]).week(), 2, 'Jan 8 2010 should be week 2');
<ide> assert.equal(moment([2010, 0, 9]).week(), 3, 'Jan 9 2010 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting saturday", function (assert) {
<add>test('weeks year starting saturday', function (assert) {
<ide> assert.equal(moment([2011, 0, 1]).week(), 1, 'Jan 1 2011 should be week 1');
<ide> assert.equal(moment([2011, 0, 7]).week(), 1, 'Jan 7 2011 should be week 1');
<ide> assert.equal(moment([2011, 0, 8]).week(), 2, 'Jan 8 2011 should be week 2');
<ide> assert.equal(moment([2011, 0, 14]).week(), 2, 'Jan 14 2011 should be week 2');
<ide> assert.equal(moment([2011, 0, 15]).week(), 3, 'Jan 15 2011 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting sunday formatted", function (assert) {
<add>test('weeks year starting sunday formatted', function (assert) {
<ide> assert.equal(moment([2011, 11, 31]).format('w ww wo'), '١ ٠١ ١', 'Dec 31 2011 should be week 1');
<ide> assert.equal(moment([2012, 0, 6]).format('w ww wo'), '١ ٠١ ١', 'Jan 6 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 7]).format('w ww wo'), '٢ ٠٢ ٢', 'Jan 7 2012 should be week 2');
<ide> assert.equal(moment([2012, 0, 13]).format('w ww wo'), '٢ ٠٢ ٢', 'Jan 13 2012 should be week 2');
<ide> assert.equal(moment([2012, 0, 14]).format('w ww wo'), '٣ ٠٣ ٣', 'Jan 14 2012 should be week 3');
<ide> });
<ide>
<del>test("lenient ordinal parsing", function (assert) {
<add>test('lenient ordinal parsing', function (assert) {
<ide> var i, ordinalStr, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> ordinalStr = moment([2014, 0, i]).format('YYYY MM Do');
<ide> test("lenient ordinal parsing", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("lenient ordinal parsing of number", function (assert) {
<add>test('lenient ordinal parsing of number', function (assert) {
<ide> var i, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> testMoment = moment('2014 01 ' + i, 'YYYY MM Do');
<ide> test("lenient ordinal parsing of number", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("strict ordinal parsing", function (assert) {
<add>test('strict ordinal parsing', function (assert) {
<ide> var i, ordinalStr, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> ordinalStr = moment([2014, 0, i]).format('YYYY MM Do');
<ide><path>src/test/locale/ar-tn.js
<del>import {localeModule, test} from "../qunit";
<del>import {moment} from "../../moment";
<del>localeModule("ar-tn");
<add>import {localeModule, test} from '../qunit';
<add>import {moment} from '../../moment';
<add>localeModule('ar-tn');
<ide>
<del>test("parse", function (assert) {
<add>test('parse', function (assert) {
<ide> var tests = 'جانفي:جانفي_فيفري:فيفري_مارس:مارس_أفريل:أفريل_ماي:ماي_جوان:جوان_جويلية:جويلية_أوت:أوت_سبتمبر:سبتمبر_أكتوبر:أكتوبر_نوفمبر:نوفمبر_ديسمبر:ديسمبر'.split('_'),
<ide> i;
<ide>
<ide> test("parse", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("format", function (assert) {
<add>test('format', function (assert) {
<ide> var a = [
<ide> ['dddd, MMMM Do YYYY, h:mm:ss a', 'الأحد, فيفري 14 2010, 3:25:50 pm'],
<ide> ['ddd, hA', 'أحد, 3PM'],
<ide> test("format", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("format ordinal", function (assert) {
<add>test('format ordinal', function (assert) {
<ide> assert.equal(moment([2011, 0, 1]).format('DDDo'), '1', '1');
<ide> assert.equal(moment([2011, 0, 2]).format('DDDo'), '2', '2');
<ide> assert.equal(moment([2011, 0, 3]).format('DDDo'), '3', '3');
<ide> test("format ordinal", function (assert) {
<ide> assert.equal(moment([2011, 0, 31]).format('DDDo'), '31', '31');
<ide> });
<ide>
<del>test("format month", function (assert) {
<add>test('format month', function (assert) {
<ide> var expected = 'جانفي جانفي_فيفري فيفري_مارس مارس_أفريل أفريل_ماي ماي_جوان جوان_جويلية جويلية_أوت أوت_سبتمبر سبتمبر_أكتوبر أكتوبر_نوفمبر نوفمبر_ديسمبر ديسمبر'.split('_'),
<ide> i;
<ide> for (i = 0; i < expected.length; i++) {
<ide> assert.equal(moment([2011, i, 1]).format('MMMM MMM'), expected[i], expected[i]);
<ide> }
<ide> });
<ide>
<del>test("format week", function (assert) {
<add>test('format week', function (assert) {
<ide> var expected = 'الأحد أحد ح_الإثنين إثنين ن_الثلاثاء ثلاثاء ث_الأربعاء أربعاء ر_الخميس خميس خ_الجمعة جمعة ج_السبت سبت س'.split('_'),
<ide> i;
<ide> for (i = 0; i < expected.length; i++) {
<ide> assert.equal(moment([2011, 0, 2 + i]).format('dddd ddd dd'), expected[i], expected[i]);
<ide> }
<ide> });
<ide>
<del>test("from", function (assert) {
<add>test('from', function (assert) {
<ide> var start = moment([2007, 1, 28]);
<ide> assert.equal(start.from(moment([2007, 1, 28]).add({
<ide> s: 44
<ide> test("from", function (assert) {
<ide> }), true), '5 سنوات', '5 years = 5 years');
<ide> });
<ide>
<del>test("suffix", function (assert) {
<add>test('suffix', function (assert) {
<ide> assert.equal(moment(30000).from(0), 'في ثوان', 'prefix');
<ide> assert.equal(moment(0).from(30000), 'منذ ثوان', 'suffix');
<ide> });
<ide>
<del>test("now from now", function (assert) {
<add>test('now from now', function (assert) {
<ide> assert.equal(moment().fromNow(), 'منذ ثوان', 'now from now should display as in the past');
<ide> });
<ide>
<del>test("fromNow", function (assert) {
<add>test('fromNow', function (assert) {
<ide> assert.equal(moment().add({
<ide> s: 30
<ide> }).fromNow(), 'في ثوان', 'in a few seconds');
<ide> test("fromNow", function (assert) {
<ide> }).fromNow(), 'في 5 أيام', 'in 5 days');
<ide> });
<ide>
<del>test("calendar day", function (assert) {
<add>test('calendar day', function (assert) {
<ide> var a = moment().hours(2).minutes(0).seconds(0);
<ide>
<ide> assert.equal(moment(a).calendar(), 'اليوم على الساعة 02:00', 'today at the same time');
<ide> test("calendar day", function (assert) {
<ide> }).calendar(), 'أمس على الساعة 02:00', 'yesterday at the same time');
<ide> });
<ide>
<del>test("calendar next week", function (assert) {
<add>test('calendar next week', function (assert) {
<ide> var i, m;
<ide> for (i = 2; i < 7; i++) {
<ide> m = moment().add({
<ide> test("calendar next week", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("calendar last week", function (assert) {
<add>test('calendar last week', function (assert) {
<ide> var i, m;
<ide> for (i = 2; i < 7; i++) {
<ide> m = moment().subtract({
<ide> test("calendar last week", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("calendar all else", function (assert) {
<add>test('calendar all else', function (assert) {
<ide> var weeksAgo = moment().subtract({
<ide> w: 1
<ide> }),
<ide> test("calendar all else", function (assert) {
<ide> assert.equal(weeksFromNow.calendar(), weeksFromNow.format('L'), 'in 2 weeks');
<ide> });
<ide>
<del>test("weeks year starting sunday", function (assert) {
<add>test('weeks year starting sunday', function (assert) {
<ide> assert.equal(moment([2012, 0, 1]).week(), 52, 'Jan 1 2012 should be week 52');
<ide> assert.equal(moment([2012, 0, 2]).week(), 1, 'Jan 2 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 8]).week(), 1, 'Jan 8 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 9]).week(), 2, 'Jan 9 2012 should be week 2');
<ide> assert.equal(moment([2012, 0, 15]).week(), 2, 'Jan 15 2012 should be week 2');
<ide> });
<ide>
<del>test("weeks year starting monday", function (assert) {
<add>test('weeks year starting monday', function (assert) {
<ide> assert.equal(moment([2007, 0, 1]).week(), 1, 'Jan 1 2007 should be week 1');
<ide> assert.equal(moment([2007, 0, 7]).week(), 1, 'Jan 7 2007 should be week 1');
<ide> assert.equal(moment([2007, 0, 8]).week(), 2, 'Jan 8 2007 should be week 2');
<ide> assert.equal(moment([2007, 0, 14]).week(), 2, 'Jan 14 2007 should be week 2');
<ide> assert.equal(moment([2007, 0, 15]).week(), 3, 'Jan 15 2007 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting tuesday", function (assert) {
<add>test('weeks year starting tuesday', function (assert) {
<ide> assert.equal(moment([2007, 11, 31]).week(), 1, 'Dec 31 2007 should be week 1');
<ide> assert.equal(moment([2008, 0, 1]).week(), 1, 'Jan 1 2008 should be week 1');
<ide> assert.equal(moment([2008, 0, 6]).week(), 1, 'Jan 6 2008 should be week 1');
<ide> test("weeks year starting tuesday", function (assert) {
<ide> assert.equal(moment([2008, 0, 14]).week(), 3, 'Jan 14 2008 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting wednesday", function (assert) {
<add>test('weeks year starting wednesday', function (assert) {
<ide> assert.equal(moment([2002, 11, 30]).week(), 1, 'Dec 30 2002 should be week 1');
<ide> assert.equal(moment([2003, 0, 1]).week(), 1, 'Jan 1 2003 should be week 1');
<ide> assert.equal(moment([2003, 0, 5]).week(), 1, 'Jan 5 2003 should be week 1');
<ide> test("weeks year starting wednesday", function (assert) {
<ide> assert.equal(moment([2003, 0, 13]).week(), 3, 'Jan 13 2003 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting thursday", function (assert) {
<add>test('weeks year starting thursday', function (assert) {
<ide> assert.equal(moment([2008, 11, 29]).week(), 1, 'Dec 29 2008 should be week 1');
<ide> assert.equal(moment([2009, 0, 1]).week(), 1, 'Jan 1 2009 should be week 1');
<ide> assert.equal(moment([2009, 0, 4]).week(), 1, 'Jan 4 2009 should be week 1');
<ide> test("weeks year starting thursday", function (assert) {
<ide> assert.equal(moment([2009, 0, 13]).week(), 3, 'Jan 12 2009 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting friday", function (assert) {
<add>test('weeks year starting friday', function (assert) {
<ide> assert.equal(moment([2009, 11, 28]).week(), 53, 'Dec 28 2009 should be week 53');
<ide> assert.equal(moment([2010, 0, 1]).week(), 53, 'Jan 1 2010 should be week 53');
<ide> assert.equal(moment([2010, 0, 3]).week(), 53, 'Jan 3 2010 should be week 53');
<ide> test("weeks year starting friday", function (assert) {
<ide> assert.equal(moment([2010, 0, 11]).week(), 2, 'Jan 11 2010 should be week 2');
<ide> });
<ide>
<del>test("weeks year starting saturday", function (assert) {
<add>test('weeks year starting saturday', function (assert) {
<ide> assert.equal(moment([2010, 11, 27]).week(), 52, 'Dec 27 2010 should be week 52');
<ide> assert.equal(moment([2011, 0, 1]).week(), 52, 'Jan 1 2011 should be week 52');
<ide> assert.equal(moment([2011, 0, 2]).week(), 52, 'Jan 2 2011 should be week 52');
<ide> test("weeks year starting saturday", function (assert) {
<ide> assert.equal(moment([2011, 0, 10]).week(), 2, 'Jan 10 2011 should be week 2');
<ide> });
<ide>
<del>test("weeks year starting sunday formatted", function (assert) {
<add>test('weeks year starting sunday formatted', function (assert) {
<ide> assert.equal(moment([2012, 0, 1]).format('w ww wo'), '52 52 52', 'Jan 1 2012 should be week 52');
<ide> assert.equal(moment([2012, 0, 2]).format('w ww wo'), '1 01 1', 'Jan 2 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 8]).format('w ww wo'), '1 01 1', 'Jan 8 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 9]).format('w ww wo'), '2 02 2', 'Jan 9 2012 should be week 2');
<ide> assert.equal(moment([2012, 0, 15]).format('w ww wo'), '2 02 2', 'Jan 15 2012 should be week 2');
<ide> });
<ide>
<del>test("lenient ordinal parsing", function (assert) {
<add>test('lenient ordinal parsing', function (assert) {
<ide> var i, ordinalStr, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> ordinalStr = moment([2014, 0, i]).format('YYYY MM Do');
<ide> test("lenient ordinal parsing", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("lenient ordinal parsing of number", function (assert) {
<add>test('lenient ordinal parsing of number', function (assert) {
<ide> var i, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> testMoment = moment('2014 01 ' + i, 'YYYY MM Do');
<ide> test("lenient ordinal parsing of number", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("strict ordinal parsing", function (assert) {
<add>test('strict ordinal parsing', function (assert) {
<ide> var i, ordinalStr, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> ordinalStr = moment([2014, 0, i]).format('YYYY MM Do');
<ide><path>src/test/locale/ar.js
<del>import {localeModule, test} from "../qunit";
<del>import {moment} from "../../moment";
<del>localeModule("ar");
<add>import {localeModule, test} from '../qunit';
<add>import {moment} from '../../moment';
<add>localeModule('ar');
<ide>
<ide> var months = [
<ide> 'كانون الثاني يناير',
<ide> var months = [
<ide> 'كانون الأول ديسمبر'
<ide> ];
<ide>
<del>test("parse", function (assert) {
<add>test('parse', function (assert) {
<ide> var tests = months, i;
<ide> function equalTest(input, mmm, i) {
<ide> assert.equal(moment(input, mmm).month(), i, input + ' should be month ' + (i + 1) + ' instead is month ' + moment(input, mmm).month());
<ide> test("parse", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("format", function (assert) {
<add>test('format', function (assert) {
<ide> var a = [
<ide> ['dddd, MMMM Do YYYY, h:mm:ss a', 'الأحد، شباط فبراير ١٤ ٢٠١٠، ٣:٢٥:٥٠ م'],
<ide> ['ddd, hA', 'أحد، ٣م'],
<ide> test("format", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("format ordinal", function (assert) {
<add>test('format ordinal', function (assert) {
<ide> assert.equal(moment([2011, 0, 1]).format('DDDo'), '١', '1');
<ide> assert.equal(moment([2011, 0, 2]).format('DDDo'), '٢', '2');
<ide> assert.equal(moment([2011, 0, 3]).format('DDDo'), '٣', '3');
<ide> test("format ordinal", function (assert) {
<ide> assert.equal(moment([2011, 0, 31]).format('DDDo'), '٣١', '31');
<ide> });
<ide>
<del>test("format month", function (assert) {
<add>test('format month', function (assert) {
<ide> var expected = months, i;
<ide> for (i = 0; i < expected.length; i++) {
<ide> assert.equal(moment([2011, i, 1]).format('MMMM'), expected[i], expected[i]);
<ide> assert.equal(moment([2011, i, 1]).format('MMM'), expected[i], expected[i]);
<ide> }
<ide> });
<ide>
<del>test("format week", function (assert) {
<add>test('format week', function (assert) {
<ide> var expected = 'الأحد أحد ح_الإثنين إثنين ن_الثلاثاء ثلاثاء ث_الأربعاء أربعاء ر_الخميس خميس خ_الجمعة جمعة ج_السبت سبت س'.split('_'), i;
<ide> for (i = 0; i < expected.length; i++) {
<ide> assert.equal(moment([2011, 0, 2 + i]).format('dddd ddd dd'), expected[i], expected[i]);
<ide> }
<ide> });
<ide>
<del>test("from", function (assert) {
<add>test('from', function (assert) {
<ide> var start = moment([2007, 1, 28]);
<ide> assert.equal(start.from(moment([2007, 1, 28]).add({s: 44}), true), '٤٤ ثانية', '44 seconds = a few seconds');
<ide> assert.equal(start.from(moment([2007, 1, 28]).add({s: 45}), true), 'دقيقة واحدة', '45 seconds = a minute');
<ide> test("from", function (assert) {
<ide> assert.equal(start.from(moment([2007, 1, 28]).add({y: 5}), true), '٥ أعوام', '5 years = 5 years');
<ide> });
<ide>
<del>test("suffix", function (assert) {
<add>test('suffix', function (assert) {
<ide> assert.equal(moment(30000).from(0), 'بعد ٣٠ ثانية', 'prefix');
<ide> assert.equal(moment(0).from(30000), 'منذ ٣٠ ثانية', 'suffix');
<ide> });
<ide>
<del>test("now from now", function (assert) {
<add>test('now from now', function (assert) {
<ide> assert.equal(moment().fromNow(), 'منذ ثانية واحدة', 'now from now should display as in the past');
<ide> });
<ide>
<del>test("fromNow", function (assert) {
<add>test('fromNow', function (assert) {
<ide> assert.equal(moment().add({s: 30}).fromNow(), 'بعد ٣٠ ثانية', 'in a few seconds');
<ide> assert.equal(moment().add({d: 5}).fromNow(), 'بعد ٥ أيام', 'in 5 days');
<ide> });
<ide>
<del>test("calendar day", function (assert) {
<add>test('calendar day', function (assert) {
<ide> var a = moment().hours(2).minutes(0).seconds(0);
<ide>
<ide> assert.equal(moment(a).calendar(), 'اليوم عند الساعة ٠٢:٠٠', 'today at the same time');
<ide> test("calendar day", function (assert) {
<ide> assert.equal(moment(a).subtract({d: 1}).calendar(), 'أمس عند الساعة ٠٢:٠٠', 'yesterday at the same time');
<ide> });
<ide>
<del>test("calendar next week", function (assert) {
<add>test('calendar next week', function (assert) {
<ide> var i, m;
<ide> for (i = 2; i < 7; i++) {
<ide> m = moment().add({d: i});
<ide> test("calendar next week", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("calendar last week", function (assert) {
<add>test('calendar last week', function (assert) {
<ide> var i, m;
<ide> for (i = 2; i < 7; i++) {
<ide> m = moment().subtract({d: i});
<ide> test("calendar last week", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("calendar all else", function (assert) {
<add>test('calendar all else', function (assert) {
<ide> var weeksAgo = moment().subtract({w: 1}),
<ide> weeksFromNow = moment().add({w: 1});
<ide>
<ide> test("calendar all else", function (assert) {
<ide> assert.equal(weeksFromNow.calendar(), weeksFromNow.format('L'), 'in 2 weeks');
<ide> });
<ide>
<del>test("weeks year starting sunday", function (assert) {
<add>test('weeks year starting sunday', function (assert) {
<ide> assert.equal(moment([2011, 11, 31]).week(), 1, 'Dec 31 2011 should be week 1');
<ide> assert.equal(moment([2012, 0, 6]).week(), 1, 'Jan 6 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 7]).week(), 2, 'Jan 7 2012 should be week 2');
<ide> assert.equal(moment([2012, 0, 13]).week(), 2, 'Jan 13 2012 should be week 2');
<ide> assert.equal(moment([2012, 0, 14]).week(), 3, 'Jan 14 2012 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting monday", function (assert) {
<add>test('weeks year starting monday', function (assert) {
<ide> assert.equal(moment([2006, 11, 30]).week(), 1, 'Dec 30 2006 should be week 1');
<ide> assert.equal(moment([2007, 0, 5]).week(), 1, 'Jan 5 2007 should be week 1');
<ide> assert.equal(moment([2007, 0, 6]).week(), 2, 'Jan 6 2007 should be week 2');
<ide> assert.equal(moment([2007, 0, 12]).week(), 2, 'Jan 12 2007 should be week 2');
<ide> assert.equal(moment([2007, 0, 13]).week(), 3, 'Jan 13 2007 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting tuesday", function (assert) {
<add>test('weeks year starting tuesday', function (assert) {
<ide> assert.equal(moment([2007, 11, 29]).week(), 1, 'Dec 29 2007 should be week 1');
<ide> assert.equal(moment([2008, 0, 1]).week(), 1, 'Jan 1 2008 should be week 1');
<ide> assert.equal(moment([2008, 0, 4]).week(), 1, 'Jan 4 2008 should be week 1');
<ide> test("weeks year starting tuesday", function (assert) {
<ide> assert.equal(moment([2008, 0, 12]).week(), 3, 'Jan 12 2008 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting wednesday", function (assert) {
<add>test('weeks year starting wednesday', function (assert) {
<ide> assert.equal(moment([2002, 11, 28]).week(), 1, 'Dec 28 2002 should be week 1');
<ide> assert.equal(moment([2003, 0, 1]).week(), 1, 'Jan 1 2003 should be week 1');
<ide> assert.equal(moment([2003, 0, 3]).week(), 1, 'Jan 3 2003 should be week 1');
<ide> test("weeks year starting wednesday", function (assert) {
<ide> assert.equal(moment('2003 1 0', 'gggg w e').format('gggg w e'), '٢٠٠٣ ١ ٠', '1st day of week 1 of 2003 parsed should be formatted as 2003 1 0');
<ide> });
<ide>
<del>test("weeks year starting thursday", function (assert) {
<add>test('weeks year starting thursday', function (assert) {
<ide> assert.equal(moment([2008, 11, 27]).week(), 1, 'Dec 27 2008 should be week 1');
<ide> assert.equal(moment([2009, 0, 1]).week(), 1, 'Jan 1 2009 should be week 1');
<ide> assert.equal(moment([2009, 0, 2]).week(), 1, 'Jan 2 2009 should be week 1');
<ide> test("weeks year starting thursday", function (assert) {
<ide> assert.equal(moment([2009, 0, 10]).week(), 3, 'Jan 10 2009 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting friday", function (assert) {
<add>test('weeks year starting friday', function (assert) {
<ide> assert.equal(moment([2009, 11, 26]).week(), 1, 'Dec 26 2009 should be week 1');
<ide> assert.equal(moment([2010, 0, 1]).week(), 1, 'Jan 1 2010 should be week 1');
<ide> assert.equal(moment([2010, 0, 2]).week(), 2, 'Jan 2 2010 should be week 2');
<ide> assert.equal(moment([2010, 0, 8]).week(), 2, 'Jan 8 2010 should be week 2');
<ide> assert.equal(moment([2010, 0, 9]).week(), 3, 'Jan 9 2010 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting saturday", function (assert) {
<add>test('weeks year starting saturday', function (assert) {
<ide> assert.equal(moment([2011, 0, 1]).week(), 1, 'Jan 1 2011 should be week 1');
<ide> assert.equal(moment([2011, 0, 7]).week(), 1, 'Jan 7 2011 should be week 1');
<ide> assert.equal(moment([2011, 0, 8]).week(), 2, 'Jan 8 2011 should be week 2');
<ide> assert.equal(moment([2011, 0, 14]).week(), 2, 'Jan 14 2011 should be week 2');
<ide> assert.equal(moment([2011, 0, 15]).week(), 3, 'Jan 15 2011 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting sunday formatted", function (assert) {
<add>test('weeks year starting sunday formatted', function (assert) {
<ide> assert.equal(moment([2011, 11, 31]).format('w ww wo'), '١ ٠١ ١', 'Dec 31 2011 should be week 1');
<ide> assert.equal(moment([2012, 0, 6]).format('w ww wo'), '١ ٠١ ١', 'Jan 6 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 7]).format('w ww wo'), '٢ ٠٢ ٢', 'Jan 7 2012 should be week 2');
<ide> assert.equal(moment([2012, 0, 13]).format('w ww wo'), '٢ ٠٢ ٢', 'Jan 13 2012 should be week 2');
<ide> assert.equal(moment([2012, 0, 14]).format('w ww wo'), '٣ ٠٣ ٣', 'Jan 14 2012 should be week 3');
<ide> });
<ide>
<del>test("lenient ordinal parsing", function (assert) {
<add>test('lenient ordinal parsing', function (assert) {
<ide> var i, ordinalStr, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> ordinalStr = moment([2014, 0, i]).format('YYYY MM Do');
<ide> test("lenient ordinal parsing", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("lenient ordinal parsing of number", function (assert) {
<add>test('lenient ordinal parsing of number', function (assert) {
<ide> var i, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> testMoment = moment('2014 01 ' + i, 'YYYY MM Do');
<ide> test("lenient ordinal parsing of number", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("strict ordinal parsing", function (assert) {
<add>test('strict ordinal parsing', function (assert) {
<ide> var i, ordinalStr, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> ordinalStr = moment([2014, 0, i]).format('YYYY MM Do');
<ide><path>src/test/locale/az.js
<del>import {localeModule, test} from "../qunit";
<del>import {moment} from "../../moment";
<del>localeModule("az");
<add>import {localeModule, test} from '../qunit';
<add>import {moment} from '../../moment';
<add>localeModule('az');
<ide>
<del>test("parse", function (assert) {
<add>test('parse', function (assert) {
<ide> var tests = 'yanvar yan_fevral fev_mart mar_Aprel apr_may may_iyun iyn_iyul iyl_Avqust avq_sentyabr sen_oktyabr okt_noyabr noy_dekabr dek'.split('_'), i;
<ide> function equalTest(input, mmm, i) {
<ide> assert.equal(moment(input, mmm).month(), i, input + ' should be month ' + (i + 1));
<ide> test("parse", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("format", function (assert) {
<add>test('format', function (assert) {
<ide> var a = [
<ide> ['dddd, D MMMM YYYY, HH:mm:ss', 'Bazar, 14 fevral 2010, 15:25:50'],
<ide> ['ddd, A h', 'Baz, gündüz 3'],
<ide> test("format", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("format ordinal", function (assert) {
<add>test('format ordinal', function (assert) {
<ide> assert.equal(moment([2011, 0, 1]).format('DDDo'), '1-inci', '1st');
<ide> assert.equal(moment([2011, 0, 2]).format('DDDo'), '2-nci', '2nd');
<ide> assert.equal(moment([2011, 0, 3]).format('DDDo'), '3-üncü', '3rd');
<ide> test("format ordinal", function (assert) {
<ide> assert.equal(moment([2011, 0, 31]).format('DDDo'), '31-inci', '31st');
<ide> });
<ide>
<del>test("format month", function (assert) {
<add>test('format month', function (assert) {
<ide> var expected = 'yanvar yan_fevral fev_mart mar_aprel apr_may may_iyun iyn_iyul iyl_avqust avq_sentyabr sen_oktyabr okt_noyabr noy_dekabr dek'.split('_'), i;
<ide> for (i = 0; i < expected.length; i++) {
<ide> assert.equal(moment([2011, i, 1]).format('MMMM MMM'), expected[i], expected[i]);
<ide> }
<ide> });
<ide>
<del>test("format week", function (assert) {
<add>test('format week', function (assert) {
<ide> var expected = 'Bazar Baz Bz_Bazar ertəsi BzE BE_Çərşənbə axşamı ÇAx ÇA_Çərşənbə Çər Çə_Cümə axşamı CAx CA_Cümə Cüm Cü_Şənbə Şən Şə'.split('_'), i;
<ide> for (i = 0; i < expected.length; i++) {
<ide> assert.equal(moment([2011, 0, 2 + i]).format('dddd ddd dd'), expected[i], expected[i]);
<ide> }
<ide> });
<ide>
<del>test("from", function (assert) {
<add>test('from', function (assert) {
<ide> var start = moment([2007, 1, 28]);
<ide> assert.equal(start.from(moment([2007, 1, 28]).add({s: 44}), true), 'birneçə saniyyə', '44 seconds = a few seconds');
<ide> assert.equal(start.from(moment([2007, 1, 28]).add({s: 45}), true), 'bir dəqiqə', '45 seconds = a minute');
<ide> test("from", function (assert) {
<ide> assert.equal(start.from(moment([2007, 1, 28]).add({y: 5}), true), '5 il', '5 years = 5 years');
<ide> });
<ide>
<del>test("suffix", function (assert) {
<add>test('suffix', function (assert) {
<ide> assert.equal(moment(30000).from(0), 'birneçə saniyyə sonra', 'prefix');
<ide> assert.equal(moment(0).from(30000), 'birneçə saniyyə əvvəl', 'suffix');
<ide> });
<ide>
<del>test("now from now", function (assert) {
<add>test('now from now', function (assert) {
<ide> assert.equal(moment().fromNow(), 'birneçə saniyyə əvvəl', 'now from now should display as in the past');
<ide> });
<ide>
<del>test("fromNow", function (assert) {
<add>test('fromNow', function (assert) {
<ide> assert.equal(moment().add({s: 30}).fromNow(), 'birneçə saniyyə sonra', 'in a few seconds');
<ide> assert.equal(moment().add({d: 5}).fromNow(), '5 gün sonra', 'in 5 days');
<ide> });
<ide>
<del>test("calendar day", function (assert) {
<add>test('calendar day', function (assert) {
<ide> var a = moment().hours(2).minutes(0).seconds(0);
<ide>
<ide> assert.equal(moment(a).calendar(), 'bugün saat 02:00', 'today at the same time');
<ide> test("calendar day", function (assert) {
<ide> assert.equal(moment(a).subtract({d: 1}).calendar(), 'dünən 02:00', 'yesterday at the same time');
<ide> });
<ide>
<del>test("calendar next week", function (assert) {
<add>test('calendar next week', function (assert) {
<ide> var i, m;
<ide> for (i = 2; i < 7; i++) {
<ide> m = moment().add({d: i});
<ide> test("calendar next week", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("calendar last week", function (assert) {
<add>test('calendar last week', function (assert) {
<ide> var i, m;
<ide> for (i = 2; i < 7; i++) {
<ide> m = moment().subtract({d: i});
<ide> test("calendar last week", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("calendar all else", function (assert) {
<add>test('calendar all else', function (assert) {
<ide> var weeksAgo = moment().subtract({w: 1}),
<ide> weeksFromNow = moment().add({w: 1});
<ide>
<ide> test("calendar all else", function (assert) {
<ide> assert.equal(weeksFromNow.calendar(), weeksFromNow.format('L'), 'in 2 weeks');
<ide> });
<ide>
<del>test("weeks year starting sunday", function (assert) {
<add>test('weeks year starting sunday', function (assert) {
<ide> assert.equal(moment([2011, 11, 26]).week(), 1, 'Dec 26 2011 should be week 1');
<ide> assert.equal(moment([2012, 0, 1]).week(), 1, 'Jan 1 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 2]).week(), 2, 'Jan 2 2012 should be week 2');
<ide> assert.equal(moment([2012, 0, 8]).week(), 2, 'Jan 8 2012 should be week 2');
<ide> assert.equal(moment([2012, 0, 9]).week(), 3, 'Jan 9 2012 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting monday", function (assert) {
<add>test('weeks year starting monday', function (assert) {
<ide> assert.equal(moment([2007, 0, 1]).week(), 1, 'Jan 1 2007 should be week 1');
<ide> assert.equal(moment([2007, 0, 7]).week(), 1, 'Jan 7 2007 should be week 1');
<ide> assert.equal(moment([2007, 0, 8]).week(), 2, 'Jan 8 2007 should be week 2');
<ide> assert.equal(moment([2007, 0, 14]).week(), 2, 'Jan 14 2007 should be week 2');
<ide> assert.equal(moment([2007, 0, 15]).week(), 3, 'Jan 15 2007 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting tuesday", function (assert) {
<add>test('weeks year starting tuesday', function (assert) {
<ide> assert.equal(moment([2007, 11, 31]).week(), 1, 'Dec 31 2007 should be week 1');
<ide> assert.equal(moment([2008, 0, 1]).week(), 1, 'Jan 1 2008 should be week 1');
<ide> assert.equal(moment([2008, 0, 6]).week(), 1, 'Jan 6 2008 should be week 1');
<ide> test("weeks year starting tuesday", function (assert) {
<ide> assert.equal(moment([2008, 0, 14]).week(), 3, 'Jan 14 2008 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting wednesday", function (assert) {
<add>test('weeks year starting wednesday', function (assert) {
<ide> assert.equal(moment([2002, 11, 30]).week(), 1, 'Dec 30 2002 should be week 1');
<ide> assert.equal(moment([2003, 0, 1]).week(), 1, 'Jan 1 2003 should be week 1');
<ide> assert.equal(moment([2003, 0, 5]).week(), 1, 'Jan 5 2003 should be week 1');
<ide> test("weeks year starting wednesday", function (assert) {
<ide> assert.equal(moment([2003, 0, 13]).week(), 3, 'Jan 13 2003 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting thursday", function (assert) {
<add>test('weeks year starting thursday', function (assert) {
<ide> assert.equal(moment([2008, 11, 29]).week(), 1, 'Dec 29 2008 should be week 1');
<ide> assert.equal(moment([2009, 0, 1]).week(), 1, 'Jan 1 2009 should be week 1');
<ide> assert.equal(moment([2009, 0, 4]).week(), 1, 'Jan 4 2009 should be week 1');
<ide> test("weeks year starting thursday", function (assert) {
<ide> assert.equal(moment([2009, 0, 12]).week(), 3, 'Jan 12 2009 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting friday", function (assert) {
<add>test('weeks year starting friday', function (assert) {
<ide> assert.equal(moment([2009, 11, 28]).week(), 1, 'Dec 28 2009 should be week 1');
<ide> assert.equal(moment([2010, 0, 1]).week(), 1, 'Jan 1 2010 should be week 1');
<ide> assert.equal(moment([2010, 0, 3]).week(), 1, 'Jan 3 2010 should be week 1');
<ide> test("weeks year starting friday", function (assert) {
<ide> assert.equal(moment([2010, 0, 11]).week(), 3, 'Jan 11 2010 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting saturday", function (assert) {
<add>test('weeks year starting saturday', function (assert) {
<ide> assert.equal(moment([2010, 11, 27]).week(), 1, 'Dec 27 2010 should be week 1');
<ide> assert.equal(moment([2011, 0, 1]).week(), 1, 'Jan 1 2011 should be week 1');
<ide> assert.equal(moment([2011, 0, 2]).week(), 1, 'Jan 2 2011 should be week 1');
<ide> test("weeks year starting saturday", function (assert) {
<ide> assert.equal(moment([2011, 0, 10]).week(), 3, 'Jan 10 2011 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting sunday formatted", function (assert) {
<add>test('weeks year starting sunday formatted', function (assert) {
<ide> assert.equal(moment([2011, 11, 26]).format('w ww wo'), '1 01 1-inci', 'Dec 26 2011 should be week 1');
<ide> assert.equal(moment([2012, 0, 1]).format('w ww wo'), '1 01 1-inci', 'Jan 1 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 2]).format('w ww wo'), '2 02 2-nci', 'Jan 2 2012 should be week 2');
<ide> assert.equal(moment([2012, 0, 8]).format('w ww wo'), '2 02 2-nci', 'Jan 8 2012 should be week 2');
<ide> assert.equal(moment([2012, 0, 9]).format('w ww wo'), '3 03 3-üncü', 'Jan 9 2012 should be week 3');
<ide> });
<ide>
<del>test("lenient ordinal parsing", function (assert) {
<add>test('lenient ordinal parsing', function (assert) {
<ide> var i, ordinalStr, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> ordinalStr = moment([2014, 0, i]).format('YYYY MM Do');
<ide> test("lenient ordinal parsing", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("lenient ordinal parsing of number", function (assert) {
<add>test('lenient ordinal parsing of number', function (assert) {
<ide> var i, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> testMoment = moment('2014 01 ' + i, 'YYYY MM Do');
<ide> test("lenient ordinal parsing of number", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("strict ordinal parsing", function (assert) {
<add>test('strict ordinal parsing', function (assert) {
<ide> var i, ordinalStr, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> ordinalStr = moment([2014, 0, i]).format('YYYY MM Do');
<ide><path>src/test/locale/be.js
<del>import {localeModule, test} from "../qunit";
<del>import {moment} from "../../moment";
<del>localeModule("be");
<add>import {localeModule, test} from '../qunit';
<add>import {moment} from '../../moment';
<add>localeModule('be');
<ide>
<del>test("parse", function (assert) {
<add>test('parse', function (assert) {
<ide> var tests = 'студзень студ_люты лют_сакавік сак_красавік крас_травень трав_чэрвень чэрв_ліпень ліп_жнівень жнів_верасень вер_кастрычнік каст_лістапад ліст_снежань снеж'.split('_'), i;
<ide> function equalTest(input, mmm, i) {
<ide> assert.equal(moment(input, mmm).month(), i, input + ' should be month ' + (i + 1));
<ide> test("parse", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("format", function (assert) {
<add>test('format', function (assert) {
<ide> var a = [
<ide> ['dddd, Do MMMM YYYY, HH:mm:ss', 'нядзеля, 14-га лютага 2010, 15:25:50'],
<ide> ['ddd, h A', 'нд, 3 дня'],
<ide> test("format", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("format meridiem", function (assert) {
<add>test('format meridiem', function (assert) {
<ide> assert.equal(moment([2012, 11, 28, 0, 0]).format('A'), 'ночы', 'night');
<ide> assert.equal(moment([2012, 11, 28, 3, 59]).format('A'), 'ночы', 'night');
<ide> assert.equal(moment([2012, 11, 28, 4, 0]).format('A'), 'раніцы', 'morning');
<ide> test("format meridiem", function (assert) {
<ide> assert.equal(moment([2012, 11, 28, 23, 59]).format('A'), 'вечара', 'evening');
<ide> });
<ide>
<del>test("format ordinal", function (assert) {
<add>test('format ordinal', function (assert) {
<ide> assert.equal(moment([2011, 0, 1]).format('DDDo'), '1-ы', '1-ы');
<ide> assert.equal(moment([2011, 0, 2]).format('DDDo'), '2-і', '2-і');
<ide> assert.equal(moment([2011, 0, 3]).format('DDDo'), '3-і', '3-і');
<ide> test("format ordinal", function (assert) {
<ide> assert.equal(moment([2011, 0, 31]).format('DDDo'), '31-ы', '31-ы');
<ide> });
<ide>
<del>test("format month", function (assert) {
<add>test('format month', function (assert) {
<ide> var expected = 'студзень студ_люты лют_сакавік сак_красавік крас_травень трав_чэрвень чэрв_ліпень ліп_жнівень жнів_верасень вер_кастрычнік каст_лістапад ліст_снежань снеж'.split('_'), i;
<ide> for (i = 0; i < expected.length; i++) {
<ide> assert.equal(moment([2011, i, 1]).format('MMMM MMM'), expected[i], expected[i]);
<ide> }
<ide> });
<ide>
<del>test("format month case", function (assert) {
<add>test('format month case', function (assert) {
<ide> var months = {
<ide> 'nominative': 'студзень_люты_сакавік_красавік_травень_чэрвень_ліпень_жнівень_верасень_кастрычнік_лістапад_снежань'.split('_'),
<ide> 'accusative': 'студзеня_лютага_сакавіка_красавіка_траўня_чэрвеня_ліпеня_жніўня_верасня_кастрычніка_лістапада_снежня'.split('_')
<ide> test("format month case", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("format month case with escaped symbols", function (assert) {
<add>test('format month case with escaped symbols', function (assert) {
<ide> var months = {
<ide> 'nominative': 'студзень_люты_сакавік_красавік_травень_чэрвень_ліпень_жнівень_верасень_кастрычнік_лістапад_снежань'.split('_'),
<ide> 'accusative': 'студзеня_лютага_сакавіка_красавіка_траўня_чэрвеня_ліпеня_жніўня_верасня_кастрычніка_лістапада_снежня'.split('_')
<ide> test("format month case with escaped symbols", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("format week", function (assert) {
<add>test('format week', function (assert) {
<ide> var expected = 'нядзеля нд нд_панядзелак пн пн_аўторак ат ат_серада ср ср_чацвер чц чц_пятніца пт пт_субота сб сб'.split('_'), i;
<ide> for (i = 0; i < expected.length; i++) {
<ide> assert.equal(moment([2011, 0, 2 + i]).format('dddd ddd dd'), expected[i], expected[i]);
<ide> }
<ide> });
<ide>
<del>test("from", function (assert) {
<add>test('from', function (assert) {
<ide> var start = moment([2007, 1, 28]);
<ide> assert.equal(start.from(moment([2007, 1, 28]).add({s: 44}), true), 'некалькі секунд', '44 seconds = a few seconds');
<ide> assert.equal(start.from(moment([2007, 1, 28]).add({s: 45}), true), 'хвіліна', '45 seconds = a minute');
<ide> test("from", function (assert) {
<ide> assert.equal(start.from(moment([2007, 1, 28]).add({y: 5}), true), '5 гадоў', '5 years = 5 years');
<ide> });
<ide>
<del>test("suffix", function (assert) {
<add>test('suffix', function (assert) {
<ide> assert.equal(moment(30000).from(0), 'праз некалькі секунд', 'prefix');
<ide> assert.equal(moment(0).from(30000), 'некалькі секунд таму', 'suffix');
<ide> });
<ide>
<del>test("fromNow", function (assert) {
<add>test('fromNow', function (assert) {
<ide> assert.equal(moment().add({s: 30}).fromNow(), 'праз некалькі секунд', 'in a few seconds');
<ide> assert.equal(moment().add({d: 5}).fromNow(), 'праз 5 дзён', 'in 5 days');
<ide> assert.equal(moment().add({m: 31}).fromNow(), 'праз 31 хвіліну', 'in 31 minutes = in 31 minutes');
<ide> assert.equal(moment().subtract({m: 31}).fromNow(), '31 хвіліну таму', '31 minutes ago = 31 minutes ago');
<ide> });
<ide>
<del>test("calendar day", function (assert) {
<add>test('calendar day', function (assert) {
<ide> var a = moment().hours(2).minutes(0).seconds(0);
<ide>
<ide> assert.equal(moment(a).calendar(), 'Сёння ў 02:00', 'today at the same time');
<ide> test("calendar day", function (assert) {
<ide> assert.equal(moment(a).subtract({d: 1}).calendar(), 'Учора ў 02:00', 'yesterday at the same time');
<ide> });
<ide>
<del>test("calendar next week", function (assert) {
<add>test('calendar next week', function (assert) {
<ide> var i, m;
<ide> function makeFormat(d) {
<ide> return '[У] dddd [ў] LT';
<ide> test("calendar next week", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("calendar last week", function (assert) {
<add>test('calendar last week', function (assert) {
<ide> var i, m;
<ide>
<ide> function makeFormat(d) {
<ide> test("calendar last week", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("calendar all else", function (assert) {
<add>test('calendar all else', function (assert) {
<ide> var weeksAgo = moment().subtract({w: 1}),
<ide> weeksFromNow = moment().add({w: 1});
<ide>
<ide> test("calendar all else", function (assert) {
<ide> assert.equal(weeksFromNow.calendar(), weeksFromNow.format('L'), 'in 2 weeks');
<ide> });
<ide>
<del>test("weeks year starting sunday", function (assert) {
<add>test('weeks year starting sunday', function (assert) {
<ide> assert.equal(moment([2011, 11, 26]).week(), 1, 'Dec 26 2011 should be week 1');
<ide> assert.equal(moment([2012, 0, 1]).week(), 1, 'Jan 1 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 2]).week(), 2, 'Jan 2 2012 should be week 2');
<ide> assert.equal(moment([2012, 0, 8]).week(), 2, 'Jan 8 2012 should be week 2');
<ide> assert.equal(moment([2012, 0, 9]).week(), 3, 'Jan 9 2012 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting monday", function (assert) {
<add>test('weeks year starting monday', function (assert) {
<ide> assert.equal(moment([2007, 0, 1]).week(), 1, 'Jan 1 2007 should be week 1');
<ide> assert.equal(moment([2007, 0, 7]).week(), 1, 'Jan 7 2007 should be week 1');
<ide> assert.equal(moment([2007, 0, 8]).week(), 2, 'Jan 8 2007 should be week 2');
<ide> assert.equal(moment([2007, 0, 14]).week(), 2, 'Jan 14 2007 should be week 2');
<ide> assert.equal(moment([2007, 0, 15]).week(), 3, 'Jan 15 2007 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting tuesday", function (assert) {
<add>test('weeks year starting tuesday', function (assert) {
<ide> assert.equal(moment([2007, 11, 31]).week(), 1, 'Dec 31 2007 should be week 1');
<ide> assert.equal(moment([2008, 0, 1]).week(), 1, 'Jan 1 2008 should be week 1');
<ide> assert.equal(moment([2008, 0, 6]).week(), 1, 'Jan 6 2008 should be week 1');
<ide> test("weeks year starting tuesday", function (assert) {
<ide> assert.equal(moment([2008, 0, 14]).week(), 3, 'Jan 14 2008 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting wednesday", function (assert) {
<add>test('weeks year starting wednesday', function (assert) {
<ide> assert.equal(moment([2002, 11, 30]).week(), 1, 'Dec 30 2002 should be week 1');
<ide> assert.equal(moment([2003, 0, 1]).week(), 1, 'Jan 1 2003 should be week 1');
<ide> assert.equal(moment([2003, 0, 5]).week(), 1, 'Jan 5 2003 should be week 1');
<ide> test("weeks year starting wednesday", function (assert) {
<ide> assert.equal(moment([2003, 0, 13]).week(), 3, 'Jan 13 2003 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting thursday", function (assert) {
<add>test('weeks year starting thursday', function (assert) {
<ide> assert.equal(moment([2008, 11, 29]).week(), 1, 'Dec 29 2008 should be week 1');
<ide> assert.equal(moment([2009, 0, 1]).week(), 1, 'Jan 1 2009 should be week 1');
<ide> assert.equal(moment([2009, 0, 4]).week(), 1, 'Jan 4 2009 should be week 1');
<ide> test("weeks year starting thursday", function (assert) {
<ide> assert.equal(moment([2009, 0, 12]).week(), 3, 'Jan 12 2009 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting friday", function (assert) {
<add>test('weeks year starting friday', function (assert) {
<ide> assert.equal(moment([2009, 11, 28]).week(), 1, 'Dec 28 2009 should be week 1');
<ide> assert.equal(moment([2010, 0, 1]).week(), 1, 'Jan 1 2010 should be week 1');
<ide> assert.equal(moment([2010, 0, 3]).week(), 1, 'Jan 3 2010 should be week 1');
<ide> test("weeks year starting friday", function (assert) {
<ide> assert.equal(moment([2010, 0, 11]).week(), 3, 'Jan 11 2010 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting saturday", function (assert) {
<add>test('weeks year starting saturday', function (assert) {
<ide> assert.equal(moment([2010, 11, 27]).week(), 1, 'Dec 27 2010 should be week 1');
<ide> assert.equal(moment([2011, 0, 1]).week(), 1, 'Jan 1 2011 should be week 1');
<ide> assert.equal(moment([2011, 0, 2]).week(), 1, 'Jan 2 2011 should be week 1');
<ide> test("weeks year starting saturday", function (assert) {
<ide> assert.equal(moment([2011, 0, 10]).week(), 3, 'Jan 10 2011 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting sunday formatted", function (assert) {
<add>test('weeks year starting sunday formatted', function (assert) {
<ide> assert.equal(moment([2011, 11, 26]).format('w ww wo'), '1 01 1-ы', 'Dec 26 2011 should be week 1');
<ide> assert.equal(moment([2012, 0, 1]).format('w ww wo'), '1 01 1-ы', 'Jan 1 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 2]).format('w ww wo'), '2 02 2-і', 'Jan 2 2012 should be week 2');
<ide> assert.equal(moment([2012, 0, 8]).format('w ww wo'), '2 02 2-і', 'Jan 8 2012 should be week 2');
<ide> assert.equal(moment([2012, 0, 9]).format('w ww wo'), '3 03 3-і', 'Jan 9 2012 should be week 3');
<ide> });
<ide>
<del>test("lenient ordinal parsing", function (assert) {
<add>test('lenient ordinal parsing', function (assert) {
<ide> var i, ordinalStr, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> ordinalStr = moment([2014, 0, i]).format('YYYY MM Do');
<ide> test("lenient ordinal parsing", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("lenient ordinal parsing of number", function (assert) {
<add>test('lenient ordinal parsing of number', function (assert) {
<ide> var i, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> testMoment = moment('2014 01 ' + i, 'YYYY MM Do');
<ide> test("lenient ordinal parsing of number", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("strict ordinal parsing", function (assert) {
<add>test('strict ordinal parsing', function (assert) {
<ide> var i, ordinalStr, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> ordinalStr = moment([2014, 0, i]).format('YYYY MM Do');
<ide><path>src/test/locale/bg.js
<del>import {localeModule, test} from "../qunit";
<del>import {moment} from "../../moment";
<del>localeModule("bg");
<add>import {localeModule, test} from '../qunit';
<add>import {moment} from '../../moment';
<add>localeModule('bg');
<ide>
<del>test("parse", function (assert) {
<add>test('parse', function (assert) {
<ide> var tests = 'януари янр_февруари фев_март мар_април апр_май май_юни юни_юли юли_август авг_септември сеп_октомври окт_ноември ное_декември дек'.split('_'), i;
<ide> function equalTest(input, mmm, i) {
<ide> assert.equal(moment(input, mmm).month(), i, input + ' should be month ' + (i + 1));
<ide> test("parse", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("format", function (assert) {
<add>test('format', function (assert) {
<ide> var a = [
<ide> ['dddd, MMMM Do YYYY, H:mm:ss', 'неделя, февруари 14-ти 2010, 15:25:50'],
<ide> ['ddd, hA', 'нед, 3PM'],
<ide> test("format", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("format ordinal", function (assert) {
<add>test('format ordinal', function (assert) {
<ide> assert.equal(moment([2011, 0, 1]).format('DDDo'), '1-ви', '1-ви');
<ide> assert.equal(moment([2011, 0, 2]).format('DDDo'), '2-ри', '2-ри');
<ide> assert.equal(moment([2011, 0, 3]).format('DDDo'), '3-ти', '3-ти');
<ide> test("format ordinal", function (assert) {
<ide> assert.equal(moment([2011, 0, 31]).format('DDDo'), '31-ви', '31-ви');
<ide> });
<ide>
<del>test("format month", function (assert) {
<add>test('format month', function (assert) {
<ide> var expected = 'януари янр_февруари фев_март мар_април апр_май май_юни юни_юли юли_август авг_септември сеп_октомври окт_ноември ное_декември дек'.split('_'), i;
<ide> for (i = 0; i < expected.length; i++) {
<ide> assert.equal(moment([2011, i, 1]).format('MMMM MMM'), expected[i], expected[i]);
<ide> }
<ide> });
<ide>
<del>test("format week", function (assert) {
<add>test('format week', function (assert) {
<ide> var expected = 'неделя нед нд_понеделник пон пн_вторник вто вт_сряда сря ср_четвъртък чет чт_петък пет пт_събота съб сб'.split('_'), i;
<ide> for (i = 0; i < expected.length; i++) {
<ide> assert.equal(moment([2011, 0, 2 + i]).format('dddd ddd dd'), expected[i], expected[i]);
<ide> }
<ide> });
<ide>
<del>test("from", function (assert) {
<add>test('from', function (assert) {
<ide> var start = moment([2007, 1, 28]);
<ide> assert.equal(start.from(moment([2007, 1, 28]).add({s: 44}), true), 'няколко секунди', '44 seconds = a few seconds');
<ide> assert.equal(start.from(moment([2007, 1, 28]).add({s: 45}), true), 'минута', '45 seconds = a minute');
<ide> test("from", function (assert) {
<ide> assert.equal(start.from(moment([2007, 1, 28]).add({y: 5}), true), '5 години', '5 years = 5 years');
<ide> });
<ide>
<del>test("suffix", function (assert) {
<add>test('suffix', function (assert) {
<ide> assert.equal(moment(30000).from(0), 'след няколко секунди', 'prefix');
<ide> assert.equal(moment(0).from(30000), 'преди няколко секунди', 'suffix');
<ide> });
<ide>
<del>test("now from now", function (assert) {
<add>test('now from now', function (assert) {
<ide> assert.equal(moment().fromNow(), 'преди няколко секунди', 'now from now should display as in the past');
<ide> });
<ide>
<del>test("fromNow", function (assert) {
<add>test('fromNow', function (assert) {
<ide> assert.equal(moment().add({s: 30}).fromNow(), 'след няколко секунди', 'in a few seconds');
<ide> assert.equal(moment().add({d: 5}).fromNow(), 'след 5 дни', 'in 5 days');
<ide> });
<ide>
<del>test("calendar day", function (assert) {
<add>test('calendar day', function (assert) {
<ide> var a = moment().hours(2).minutes(0).seconds(0);
<ide>
<ide> assert.equal(moment(a).calendar(), 'Днес в 2:00', 'today at the same time');
<ide> test("calendar day", function (assert) {
<ide> assert.equal(moment(a).subtract({d: 1}).calendar(), 'Вчера в 2:00', 'yesterday at the same time');
<ide> });
<ide>
<del>test("calendar next week", function (assert) {
<add>test('calendar next week', function (assert) {
<ide> var i, m;
<ide> for (i = 2; i < 7; i++) {
<ide> m = moment().add({d: i});
<ide> test("calendar next week", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("calendar last week", function (assert) {
<add>test('calendar last week', function (assert) {
<ide> var i, m;
<ide>
<ide> function makeFormat(d) {
<ide> test("calendar last week", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("calendar all else", function (assert) {
<add>test('calendar all else', function (assert) {
<ide> var weeksAgo = moment().subtract({w: 1}),
<ide> weeksFromNow = moment().add({w: 1});
<ide>
<ide> test("calendar all else", function (assert) {
<ide> assert.equal(weeksFromNow.calendar(), weeksFromNow.format('L'), 'in 2 weeks');
<ide> });
<ide>
<del>test("weeks year starting sunday", function (assert) {
<add>test('weeks year starting sunday', function (assert) {
<ide> assert.equal(moment([2011, 11, 26]).week(), 1, 'Dec 26 2011 should be week 1');
<ide> assert.equal(moment([2012, 0, 1]).week(), 1, 'Jan 1 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 2]).week(), 2, 'Jan 2 2012 should be week 2');
<ide> assert.equal(moment([2012, 0, 8]).week(), 2, 'Jan 8 2012 should be week 2');
<ide> assert.equal(moment([2012, 0, 9]).week(), 3, 'Jan 9 2012 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting monday", function (assert) {
<add>test('weeks year starting monday', function (assert) {
<ide> assert.equal(moment([2007, 0, 1]).week(), 1, 'Jan 1 2007 should be week 1');
<ide> assert.equal(moment([2007, 0, 7]).week(), 1, 'Jan 7 2007 should be week 1');
<ide> assert.equal(moment([2007, 0, 8]).week(), 2, 'Jan 8 2007 should be week 2');
<ide> assert.equal(moment([2007, 0, 14]).week(), 2, 'Jan 14 2007 should be week 2');
<ide> assert.equal(moment([2007, 0, 15]).week(), 3, 'Jan 15 2007 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting tuesday", function (assert) {
<add>test('weeks year starting tuesday', function (assert) {
<ide> assert.equal(moment([2007, 11, 31]).week(), 1, 'Dec 31 2007 should be week 1');
<ide> assert.equal(moment([2008, 0, 1]).week(), 1, 'Jan 1 2008 should be week 1');
<ide> assert.equal(moment([2008, 0, 6]).week(), 1, 'Jan 6 2008 should be week 1');
<ide> test("weeks year starting tuesday", function (assert) {
<ide> assert.equal(moment([2008, 0, 14]).week(), 3, 'Jan 14 2008 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting wednesday", function (assert) {
<add>test('weeks year starting wednesday', function (assert) {
<ide> assert.equal(moment([2002, 11, 30]).week(), 1, 'Dec 30 2002 should be week 1');
<ide> assert.equal(moment([2003, 0, 1]).week(), 1, 'Jan 1 2003 should be week 1');
<ide> assert.equal(moment([2003, 0, 5]).week(), 1, 'Jan 5 2003 should be week 1');
<ide> test("weeks year starting wednesday", function (assert) {
<ide> assert.equal(moment([2003, 0, 13]).week(), 3, 'Jan 13 2003 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting thursday", function (assert) {
<add>test('weeks year starting thursday', function (assert) {
<ide> assert.equal(moment([2008, 11, 29]).week(), 1, 'Dec 29 2008 should be week 1');
<ide> assert.equal(moment([2009, 0, 1]).week(), 1, 'Jan 1 2009 should be week 1');
<ide> assert.equal(moment([2009, 0, 4]).week(), 1, 'Jan 4 2009 should be week 1');
<ide> test("weeks year starting thursday", function (assert) {
<ide> assert.equal(moment([2009, 0, 12]).week(), 3, 'Jan 12 2009 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting friday", function (assert) {
<add>test('weeks year starting friday', function (assert) {
<ide> assert.equal(moment([2009, 11, 28]).week(), 1, 'Dec 28 2009 should be week 1');
<ide> assert.equal(moment([2010, 0, 1]).week(), 1, 'Jan 1 2010 should be week 1');
<ide> assert.equal(moment([2010, 0, 3]).week(), 1, 'Jan 3 2010 should be week 1');
<ide> test("weeks year starting friday", function (assert) {
<ide> assert.equal(moment([2010, 0, 11]).week(), 3, 'Jan 11 2010 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting saturday", function (assert) {
<add>test('weeks year starting saturday', function (assert) {
<ide> assert.equal(moment([2010, 11, 27]).week(), 1, 'Dec 27 2010 should be week 1');
<ide> assert.equal(moment([2011, 0, 1]).week(), 1, 'Jan 1 2011 should be week 1');
<ide> assert.equal(moment([2011, 0, 2]).week(), 1, 'Jan 2 2011 should be week 1');
<ide> test("weeks year starting saturday", function (assert) {
<ide> assert.equal(moment([2011, 0, 10]).week(), 3, 'Jan 10 2011 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting sunday formatted", function (assert) {
<add>test('weeks year starting sunday formatted', function (assert) {
<ide> assert.equal(moment([2011, 11, 26]).format('w ww wo'), '1 01 1-ви', 'Dec 26 2011 should be week 1');
<ide> assert.equal(moment([2012, 0, 1]).format('w ww wo'), '1 01 1-ви', 'Jan 1 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 2]).format('w ww wo'), '2 02 2-ри', 'Jan 2 2012 should be week 2');
<ide> assert.equal(moment([2012, 0, 8]).format('w ww wo'), '2 02 2-ри', 'Jan 8 2012 should be week 2');
<ide> assert.equal(moment([2012, 0, 9]).format('w ww wo'), '3 03 3-ти', 'Jan 9 2012 should be week 3');
<ide> });
<ide>
<del>test("lenient ordinal parsing", function (assert) {
<add>test('lenient ordinal parsing', function (assert) {
<ide> var i, ordinalStr, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> ordinalStr = moment([2014, 0, i]).format('YYYY MM Do');
<ide> test("lenient ordinal parsing", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("lenient ordinal parsing of number", function (assert) {
<add>test('lenient ordinal parsing of number', function (assert) {
<ide> var i, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> testMoment = moment('2014 01 ' + i, 'YYYY MM Do');
<ide> test("lenient ordinal parsing of number", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("strict ordinal parsing", function (assert) {
<add>test('strict ordinal parsing', function (assert) {
<ide> var i, ordinalStr, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> ordinalStr = moment([2014, 0, i]).format('YYYY MM Do');
<ide><path>src/test/locale/bn.js
<del>import {localeModule, test} from "../qunit";
<del>import {moment} from "../../moment";
<del>localeModule("bn");
<add>import {localeModule, test} from '../qunit';
<add>import {moment} from '../../moment';
<add>localeModule('bn');
<ide>
<del>test("parse", function (assert) {
<add>test('parse', function (assert) {
<ide> var tests = 'জানুয়ারী জানু_ফেবুয়ারী ফেব_মার্চ মার্চ_এপ্রিল এপর_মে মে_জুন জুন_জুলাই জুল_অগাস্ট অগ_সেপ্টেম্বর সেপ্ট_অক্টোবর অক্টো_নভেম্বর নভ_ডিসেম্বর ডিসেম্'.split('_'), i;
<ide> function equalTest(input, mmm, i) {
<ide> assert.equal(moment(input, mmm).month(), i, input + ' should be month ' + (i + 1));
<ide> test("parse", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("format", function (assert) {
<add>test('format', function (assert) {
<ide> var a = [
<ide> ['dddd, Do MMMM YYYY, a h:mm:ss সময়', 'রবিবার, ১৪ ফেবুয়ারী ২০১০, দুপুর ৩:২৫:৫০ সময়'],
<ide> ['ddd, a h সময়', 'রবি, দুপুর ৩ সময়'],
<ide> test("format", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("format ordinal", function (assert) {
<add>test('format ordinal', function (assert) {
<ide> assert.equal(moment([2011, 0, 1]).format('DDDo'), '১', '১');
<ide> assert.equal(moment([2011, 0, 2]).format('DDDo'), '২', '২');
<ide> assert.equal(moment([2011, 0, 3]).format('DDDo'), '৩', '৩');
<ide> test("format ordinal", function (assert) {
<ide> assert.equal(moment([2011, 0, 31]).format('DDDo'), '৩১', '৩১');
<ide> });
<ide>
<del>test("format month", function (assert) {
<add>test('format month', function (assert) {
<ide> var expected = 'জানুয়ারী জানু_ফেবুয়ারী ফেব_মার্চ মার্চ_এপ্রিল এপর_মে মে_জুন জুন_জুলাই জুল_অগাস্ট অগ_সেপ্টেম্বর সেপ্ট_অক্টোবর অক্টো_নভেম্বর নভ_ডিসেম্বর ডিসেম্'.split('_'), i;
<ide> for (i = 0; i < expected.length; i++) {
<ide> assert.equal(moment([2011, i, 1]).format('MMMM MMM'), expected[i], expected[i]);
<ide> }
<ide> });
<ide>
<del>test("format week", function (assert) {
<add>test('format week', function (assert) {
<ide> var expected = 'রবিবার রবি রব_সোমবার সোম সম_মঙ্গলবার মঙ্গল মঙ্গ_বুধবার বুধ বু_বৃহস্পত্তিবার বৃহস্পত্তি ব্রিহ_শুক্রুবার শুক্রু শু_শনিবার শনি শনি'.split('_'), i;
<ide> for (i = 0; i < expected.length; i++) {
<ide> assert.equal(moment([2011, 0, 2 + i]).format('dddd ddd dd'), expected[i], expected[i]);
<ide> }
<ide> });
<ide>
<del>test("from", function (assert) {
<add>test('from', function (assert) {
<ide> var start = moment([2007, 1, 28]);
<ide> assert.equal(start.from(moment([2007, 1, 28]).add({s: 44}), true), 'কএক সেকেন্ড', '44 seconds = a few seconds');
<ide> assert.equal(start.from(moment([2007, 1, 28]).add({s: 45}), true), 'এক মিনিট', '45 seconds = a minute');
<ide> test("from", function (assert) {
<ide> assert.equal(start.from(moment([2007, 1, 28]).add({y: 5}), true), '৫ বছর', '5 years = 5 years');
<ide> });
<ide>
<del>test("suffix", function (assert) {
<add>test('suffix', function (assert) {
<ide> assert.equal(moment(30000).from(0), 'কএক সেকেন্ড পরে', 'prefix');
<ide> assert.equal(moment(0).from(30000), 'কএক সেকেন্ড আগে', 'suffix');
<ide> });
<ide>
<del>test("now from now", function (assert) {
<add>test('now from now', function (assert) {
<ide> assert.equal(moment().fromNow(), 'কএক সেকেন্ড আগে', 'now from now should display as in the past');
<ide> });
<ide>
<del>test("fromNow", function (assert) {
<add>test('fromNow', function (assert) {
<ide> assert.equal(moment().add({s: 30}).fromNow(), 'কএক সেকেন্ড পরে', 'কএক সেকেন্ড পরে');
<ide> assert.equal(moment().add({d: 5}).fromNow(), '৫ দিন পরে', '৫ দিন পরে');
<ide> });
<ide>
<del>test("calendar day", function (assert) {
<add>test('calendar day', function (assert) {
<ide> var a = moment().hours(2).minutes(0).seconds(0);
<ide>
<ide> assert.equal(moment(a).calendar(), 'আজ রাত ২:০০ সময়', 'today at the same time');
<ide> test("calendar day", function (assert) {
<ide> assert.equal(moment(a).subtract({d: 1}).calendar(), 'গতকাল রাত ২:০০ সময়', 'yesterday at the same time');
<ide> });
<ide>
<del>test("calendar next week", function (assert) {
<add>test('calendar next week', function (assert) {
<ide> var i, m;
<ide> for (i = 2; i < 7; i++) {
<ide> m = moment().add({d: i});
<ide> test("calendar next week", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("calendar last week", function (assert) {
<add>test('calendar last week', function (assert) {
<ide> var i, m;
<ide>
<ide> for (i = 2; i < 7; i++) {
<ide> test("calendar last week", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("calendar all else", function (assert) {
<add>test('calendar all else', function (assert) {
<ide> var weeksAgo = moment().subtract({w: 1}),
<ide> weeksFromNow = moment().add({w: 1});
<ide>
<ide> test("calendar all else", function (assert) {
<ide> assert.equal(weeksFromNow.calendar(), weeksFromNow.format('L'), 'in 2 weeks');
<ide> });
<ide>
<del>test("meridiem", function (assert) {
<add>test('meridiem', function (assert) {
<ide> assert.equal(moment([2011, 2, 23, 2, 30]).format('a'), 'রাত', 'before dawn');
<ide> assert.equal(moment([2011, 2, 23, 9, 30]).format('a'), 'শকাল', 'morning');
<ide> assert.equal(moment([2011, 2, 23, 14, 30]).format('a'), 'দুপুর', 'during day');
<ide> test("meridiem", function (assert) {
<ide> assert.equal(moment([2011, 2, 23, 21, 20]).format('A'), 'রাত', 'night');
<ide> });
<ide>
<del>test("weeks year starting sunday", function (assert) {
<add>test('weeks year starting sunday', function (assert) {
<ide> assert.equal(moment([2012, 0, 1]).week(), 1, 'Jan 1 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 7]).week(), 1, 'Jan 7 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 8]).week(), 2, 'Jan 8 2012 should be week 2');
<ide> assert.equal(moment([2012, 0, 14]).week(), 2, 'Jan 14 2012 should be week 2');
<ide> assert.equal(moment([2012, 0, 15]).week(), 3, 'Jan 15 2012 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting monday", function (assert) {
<add>test('weeks year starting monday', function (assert) {
<ide> assert.equal(moment([2006, 11, 31]).week(), 1, 'Dec 31 2006 should be week 1');
<ide> assert.equal(moment([2007, 0, 1]).week(), 1, 'Jan 1 2007 should be week 1');
<ide> assert.equal(moment([2007, 0, 6]).week(), 1, 'Jan 6 2007 should be week 1');
<ide> test("weeks year starting monday", function (assert) {
<ide> assert.equal(moment([2007, 0, 14]).week(), 3, 'Jan 14 2007 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting tuesday", function (assert) {
<add>test('weeks year starting tuesday', function (assert) {
<ide> assert.equal(moment([2007, 11, 29]).week(), 52, 'Dec 29 2007 should be week 52');
<ide> assert.equal(moment([2008, 0, 1]).week(), 1, 'Jan 1 2008 should be week 1');
<ide> assert.equal(moment([2008, 0, 5]).week(), 1, 'Jan 5 2008 should be week 1');
<ide> test("weeks year starting tuesday", function (assert) {
<ide> assert.equal(moment([2008, 0, 13]).week(), 3, 'Jan 13 2008 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting wednesday", function (assert) {
<add>test('weeks year starting wednesday', function (assert) {
<ide> assert.equal(moment([2002, 11, 29]).week(), 1, 'Dec 29 2002 should be week 1');
<ide> assert.equal(moment([2003, 0, 1]).week(), 1, 'Jan 1 2003 should be week 1');
<ide> assert.equal(moment([2003, 0, 4]).week(), 1, 'Jan 4 2003 should be week 1');
<ide> test("weeks year starting wednesday", function (assert) {
<ide> assert.equal(moment([2003, 0, 12]).week(), 3, 'Jan 12 2003 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting thursday", function (assert) {
<add>test('weeks year starting thursday', function (assert) {
<ide> assert.equal(moment([2008, 11, 28]).week(), 1, 'Dec 28 2008 should be week 1');
<ide> assert.equal(moment([2009, 0, 1]).week(), 1, 'Jan 1 2009 should be week 1');
<ide> assert.equal(moment([2009, 0, 3]).week(), 1, 'Jan 3 2009 should be week 1');
<ide> test("weeks year starting thursday", function (assert) {
<ide> assert.equal(moment([2009, 0, 11]).week(), 3, 'Jan 11 2009 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting friday", function (assert) {
<add>test('weeks year starting friday', function (assert) {
<ide> assert.equal(moment([2009, 11, 27]).week(), 1, 'Dec 27 2009 should be week 1');
<ide> assert.equal(moment([2010, 0, 1]).week(), 1, 'Jan 1 2010 should be week 1');
<ide> assert.equal(moment([2010, 0, 2]).week(), 1, 'Jan 2 2010 should be week 1');
<ide> test("weeks year starting friday", function (assert) {
<ide> assert.equal(moment([2010, 0, 10]).week(), 3, 'Jan 10 2010 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting saturday", function (assert) {
<add>test('weeks year starting saturday', function (assert) {
<ide> assert.equal(moment([2010, 11, 26]).week(), 1, 'Dec 26 2010 should be week 1');
<ide> assert.equal(moment([2011, 0, 1]).week(), 1, 'Jan 1 2011 should be week 1');
<ide> assert.equal(moment([2011, 0, 2]).week(), 2, 'Jan 2 2011 should be week 2');
<ide> assert.equal(moment([2011, 0, 8]).week(), 2, 'Jan 8 2011 should be week 2');
<ide> assert.equal(moment([2011, 0, 9]).week(), 3, 'Jan 9 2011 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting sunday formatted", function (assert) {
<add>test('weeks year starting sunday formatted', function (assert) {
<ide> assert.equal(moment([2012, 0, 1]).format('w ww wo'), '১ ০১ ১', 'Jan 1 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 7]).format('w ww wo'), '১ ০১ ১', 'Jan 7 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 8]).format('w ww wo'), '২ ০২ ২', 'Jan 8 2012 should be week 2');
<ide> assert.equal(moment([2012, 0, 14]).format('w ww wo'), '২ ০২ ২', 'Jan 14 2012 should be week 2');
<ide> assert.equal(moment([2012, 0, 15]).format('w ww wo'), '৩ ০৩ ৩', 'Jan 15 2012 should be week 3');
<ide> });
<ide>
<del>test("lenient ordinal parsing", function (assert) {
<add>test('lenient ordinal parsing', function (assert) {
<ide> var i, ordinalStr, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> ordinalStr = moment([2014, 0, i]).format('YYYY MM Do');
<ide> test("lenient ordinal parsing", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("lenient ordinal parsing of number", function (assert) {
<add>test('lenient ordinal parsing of number', function (assert) {
<ide> var i, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> testMoment = moment('2014 01 ' + i, 'YYYY MM Do');
<ide> test("lenient ordinal parsing of number", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("strict ordinal parsing", function (assert) {
<add>test('strict ordinal parsing', function (assert) {
<ide> var i, ordinalStr, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> ordinalStr = moment([2014, 0, i]).format('YYYY MM Do');
<ide><path>src/test/locale/bo.js
<del>import {localeModule, test} from "../qunit";
<del>import {moment} from "../../moment";
<del>localeModule("bo");
<add>import {localeModule, test} from '../qunit';
<add>import {moment} from '../../moment';
<add>localeModule('bo');
<ide>
<del>test("parse", function (assert) {
<add>test('parse', function (assert) {
<ide> var tests = 'ཟླ་བ་དང་པོ ཟླ་བ་དང་པོ._ཟླ་བ་གཉིས་པ ཟླ་བ་གཉིས་པ_ཟླ་བ་གསུམ་པ ཟླ་བ་གསུམ་པ_ཟླ་བ་བཞི་པ ཟླ་བ་བཞི་པ_ཟླ་བ་ལྔ་པ ཟླ་བ་ལྔ་པ_ཟླ་བ་དྲུག་པ ཟླ་བ་དྲུག་པ_ཟླ་བ་བདུན་པ ཟླ་བ་བདུན་པ_ཟླ་བ་བརྒྱད་པ ཟླ་བ་བརྒྱད་པ_ཟླ་བ་དགུ་པ ཟླ་བ་དགུ་པ_ཟླ་བ་བཅུ་པ ཟླ་བ་བཅུ་པ_ཟླ་བ་བཅུ་གཅིག་པ ཟླ་བ་བཅུ་གཅིག་པ_ཟླ་བ་བཅུ་གཉིས་པ ཟླ་བ་བཅུ་གཉིས་པ'.split('_'), i;
<ide> function equalTest(input, mmm, i) {
<ide> assert.equal(moment(input, mmm).month(), i, input + ' should be month ' + (i + 1));
<ide> test("parse", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("format", function (assert) {
<add>test('format', function (assert) {
<ide> var a = [
<ide> ['dddd, Do MMMM YYYY, a h:mm:ss ལ་', 'གཟའ་ཉི་མ་, ༡༤ ཟླ་བ་གཉིས་པ ༢༠༡༠, ཉིན་གུང ༣:༢༥:༥༠ ལ་'],
<ide> ['ddd, a h ལ་', 'ཉི་མ་, ཉིན་གུང ༣ ལ་'],
<ide> test("format", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("format ordinal", function (assert) {
<add>test('format ordinal', function (assert) {
<ide> assert.equal(moment([2011, 0, 1]).format('DDDo'), '༡', '༡');
<ide> assert.equal(moment([2011, 0, 2]).format('DDDo'), '༢', '༢');
<ide> assert.equal(moment([2011, 0, 3]).format('DDDo'), '༣', '༣');
<ide> test("format ordinal", function (assert) {
<ide> assert.equal(moment([2011, 0, 31]).format('DDDo'), '༣༡', '༣༡');
<ide> });
<ide>
<del>test("format month", function (assert) {
<add>test('format month', function (assert) {
<ide> var expected = 'ཟླ་བ་དང་པོ ཟླ་བ་དང་པོ_ཟླ་བ་གཉིས་པ ཟླ་བ་གཉིས་པ_ཟླ་བ་གསུམ་པ ཟླ་བ་གསུམ་པ_ཟླ་བ་བཞི་པ ཟླ་བ་བཞི་པ_ཟླ་བ་ལྔ་པ ཟླ་བ་ལྔ་པ_ཟླ་བ་དྲུག་པ ཟླ་བ་དྲུག་པ_ཟླ་བ་བདུན་པ ཟླ་བ་བདུན་པ_ཟླ་བ་བརྒྱད་པ ཟླ་བ་བརྒྱད་པ_ཟླ་བ་དགུ་པ ཟླ་བ་དགུ་པ_ཟླ་བ་བཅུ་པ ཟླ་བ་བཅུ་པ_ཟླ་བ་བཅུ་གཅིག་པ ཟླ་བ་བཅུ་གཅིག་པ_ཟླ་བ་བཅུ་གཉིས་པ ཟླ་བ་བཅུ་གཉིས་པ'.split('_'), i;
<ide> for (i = 0; i < expected.length; i++) {
<ide> assert.equal(moment([2011, i, 1]).format('MMMM MMM'), expected[i], expected[i]);
<ide> }
<ide> });
<ide>
<del>test("format week", function (assert) {
<add>test('format week', function (assert) {
<ide> var expected = 'གཟའ་ཉི་མ་ ཉི་མ་ ཉི་མ་_གཟའ་ཟླ་བ་ ཟླ་བ་ ཟླ་བ་_གཟའ་མིག་དམར་ མིག་དམར་ མིག་དམར་_གཟའ་ལྷག་པ་ ལྷག་པ་ ལྷག་པ་_གཟའ་ཕུར་བུ ཕུར་བུ ཕུར་བུ_གཟའ་པ་སངས་ པ་སངས་ པ་སངས་_གཟའ་སྤེན་པ་ སྤེན་པ་ སྤེན་པ་'.split('_'), i;
<ide> for (i = 0; i < expected.length; i++) {
<ide> assert.equal(moment([2011, 0, 2 + i]).format('dddd ddd dd'), expected[i], expected[i]);
<ide> }
<ide> });
<ide>
<del>test("from", function (assert) {
<add>test('from', function (assert) {
<ide> var start = moment([2007, 1, 28]);
<ide> assert.equal(start.from(moment([2007, 1, 28]).add({s: 44}), true), 'ལམ་སང', '44 seconds = a few seconds');
<ide> assert.equal(start.from(moment([2007, 1, 28]).add({s: 45}), true), 'སྐར་མ་གཅིག', '45 seconds = a minute');
<ide> test("from", function (assert) {
<ide> assert.equal(start.from(moment([2007, 1, 28]).add({y: 5}), true), '༥ ལོ', '5 years = 5 years');
<ide> });
<ide>
<del>test("suffix", function (assert) {
<add>test('suffix', function (assert) {
<ide> assert.equal(moment(30000).from(0), 'ལམ་སང ལ་', 'prefix');
<ide> assert.equal(moment(0).from(30000), 'ལམ་སང སྔན་ལ', 'suffix');
<ide> });
<ide>
<del>test("now from now", function (assert) {
<add>test('now from now', function (assert) {
<ide> assert.equal(moment().fromNow(), 'ལམ་སང སྔན་ལ', 'now from now should display as in the past');
<ide> });
<ide>
<del>test("fromNow", function (assert) {
<add>test('fromNow', function (assert) {
<ide> assert.equal(moment().add({s: 30}).fromNow(), 'ལམ་སང ལ་', 'ལམ་སང ལ་');
<ide> assert.equal(moment().add({d: 5}).fromNow(), '༥ ཉིན་ ལ་', '༥ ཉིན་ ལ་');
<ide> });
<ide>
<del>test("calendar day", function (assert) {
<add>test('calendar day', function (assert) {
<ide> var a = moment().hours(2).minutes(0).seconds(0);
<ide>
<ide> assert.equal(moment(a).calendar(), 'དི་རིང མཚན་མོ ༢:༠༠', 'today at the same time');
<ide> test("calendar day", function (assert) {
<ide> assert.equal(moment(a).subtract({d: 1}).calendar(), 'ཁ་སང མཚན་མོ ༢:༠༠', 'yesterday at the same time');
<ide> });
<ide>
<del>test("calendar next week", function (assert) {
<add>test('calendar next week', function (assert) {
<ide> var i, m;
<ide> for (i = 2; i < 7; i++) {
<ide> m = moment().add({d: i});
<ide> test("calendar next week", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("calendar last week", function (assert) {
<add>test('calendar last week', function (assert) {
<ide> var i, m;
<ide>
<ide> for (i = 2; i < 7; i++) {
<ide> test("calendar last week", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("calendar all else", function (assert) {
<add>test('calendar all else', function (assert) {
<ide> var weeksAgo = moment().subtract({w: 1}),
<ide> weeksFromNow = moment().add({w: 1});
<ide>
<ide> test("calendar all else", function (assert) {
<ide> assert.equal(weeksFromNow.calendar(), weeksFromNow.format('L'), 'in 2 weeks');
<ide> });
<ide>
<del>test("meridiem", function (assert) {
<add>test('meridiem', function (assert) {
<ide> assert.equal(moment([2011, 2, 23, 2, 30]).format('a'), 'མཚན་མོ', 'before dawn');
<ide> assert.equal(moment([2011, 2, 23, 9, 30]).format('a'), 'ཞོགས་ཀས', 'morning');
<ide> assert.equal(moment([2011, 2, 23, 14, 30]).format('a'), 'ཉིན་གུང', 'during day');
<ide> test("meridiem", function (assert) {
<ide> assert.equal(moment([2011, 2, 23, 21, 20]).format('A'), 'མཚན་མོ', 'night');
<ide> });
<ide>
<del>test("weeks year starting sunday", function (assert) {
<add>test('weeks year starting sunday', function (assert) {
<ide> assert.equal(moment([2012, 0, 1]).week(), 1, 'Jan 1 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 7]).week(), 1, 'Jan 7 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 8]).week(), 2, 'Jan 8 2012 should be week 2');
<ide> assert.equal(moment([2012, 0, 14]).week(), 2, 'Jan 14 2012 should be week 2');
<ide> assert.equal(moment([2012, 0, 15]).week(), 3, 'Jan 15 2012 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting monday", function (assert) {
<add>test('weeks year starting monday', function (assert) {
<ide> assert.equal(moment([2006, 11, 31]).week(), 1, 'Dec 31 2006 should be week 1');
<ide> assert.equal(moment([2007, 0, 1]).week(), 1, 'Jan 1 2007 should be week 1');
<ide> assert.equal(moment([2007, 0, 6]).week(), 1, 'Jan 6 2007 should be week 1');
<ide> test("weeks year starting monday", function (assert) {
<ide> assert.equal(moment([2007, 0, 14]).week(), 3, 'Jan 14 2007 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting tuesday", function (assert) {
<add>test('weeks year starting tuesday', function (assert) {
<ide> assert.equal(moment([2007, 11, 29]).week(), 52, 'Dec 29 2007 should be week 52');
<ide> assert.equal(moment([2008, 0, 1]).week(), 1, 'Jan 1 2008 should be week 1');
<ide> assert.equal(moment([2008, 0, 5]).week(), 1, 'Jan 5 2008 should be week 1');
<ide> test("weeks year starting tuesday", function (assert) {
<ide> assert.equal(moment([2008, 0, 13]).week(), 3, 'Jan 13 2008 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting wednesday", function (assert) {
<add>test('weeks year starting wednesday', function (assert) {
<ide> assert.equal(moment([2002, 11, 29]).week(), 1, 'Dec 29 2002 should be week 1');
<ide> assert.equal(moment([2003, 0, 1]).week(), 1, 'Jan 1 2003 should be week 1');
<ide> assert.equal(moment([2003, 0, 4]).week(), 1, 'Jan 4 2003 should be week 1');
<ide> test("weeks year starting wednesday", function (assert) {
<ide> assert.equal(moment([2003, 0, 12]).week(), 3, 'Jan 12 2003 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting thursday", function (assert) {
<add>test('weeks year starting thursday', function (assert) {
<ide> assert.equal(moment([2008, 11, 28]).week(), 1, 'Dec 28 2008 should be week 1');
<ide> assert.equal(moment([2009, 0, 1]).week(), 1, 'Jan 1 2009 should be week 1');
<ide> assert.equal(moment([2009, 0, 3]).week(), 1, 'Jan 3 2009 should be week 1');
<ide> test("weeks year starting thursday", function (assert) {
<ide> assert.equal(moment([2009, 0, 11]).week(), 3, 'Jan 11 2009 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting friday", function (assert) {
<add>test('weeks year starting friday', function (assert) {
<ide> assert.equal(moment([2009, 11, 27]).week(), 1, 'Dec 27 2009 should be week 1');
<ide> assert.equal(moment([2010, 0, 1]).week(), 1, 'Jan 1 2010 should be week 1');
<ide> assert.equal(moment([2010, 0, 2]).week(), 1, 'Jan 2 2010 should be week 1');
<ide> test("weeks year starting friday", function (assert) {
<ide> assert.equal(moment([2010, 0, 10]).week(), 3, 'Jan 10 2010 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting saturday", function (assert) {
<add>test('weeks year starting saturday', function (assert) {
<ide> assert.equal(moment([2010, 11, 26]).week(), 1, 'Dec 26 2010 should be week 1');
<ide> assert.equal(moment([2011, 0, 1]).week(), 1, 'Jan 1 2011 should be week 1');
<ide> assert.equal(moment([2011, 0, 2]).week(), 2, 'Jan 2 2011 should be week 2');
<ide> assert.equal(moment([2011, 0, 8]).week(), 2, 'Jan 8 2011 should be week 2');
<ide> assert.equal(moment([2011, 0, 9]).week(), 3, 'Jan 9 2011 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting sunday formatted", function (assert) {
<add>test('weeks year starting sunday formatted', function (assert) {
<ide> assert.equal(moment([2012, 0, 1]).format('w ww wo'), '༡ ༠༡ ༡', 'Jan 1 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 7]).format('w ww wo'), '༡ ༠༡ ༡', 'Jan 7 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 8]).format('w ww wo'), '༢ ༠༢ ༢', 'Jan 8 2012 should be week 2');
<ide> assert.equal(moment([2012, 0, 14]).format('w ww wo'), '༢ ༠༢ ༢', 'Jan 14 2012 should be week 2');
<ide> assert.equal(moment([2012, 0, 15]).format('w ww wo'), '༣ ༠༣ ༣', 'Jan 15 2012 should be week 3');
<ide> });
<ide>
<del>test("lenient ordinal parsing", function (assert) {
<add>test('lenient ordinal parsing', function (assert) {
<ide> var i, ordinalStr, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> ordinalStr = moment([2014, 0, i]).format('YYYY MM Do');
<ide> test("lenient ordinal parsing", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("lenient ordinal parsing of number", function (assert) {
<add>test('lenient ordinal parsing of number', function (assert) {
<ide> var i, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> testMoment = moment('2014 01 ' + i, 'YYYY MM Do');
<ide> test("lenient ordinal parsing of number", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("strict ordinal parsing", function (assert) {
<add>test('strict ordinal parsing', function (assert) {
<ide> var i, ordinalStr, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> ordinalStr = moment([2014, 0, i]).format('YYYY MM Do');
<ide><path>src/test/locale/br.js
<del>import {localeModule, test} from "../qunit";
<del>import {moment} from "../../moment";
<del>localeModule("br");
<add>import {localeModule, test} from '../qunit';
<add>import {moment} from '../../moment';
<add>localeModule('br');
<ide>
<del>test("parse", function (assert) {
<add>test('parse', function (assert) {
<ide> var tests = 'Genver Gen_C\'hwevrer C\'hwe_Meurzh Meu_Ebrel Ebr_Mae Mae_Mezheven Eve_Gouere Gou_Eost Eos_Gwengolo Gwe_Here Her_Du Du_Kerzu Ker'.split('_'), i;
<ide> function equalTest(input, mmm, i) {
<ide> assert.equal(moment(input, mmm).month(), i, input + ' should be month ' + (i + 1));
<ide> test("parse", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("format", function (assert) {
<add>test('format', function (assert) {
<ide> moment.locale('br');
<ide> var a = [
<ide> ['dddd, MMMM Do YYYY, h:mm:ss a', 'Sul, C\'hwevrer 14vet 2010, 3:25:50 pm'],
<ide> test("format", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("format ordinal", function (assert) {
<add>test('format ordinal', function (assert) {
<ide> moment.locale('br');
<ide> assert.equal(moment([2011, 0, 1]).format('DDDo'), '1añ', '1añ');
<ide> assert.equal(moment([2011, 0, 2]).format('DDDo'), '2vet', '2vet');
<ide> test("format ordinal", function (assert) {
<ide> assert.equal(moment([2011, 0, 31]).format('DDDo'), '31vet', '31vet');
<ide> });
<ide>
<del>test("format month", function (assert) {
<add>test('format month', function (assert) {
<ide> moment.locale('br');
<ide> var expected = 'Genver Gen_C\'hwevrer C\'hwe_Meurzh Meu_Ebrel Ebr_Mae Mae_Mezheven Eve_Gouere Gou_Eost Eos_Gwengolo Gwe_Here Her_Du Du_Kerzu Ker'.split('_'), i;
<ide> for (i = 0; i < expected.length; i++) {
<ide> assert.equal(moment([2011, i, 1]).format('MMMM MMM'), expected[i], expected[i]);
<ide> }
<ide> });
<ide>
<del>test("format week", function (assert) {
<add>test('format week', function (assert) {
<ide> moment.locale('br');
<ide> var expected = 'Sul Sul Su_Lun Lun Lu_Meurzh Meu Me_Merc\'her Mer Mer_Yaou Yao Ya_Gwener Gwe Gw_Sadorn Sad Sa'.split('_'), i;
<ide> for (i = 0; i < expected.length; i++) {
<ide> assert.equal(moment([2011, 0, 2 + i]).format('dddd ddd dd'), expected[i], expected[i]);
<ide> }
<ide> });
<ide>
<del>test("from", function (assert) {
<add>test('from', function (assert) {
<ide> moment.locale('br');
<ide> var start = moment([2007, 1, 28]);
<ide> assert.equal(start.from(moment([2007, 1, 28]).add({s: 44}), true), 'un nebeud segondennoù', '44 seconds = a few seconds');
<ide> test("from", function (assert) {
<ide> assert.equal(start.from(moment([2007, 1, 28]).add({y: 5}), true), '5 bloaz', '5 years = 5 years');
<ide> });
<ide>
<del>test("suffix", function (assert) {
<add>test('suffix', function (assert) {
<ide> moment.locale('br');
<ide> assert.equal(moment(30000).from(0), 'a-benn un nebeud segondennoù', 'prefix');
<ide> assert.equal(moment(0).from(30000), 'un nebeud segondennoù \'zo', 'suffix');
<ide> });
<ide>
<del>test("now from now", function (assert) {
<add>test('now from now', function (assert) {
<ide> moment.locale('br');
<ide> assert.equal(moment().fromNow(), 'un nebeud segondennoù \'zo', 'now from now should display as in the past');
<ide> });
<ide>
<del>test("fromNow", function (assert) {
<add>test('fromNow', function (assert) {
<ide> moment.locale('br');
<ide> assert.equal(moment().add({s: 30}).fromNow(), 'a-benn un nebeud segondennoù', 'in a few seconds');
<ide> assert.equal(moment().add({d: 5}).fromNow(), 'a-benn 5 devezh', 'in 5 days');
<ide> });
<ide>
<del>test("calendar day", function (assert) {
<add>test('calendar day', function (assert) {
<ide> moment.locale('br');
<ide>
<ide> var a = moment().hours(2).minutes(0).seconds(0);
<ide> test("calendar day", function (assert) {
<ide> assert.equal(moment(a).subtract({d: 1}).calendar(), 'Dec\'h da 2e00 AM', 'yesterday at the same time');
<ide> });
<ide>
<del>test("calendar next week", function (assert) {
<add>test('calendar next week', function (assert) {
<ide> moment.locale('br');
<ide>
<ide> var i, m;
<ide> test("calendar next week", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("calendar last week", function (assert) {
<add>test('calendar last week', function (assert) {
<ide> moment.locale('br');
<ide>
<ide> var i, m;
<ide> test("calendar last week", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("calendar all else", function (assert) {
<add>test('calendar all else', function (assert) {
<ide> moment.locale('br');
<ide> var weeksAgo = moment().subtract({w: 1}),
<ide> weeksFromNow = moment().add({w: 1});
<ide> test("calendar all else", function (assert) {
<ide> assert.equal(weeksFromNow.calendar(), weeksFromNow.format('L'), 'in 2 weeks');
<ide> });
<ide>
<del>test("special mutations for years", function (assert) {
<add>test('special mutations for years', function (assert) {
<ide> moment.locale('br');
<ide> var start = moment([2007, 1, 28]);
<ide> assert.equal(start.from(moment([2007, 1, 28]).add({y: 1}), true), 'ur bloaz', 'mutation 1 year');
<ide> test("special mutations for years", function (assert) {
<ide> assert.equal(start.from(moment([2007, 1, 28]).add({y: 261}), true), '261 bloaz', 'mutation 261 years');
<ide> });
<ide>
<del>test("lenient ordinal parsing", function (assert) {
<add>test('lenient ordinal parsing', function (assert) {
<ide> var i, ordinalStr, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> ordinalStr = moment([2014, 0, i]).format('YYYY MM Do');
<ide> test("lenient ordinal parsing", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("lenient ordinal parsing of number", function (assert) {
<add>test('lenient ordinal parsing of number', function (assert) {
<ide> var i, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> testMoment = moment('2014 01 ' + i, 'YYYY MM Do');
<ide> test("lenient ordinal parsing of number", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("strict ordinal parsing", function (assert) {
<add>test('strict ordinal parsing', function (assert) {
<ide> var i, ordinalStr, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> ordinalStr = moment([2014, 0, i]).format('YYYY MM Do');
<ide><path>src/test/locale/bs.js
<del>import {localeModule, test} from "../qunit";
<del>import {moment} from "../../moment";
<del>localeModule("bs");
<add>import {localeModule, test} from '../qunit';
<add>import {moment} from '../../moment';
<add>localeModule('bs');
<ide>
<del>test("parse", function (assert) {
<add>test('parse', function (assert) {
<ide> var tests = 'januar jan._februar feb._mart mar._april apr._maj maj._juni jun._juli jul._august aug._septembar sep._oktobar okt._novembar nov._decembar dec.'.split('_'), i;
<ide> function equalTest(input, mmm, i) {
<ide> assert.equal(moment(input, mmm).month(), i, input + ' should be month ' + (i + 1));
<ide> test("parse", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("format", function (assert) {
<add>test('format', function (assert) {
<ide> var a = [
<ide> ['dddd, Do MMMM YYYY, h:mm:ss a', 'nedjelja, 14. februar 2010, 3:25:50 pm'],
<ide> ['ddd, hA', 'ned., 3PM'],
<ide> test("format", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("format ordinal", function (assert) {
<add>test('format ordinal', function (assert) {
<ide> assert.equal(moment([2011, 0, 1]).format('DDDo'), '1.', '1.');
<ide> assert.equal(moment([2011, 0, 2]).format('DDDo'), '2.', '2.');
<ide> assert.equal(moment([2011, 0, 3]).format('DDDo'), '3.', '3.');
<ide> test("format ordinal", function (assert) {
<ide> assert.equal(moment([2011, 0, 31]).format('DDDo'), '31.', '31.');
<ide> });
<ide>
<del>test("format month", function (assert) {
<add>test('format month', function (assert) {
<ide> var expected = 'januar jan._februar feb._mart mar._april apr._maj maj._juni jun._juli jul._august aug._septembar sep._oktobar okt._novembar nov._decembar dec.'.split('_'), i;
<ide> for (i = 0; i < expected.length; i++) {
<ide> assert.equal(moment([2011, i, 1]).format('MMMM MMM'), expected[i], expected[i]);
<ide> }
<ide> });
<ide>
<del>test("format week", function (assert) {
<add>test('format week', function (assert) {
<ide> var expected = 'nedjelja ned. ne_ponedjeljak pon. po_utorak uto. ut_srijeda sri. sr_četvrtak čet. če_petak pet. pe_subota sub. su'.split('_'), i;
<ide> for (i = 0; i < expected.length; i++) {
<ide> assert.equal(moment([2011, 0, 2 + i]).format('dddd ddd dd'), expected[i], expected[i]);
<ide> }
<ide> });
<ide>
<del>test("from", function (assert) {
<add>test('from', function (assert) {
<ide> var start = moment([2007, 1, 28]);
<ide> assert.equal(start.from(moment([2007, 1, 28]).add({s: 44}), true), 'par sekundi', '44 seconds = a few seconds');
<ide> assert.equal(start.from(moment([2007, 1, 28]).add({s: 45}), true), 'jedna minuta', '45 seconds = a minute');
<ide> test("from", function (assert) {
<ide> assert.equal(start.from(moment([2007, 1, 28]).add({y: 5}), true), '5 godina', '5 years = 5 years');
<ide> });
<ide>
<del>test("suffix", function (assert) {
<add>test('suffix', function (assert) {
<ide> assert.equal(moment(30000).from(0), 'za par sekundi', 'prefix');
<ide> assert.equal(moment(0).from(30000), 'prije par sekundi', 'prefix');
<ide> });
<ide>
<del>test("now from now", function (assert) {
<add>test('now from now', function (assert) {
<ide> assert.equal(moment().fromNow(), 'prije par sekundi', 'now from now should display as in the past');
<ide> });
<ide>
<del>test("fromNow", function (assert) {
<add>test('fromNow', function (assert) {
<ide> assert.equal(moment().add({s: 30}).fromNow(), 'za par sekundi', 'in a few seconds');
<ide> assert.equal(moment().add({d: 5}).fromNow(), 'za 5 dana', 'in 5 days');
<ide> });
<ide>
<del>test("calendar day", function (assert) {
<add>test('calendar day', function (assert) {
<ide> var a = moment().hours(2).minutes(0).seconds(0);
<ide>
<ide> assert.equal(moment(a).calendar(), 'danas u 2:00', 'today at the same time');
<ide> test("calendar day", function (assert) {
<ide> assert.equal(moment(a).subtract({d: 1}).calendar(), 'jučer u 2:00', 'yesterday at the same time');
<ide> });
<ide>
<del>test("calendar next week", function (assert) {
<add>test('calendar next week', function (assert) {
<ide> var i, m;
<ide>
<ide> function makeFormat(d) {
<ide> test("calendar next week", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("calendar last week", function (assert) {
<add>test('calendar last week', function (assert) {
<ide> var i, m;
<ide>
<ide> function makeFormat(d) {
<ide> test("calendar last week", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("calendar all else", function (assert) {
<add>test('calendar all else', function (assert) {
<ide> var weeksAgo = moment().subtract({w: 1}),
<ide> weeksFromNow = moment().add({w: 1});
<ide>
<ide> test("calendar all else", function (assert) {
<ide> assert.equal(weeksFromNow.calendar(), weeksFromNow.format('L'), 'in 2 weeks');
<ide> });
<ide>
<del>test("weeks year starting sunday", function (assert) {
<add>test('weeks year starting sunday', function (assert) {
<ide> assert.equal(moment([2011, 11, 26]).week(), 1, 'Dec 26 2011 should be week 1');
<ide> assert.equal(moment([2012, 0, 1]).week(), 1, 'Jan 1 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 2]).week(), 2, 'Jan 2 2012 should be week 2');
<ide> assert.equal(moment([2012, 0, 8]).week(), 2, 'Jan 8 2012 should be week 2');
<ide> assert.equal(moment([2012, 0, 9]).week(), 3, 'Jan 9 2012 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting monday", function (assert) {
<add>test('weeks year starting monday', function (assert) {
<ide> assert.equal(moment([2007, 0, 1]).week(), 1, 'Jan 1 2007 should be week 1');
<ide> assert.equal(moment([2007, 0, 7]).week(), 1, 'Jan 7 2007 should be week 1');
<ide> assert.equal(moment([2007, 0, 8]).week(), 2, 'Jan 8 2007 should be week 2');
<ide> assert.equal(moment([2007, 0, 14]).week(), 2, 'Jan 14 2007 should be week 2');
<ide> assert.equal(moment([2007, 0, 15]).week(), 3, 'Jan 15 2007 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting tuesday", function (assert) {
<add>test('weeks year starting tuesday', function (assert) {
<ide> assert.equal(moment([2007, 11, 31]).week(), 1, 'Dec 31 2007 should be week 1');
<ide> assert.equal(moment([2008, 0, 1]).week(), 1, 'Jan 1 2008 should be week 1');
<ide> assert.equal(moment([2008, 0, 6]).week(), 1, 'Jan 6 2008 should be week 1');
<ide> test("weeks year starting tuesday", function (assert) {
<ide> assert.equal(moment([2008, 0, 14]).week(), 3, 'Jan 14 2008 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting wednesday", function (assert) {
<add>test('weeks year starting wednesday', function (assert) {
<ide> assert.equal(moment([2002, 11, 30]).week(), 1, 'Dec 30 2002 should be week 1');
<ide> assert.equal(moment([2003, 0, 1]).week(), 1, 'Jan 1 2003 should be week 1');
<ide> assert.equal(moment([2003, 0, 5]).week(), 1, 'Jan 5 2003 should be week 1');
<ide> test("weeks year starting wednesday", function (assert) {
<ide> assert.equal(moment([2003, 0, 13]).week(), 3, 'Jan 13 2003 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting thursday", function (assert) {
<add>test('weeks year starting thursday', function (assert) {
<ide> assert.equal(moment([2008, 11, 29]).week(), 1, 'Dec 29 2008 should be week 1');
<ide> assert.equal(moment([2009, 0, 1]).week(), 1, 'Jan 1 2009 should be week 1');
<ide> assert.equal(moment([2009, 0, 4]).week(), 1, 'Jan 4 2009 should be week 1');
<ide> test("weeks year starting thursday", function (assert) {
<ide> assert.equal(moment([2009, 0, 12]).week(), 3, 'Jan 12 2009 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting friday", function (assert) {
<add>test('weeks year starting friday', function (assert) {
<ide> assert.equal(moment([2009, 11, 28]).week(), 1, 'Dec 28 2009 should be week 1');
<ide> assert.equal(moment([2010, 0, 1]).week(), 1, 'Jan 1 2010 should be week 1');
<ide> assert.equal(moment([2010, 0, 3]).week(), 1, 'Jan 3 2010 should be week 1');
<ide> test("weeks year starting friday", function (assert) {
<ide> assert.equal(moment([2010, 0, 11]).week(), 3, 'Jan 11 2010 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting saturday", function (assert) {
<add>test('weeks year starting saturday', function (assert) {
<ide> assert.equal(moment([2010, 11, 27]).week(), 1, 'Dec 27 2010 should be week 1');
<ide> assert.equal(moment([2011, 0, 1]).week(), 1, 'Jan 1 2011 should be week 1');
<ide> assert.equal(moment([2011, 0, 2]).week(), 1, 'Jan 2 2011 should be week 1');
<ide> test("weeks year starting saturday", function (assert) {
<ide> assert.equal(moment([2011, 0, 10]).week(), 3, 'Jan 10 2011 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting sunday formatted", function (assert) {
<add>test('weeks year starting sunday formatted', function (assert) {
<ide> assert.equal(moment([2011, 11, 26]).format('w ww wo'), '1 01 1.', 'Dec 26 2011 should be week 1');
<ide> assert.equal(moment([2012, 0, 1]).format('w ww wo'), '1 01 1.', 'Jan 1 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 2]).format('w ww wo'), '2 02 2.', 'Jan 2 2012 should be week 2');
<ide> assert.equal(moment([2012, 0, 8]).format('w ww wo'), '2 02 2.', 'Jan 8 2012 should be week 2');
<ide> assert.equal(moment([2012, 0, 9]).format('w ww wo'), '3 03 3.', 'Jan 9 2012 should be week 3');
<ide> });
<ide>
<del>test("lenient ordinal parsing", function (assert) {
<add>test('lenient ordinal parsing', function (assert) {
<ide> var i, ordinalStr, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> ordinalStr = moment([2014, 0, i]).format('YYYY MM Do');
<ide> test("lenient ordinal parsing", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("lenient ordinal parsing of number", function (assert) {
<add>test('lenient ordinal parsing of number', function (assert) {
<ide> var i, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> testMoment = moment('2014 01 ' + i, 'YYYY MM Do');
<ide> test("lenient ordinal parsing of number", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("strict ordinal parsing", function (assert) {
<add>test('strict ordinal parsing', function (assert) {
<ide> var i, ordinalStr, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> ordinalStr = moment([2014, 0, i]).format('YYYY MM Do');
<ide><path>src/test/locale/ca.js
<del>import {localeModule, test} from "../qunit";
<del>import {moment} from "../../moment";
<del>localeModule("ca");
<add>import {localeModule, test} from '../qunit';
<add>import {moment} from '../../moment';
<add>localeModule('ca');
<ide>
<del>test("parse", function (assert) {
<add>test('parse', function (assert) {
<ide> var tests = 'gener gen._febrer febr._març mar._abril abr._maig mai._juny jun._juliol jul._agost ag._setembre set._octubre oct._novembre nov._desembre des.'.split('_'), i;
<ide> function equalTest(input, mmm, i) {
<ide> assert.equal(moment(input, mmm).month(), i, input + ' should be month ' + (i + 1));
<ide> test("parse", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("format", function (assert) {
<add>test('format', function (assert) {
<ide> var a = [
<ide> ['dddd, Do MMMM YYYY, h:mm:ss a', 'diumenge, 14è febrer 2010, 3:25:50 pm'],
<ide> ['ddd, hA', 'dg., 3PM'],
<ide> test("format", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("format ordinal", function (assert) {
<add>test('format ordinal', function (assert) {
<ide> assert.equal(moment([2011, 0, 1]).format('DDDo'), '1r', '1r');
<ide> assert.equal(moment([2011, 0, 2]).format('DDDo'), '2n', '2n');
<ide> assert.equal(moment([2011, 0, 3]).format('DDDo'), '3r', '3r');
<ide> test("format ordinal", function (assert) {
<ide> assert.equal(moment([2011, 0, 31]).format('DDDo'), '31è', '31è');
<ide> });
<ide>
<del>test("format month", function (assert) {
<add>test('format month', function (assert) {
<ide> var expected = 'gener gen._febrer febr._març mar._abril abr._maig mai._juny jun._juliol jul._agost ag._setembre set._octubre oct._novembre nov._desembre des.'.split('_'), i;
<ide> for (i = 0; i < expected.length; i++) {
<ide> assert.equal(moment([2011, i, 1]).format('MMMM MMM'), expected[i], expected[i]);
<ide> }
<ide> });
<ide>
<del>test("format week", function (assert) {
<add>test('format week', function (assert) {
<ide> var expected = 'diumenge dg. Dg_dilluns dl. Dl_dimarts dt. Dt_dimecres dc. Dc_dijous dj. Dj_divendres dv. Dv_dissabte ds. Ds'.split('_'), i;
<ide> for (i = 0; i < expected.length; i++) {
<ide> assert.equal(moment([2011, 0, 2 + i]).format('dddd ddd dd'), expected[i], expected[i]);
<ide> }
<ide> });
<ide>
<del>test("from", function (assert) {
<add>test('from', function (assert) {
<ide> var start = moment([2007, 1, 28]);
<ide> assert.equal(start.from(moment([2007, 1, 28]).add({s: 44}), true), 'uns segons', '44 seconds = a few seconds');
<ide> assert.equal(start.from(moment([2007, 1, 28]).add({s: 45}), true), 'un minut', '45 seconds = a minute');
<ide> test("from", function (assert) {
<ide> assert.equal(start.from(moment([2007, 1, 28]).add({y: 5}), true), '5 anys', '5 years = 5 years');
<ide> });
<ide>
<del>test("suffix", function (assert) {
<add>test('suffix', function (assert) {
<ide> assert.equal(moment(30000).from(0), 'en uns segons', 'prefix');
<ide> assert.equal(moment(0).from(30000), 'fa uns segons', 'suffix');
<ide> });
<ide>
<del>test("now from now", function (assert) {
<add>test('now from now', function (assert) {
<ide> assert.equal(moment().fromNow(), 'fa uns segons', 'now from now should display as in the past');
<ide> });
<ide>
<del>test("fromNow", function (assert) {
<add>test('fromNow', function (assert) {
<ide> assert.equal(moment().add({s: 30}).fromNow(), 'en uns segons', 'en uns segons');
<ide> assert.equal(moment().add({d: 5}).fromNow(), 'en 5 dies', 'en 5 dies');
<ide> });
<ide>
<del>test("calendar day", function (assert) {
<add>test('calendar day', function (assert) {
<ide> var a = moment().hours(2).minutes(0).seconds(0);
<ide>
<ide> assert.equal(moment(a).calendar(), 'avui a les 2:00', 'today at the same time');
<ide> test("calendar day", function (assert) {
<ide> assert.equal(moment(a).subtract({d: 1}).calendar(), 'ahir a les 2:00', 'yesterday at the same time');
<ide> });
<ide>
<del>test("calendar next week", function (assert) {
<add>test('calendar next week', function (assert) {
<ide> var i, m;
<ide> for (i = 2; i < 7; i++) {
<ide> m = moment().add({d: i});
<ide> test("calendar next week", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("calendar last week", function (assert) {
<add>test('calendar last week', function (assert) {
<ide> var i, m;
<ide> for (i = 2; i < 7; i++) {
<ide> m = moment().subtract({d: i});
<ide> test("calendar last week", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("calendar all else", function (assert) {
<add>test('calendar all else', function (assert) {
<ide> var weeksAgo = moment().subtract({w: 1}),
<ide> weeksFromNow = moment().add({w: 1});
<ide>
<ide> test("calendar all else", function (assert) {
<ide> assert.equal(weeksFromNow.calendar(), weeksFromNow.format('L'), 'in 2 weeks');
<ide> });
<ide>
<del>test("weeks year starting sunday", function (assert) {
<add>test('weeks year starting sunday', function (assert) {
<ide> assert.equal(moment([2012, 0, 1]).week(), 52, 'Jan 1 2012 should be week 52');
<ide> assert.equal(moment([2012, 0, 2]).week(), 1, 'Jan 2 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 8]).week(), 1, 'Jan 8 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 9]).week(), 2, 'Jan 9 2012 should be week 2');
<ide> assert.equal(moment([2012, 0, 15]).week(), 2, 'Jan 15 2012 should be week 2');
<ide> });
<ide>
<del>test("weeks year starting monday", function (assert) {
<add>test('weeks year starting monday', function (assert) {
<ide> assert.equal(moment([2007, 0, 1]).week(), 1, 'Jan 1 2007 should be week 1');
<ide> assert.equal(moment([2007, 0, 7]).week(), 1, 'Jan 7 2007 should be week 1');
<ide> assert.equal(moment([2007, 0, 8]).week(), 2, 'Jan 8 2007 should be week 2');
<ide> assert.equal(moment([2007, 0, 14]).week(), 2, 'Jan 14 2007 should be week 2');
<ide> assert.equal(moment([2007, 0, 15]).week(), 3, 'Jan 15 2007 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting tuesday", function (assert) {
<add>test('weeks year starting tuesday', function (assert) {
<ide> assert.equal(moment([2007, 11, 31]).week(), 1, 'Dec 31 2007 should be week 1');
<ide> assert.equal(moment([2008, 0, 1]).week(), 1, 'Jan 1 2008 should be week 1');
<ide> assert.equal(moment([2008, 0, 6]).week(), 1, 'Jan 6 2008 should be week 1');
<ide> test("weeks year starting tuesday", function (assert) {
<ide> assert.equal(moment([2008, 0, 14]).week(), 3, 'Jan 14 2008 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting wednesday", function (assert) {
<add>test('weeks year starting wednesday', function (assert) {
<ide> assert.equal(moment([2002, 11, 30]).week(), 1, 'Dec 30 2002 should be week 1');
<ide> assert.equal(moment([2003, 0, 1]).week(), 1, 'Jan 1 2003 should be week 1');
<ide> assert.equal(moment([2003, 0, 5]).week(), 1, 'Jan 5 2003 should be week 1');
<ide> test("weeks year starting wednesday", function (assert) {
<ide> assert.equal(moment([2003, 0, 13]).week(), 3, 'Jan 13 2003 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting thursday", function (assert) {
<add>test('weeks year starting thursday', function (assert) {
<ide> assert.equal(moment([2008, 11, 29]).week(), 1, 'Dec 29 2008 should be week 1');
<ide> assert.equal(moment([2009, 0, 1]).week(), 1, 'Jan 1 2009 should be week 1');
<ide> assert.equal(moment([2009, 0, 4]).week(), 1, 'Jan 4 2009 should be week 1');
<ide> test("weeks year starting thursday", function (assert) {
<ide> assert.equal(moment([2009, 0, 13]).week(), 3, 'Jan 12 2009 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting friday", function (assert) {
<add>test('weeks year starting friday', function (assert) {
<ide> assert.equal(moment([2009, 11, 28]).week(), 53, 'Dec 28 2009 should be week 53');
<ide> assert.equal(moment([2010, 0, 1]).week(), 53, 'Jan 1 2010 should be week 53');
<ide> assert.equal(moment([2010, 0, 3]).week(), 53, 'Jan 3 2010 should be week 53');
<ide> test("weeks year starting friday", function (assert) {
<ide> assert.equal(moment([2010, 0, 11]).week(), 2, 'Jan 11 2010 should be week 2');
<ide> });
<ide>
<del>test("weeks year starting saturday", function (assert) {
<add>test('weeks year starting saturday', function (assert) {
<ide> assert.equal(moment([2010, 11, 27]).week(), 52, 'Dec 27 2010 should be week 52');
<ide> assert.equal(moment([2011, 0, 1]).week(), 52, 'Jan 1 2011 should be week 52');
<ide> assert.equal(moment([2011, 0, 2]).week(), 52, 'Jan 2 2011 should be week 52');
<ide> test("weeks year starting saturday", function (assert) {
<ide> assert.equal(moment([2011, 0, 10]).week(), 2, 'Jan 10 2011 should be week 2');
<ide> });
<ide>
<del>test("weeks year starting sunday formatted", function (assert) {
<add>test('weeks year starting sunday formatted', function (assert) {
<ide> assert.equal(moment([2012, 0, 1]).format('w ww wo'), '52 52 52a', 'Jan 1 2012 should be week 52');
<ide> assert.equal(moment([2012, 0, 2]).format('w ww wo'), '1 01 1a', 'Jan 2 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 8]).format('w ww wo'), '1 01 1a', 'Jan 8 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 9]).format('w ww wo'), '2 02 2a', 'Jan 9 2012 should be week 2');
<ide> assert.equal(moment([2012, 0, 15]).format('w ww wo'), '2 02 2a', 'Jan 15 2012 should be week 2');
<ide> });
<ide>
<del>test("lenient ordinal parsing", function (assert) {
<add>test('lenient ordinal parsing', function (assert) {
<ide> var i, ordinalStr, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> ordinalStr = moment([2014, 0, i]).format('YYYY MM Do');
<ide> test("lenient ordinal parsing", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("lenient ordinal parsing of number", function (assert) {
<add>test('lenient ordinal parsing of number', function (assert) {
<ide> var i, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> testMoment = moment('2014 01 ' + i, 'YYYY MM Do');
<ide> test("lenient ordinal parsing of number", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("strict ordinal parsing", function (assert) {
<add>test('strict ordinal parsing', function (assert) {
<ide> var i, ordinalStr, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> ordinalStr = moment([2014, 0, i]).format('YYYY MM Do');
<ide><path>src/test/locale/cs.js
<del>import {localeModule, test} from "../qunit";
<del>import {moment} from "../../moment";
<del>localeModule("cs");
<add>import {localeModule, test} from '../qunit';
<add>import {moment} from '../../moment';
<add>localeModule('cs');
<ide>
<del>test("parse", function (assert) {
<add>test('parse', function (assert) {
<ide> var tests = 'leden led_únor úno_březen bře_duben dub_květen kvě_červen čvn_červenec čvc_srpen srp_září zář_říjen říj_listopad lis_prosinec pro'.split('_'), i;
<ide> function equalTest(input, mmm, monthIndex) {
<ide> assert.equal(moment(input, mmm).month(), monthIndex, input + ' should be month ' + (monthIndex + 1));
<ide> test("parse", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("format", function (assert) {
<add>test('format', function (assert) {
<ide> var a = [
<ide> ['dddd, MMMM Do YYYY, h:mm:ss', 'neděle, únor 14. 2010, 3:25:50'],
<ide> ['ddd, h', 'ne, 3'],
<ide> test("format", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("format ordinal", function (assert) {
<add>test('format ordinal', function (assert) {
<ide> assert.equal(moment([2011, 0, 1]).format('DDDo'), '1.', '1.');
<ide> assert.equal(moment([2011, 0, 2]).format('DDDo'), '2.', '2.');
<ide> assert.equal(moment([2011, 0, 3]).format('DDDo'), '3.', '3.');
<ide> test("format ordinal", function (assert) {
<ide> assert.equal(moment([2011, 0, 31]).format('DDDo'), '31.', '31.');
<ide> });
<ide>
<del>test("format month", function (assert) {
<add>test('format month', function (assert) {
<ide> var expected = 'leden led_únor úno_březen bře_duben dub_květen kvě_červen čvn_červenec čvc_srpen srp_září zář_říjen říj_listopad lis_prosinec pro'.split('_'), i;
<ide> for (i = 0; i < expected.length; i++) {
<ide> assert.equal(moment([2011, i, 1]).format('MMMM MMM'), expected[i], expected[i]);
<ide> }
<ide> });
<ide>
<del>test("format week", function (assert) {
<add>test('format week', function (assert) {
<ide> var expected = 'neděle ne ne_pondělí po po_úterý út út_středa st st_čtvrtek čt čt_pátek pá pá_sobota so so'.split('_'), i;
<ide> for (i = 0; i < expected.length; i++) {
<ide> assert.equal(moment([2011, 0, 2 + i]).format('dddd ddd dd'), expected[i], expected[i]);
<ide> }
<ide> });
<ide>
<del>test("from", function (assert) {
<add>test('from', function (assert) {
<ide> var start = moment([2007, 1, 28]);
<ide> assert.equal(start.from(moment([2007, 1, 28]).add({s: 44}), true), 'pár sekund', '44 seconds = a few seconds');
<ide> assert.equal(start.from(moment([2007, 1, 28]).add({s: 45}), true), 'minuta', '45 seconds = a minute');
<ide> test("from", function (assert) {
<ide> assert.equal(start.from(moment([2007, 1, 28]).add({y: 5}), true), '5 let', '5 years = 5 years');
<ide> });
<ide>
<del>test("suffix", function (assert) {
<add>test('suffix', function (assert) {
<ide> assert.equal(moment(30000).from(0), 'za pár sekund', 'prefix');
<ide> assert.equal(moment(0).from(30000), 'před pár sekundami', 'suffix');
<ide> });
<ide>
<del>test("now from now", function (assert) {
<add>test('now from now', function (assert) {
<ide> assert.equal(moment().fromNow(), 'před pár sekundami', 'now from now should display as in the past');
<ide> });
<ide>
<del>test("fromNow (future)", function (assert) {
<add>test('fromNow (future)', function (assert) {
<ide> assert.equal(moment().add({s: 30}).fromNow(), 'za pár sekund', 'in a few seconds');
<ide> assert.equal(moment().add({m: 1}).fromNow(), 'za minutu', 'in a minute');
<ide> assert.equal(moment().add({m: 3}).fromNow(), 'za 3 minuty', 'in 3 minutes');
<ide> test("fromNow (future)", function (assert) {
<ide> assert.equal(moment().add({y: 10}).fromNow(), 'za 10 let', 'in 10 years');
<ide> });
<ide>
<del>test("fromNow (past)", function (assert) {
<add>test('fromNow (past)', function (assert) {
<ide> assert.equal(moment().subtract({s: 30}).fromNow(), 'před pár sekundami', 'a few seconds ago');
<ide> assert.equal(moment().subtract({m: 1}).fromNow(), 'před minutou', 'a minute ago');
<ide> assert.equal(moment().subtract({m: 3}).fromNow(), 'před 3 minutami', '3 minutes ago');
<ide> test("fromNow (past)", function (assert) {
<ide> assert.equal(moment().subtract({y: 10}).fromNow(), 'před 10 lety', '10 years ago');
<ide> });
<ide>
<del>test("calendar day", function (assert) {
<add>test('calendar day', function (assert) {
<ide> var a = moment().hours(2).minutes(0).seconds(0);
<ide>
<ide> assert.equal(moment(a).calendar(), 'dnes v 2:00', 'today at the same time');
<ide> test("calendar day", function (assert) {
<ide> assert.equal(moment(a).subtract({d: 1}).calendar(), 'včera v 2:00', 'yesterday at the same time');
<ide> });
<ide>
<del>test("calendar next week", function (assert) {
<add>test('calendar next week', function (assert) {
<ide> var i, m, nextDay;
<ide> for (i = 2; i < 7; i++) {
<ide> m = moment().add({d: i});
<ide> test("calendar next week", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("calendar last week", function (assert) {
<add>test('calendar last week', function (assert) {
<ide> var i, m, lastDay;
<ide> for (i = 2; i < 7; i++) {
<ide> m = moment().subtract({d: i});
<ide> test("calendar last week", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("calendar all else", function (assert) {
<add>test('calendar all else', function (assert) {
<ide> var weeksAgo = moment().subtract({w: 1}),
<ide> weeksFromNow = moment().add({w: 1});
<ide>
<ide> test("calendar all else", function (assert) {
<ide> assert.equal(weeksFromNow.calendar(), weeksFromNow.format('L'), 'in 2 weeks');
<ide> });
<ide>
<del>test("humanize duration", function (assert) {
<add>test('humanize duration', function (assert) {
<ide> assert.equal(moment.duration(1, 'minutes').humanize(), 'minuta', 'a minute (future)');
<ide> assert.equal(moment.duration(1, 'minutes').humanize(true), 'za minutu', 'in a minute');
<ide> assert.equal(moment.duration(-1, 'minutes').humanize(), 'minuta', 'a minute (past)');
<ide> assert.equal(moment.duration(-1, 'minutes').humanize(true), 'před minutou', 'a minute ago');
<ide> });
<ide>
<del>test("weeks year starting sunday", function (assert) {
<add>test('weeks year starting sunday', function (assert) {
<ide> assert.equal(moment([2012, 0, 1]).week(), 52, 'Jan 1 2012 should be week 52');
<ide> assert.equal(moment([2012, 0, 2]).week(), 1, 'Jan 2 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 8]).week(), 1, 'Jan 8 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 9]).week(), 2, 'Jan 9 2012 should be week 2');
<ide> assert.equal(moment([2012, 0, 15]).week(), 2, 'Jan 15 2012 should be week 2');
<ide> });
<ide>
<del>test("weeks year starting monday", function (assert) {
<add>test('weeks year starting monday', function (assert) {
<ide> assert.equal(moment([2007, 0, 1]).week(), 1, 'Jan 1 2007 should be week 1');
<ide> assert.equal(moment([2007, 0, 7]).week(), 1, 'Jan 7 2007 should be week 1');
<ide> assert.equal(moment([2007, 0, 8]).week(), 2, 'Jan 8 2007 should be week 2');
<ide> assert.equal(moment([2007, 0, 14]).week(), 2, 'Jan 14 2007 should be week 2');
<ide> assert.equal(moment([2007, 0, 15]).week(), 3, 'Jan 15 2007 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting tuesday", function (assert) {
<add>test('weeks year starting tuesday', function (assert) {
<ide> assert.equal(moment([2007, 11, 31]).week(), 1, 'Dec 31 2007 should be week 1');
<ide> assert.equal(moment([2008, 0, 1]).week(), 1, 'Jan 1 2008 should be week 1');
<ide> assert.equal(moment([2008, 0, 6]).week(), 1, 'Jan 6 2008 should be week 1');
<ide> test("weeks year starting tuesday", function (assert) {
<ide> assert.equal(moment([2008, 0, 14]).week(), 3, 'Jan 14 2008 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting wednesday", function (assert) {
<add>test('weeks year starting wednesday', function (assert) {
<ide> assert.equal(moment([2002, 11, 30]).week(), 1, 'Dec 30 2002 should be week 1');
<ide> assert.equal(moment([2003, 0, 1]).week(), 1, 'Jan 1 2003 should be week 1');
<ide> assert.equal(moment([2003, 0, 5]).week(), 1, 'Jan 5 2003 should be week 1');
<ide> test("weeks year starting wednesday", function (assert) {
<ide> assert.equal(moment([2003, 0, 13]).week(), 3, 'Jan 13 2003 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting thursday", function (assert) {
<add>test('weeks year starting thursday', function (assert) {
<ide> assert.equal(moment([2008, 11, 29]).week(), 1, 'Dec 29 2008 should be week 1');
<ide> assert.equal(moment([2009, 0, 1]).week(), 1, 'Jan 1 2009 should be week 1');
<ide> assert.equal(moment([2009, 0, 4]).week(), 1, 'Jan 4 2009 should be week 1');
<ide> test("weeks year starting thursday", function (assert) {
<ide> assert.equal(moment([2009, 0, 13]).week(), 3, 'Jan 12 2009 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting friday", function (assert) {
<add>test('weeks year starting friday', function (assert) {
<ide> assert.equal(moment([2009, 11, 28]).week(), 53, 'Dec 28 2009 should be week 53');
<ide> assert.equal(moment([2010, 0, 1]).week(), 53, 'Jan 1 2010 should be week 53');
<ide> assert.equal(moment([2010, 0, 3]).week(), 53, 'Jan 3 2010 should be week 53');
<ide> test("weeks year starting friday", function (assert) {
<ide> assert.equal(moment([2010, 0, 11]).week(), 2, 'Jan 11 2010 should be week 2');
<ide> });
<ide>
<del>test("weeks year starting saturday", function (assert) {
<add>test('weeks year starting saturday', function (assert) {
<ide> assert.equal(moment([2010, 11, 27]).week(), 52, 'Dec 27 2010 should be week 52');
<ide> assert.equal(moment([2011, 0, 1]).week(), 52, 'Jan 1 2011 should be week 52');
<ide> assert.equal(moment([2011, 0, 2]).week(), 52, 'Jan 2 2011 should be week 52');
<ide> test("weeks year starting saturday", function (assert) {
<ide> assert.equal(moment([2011, 0, 10]).week(), 2, 'Jan 10 2011 should be week 2');
<ide> });
<ide>
<del>test("weeks year starting sunday formatted", function (assert) {
<add>test('weeks year starting sunday formatted', function (assert) {
<ide> assert.equal(moment([2012, 0, 1]).format('w ww wo'), '52 52 52.', 'Jan 1 2012 should be week 52');
<ide> assert.equal(moment([2012, 0, 2]).format('w ww wo'), '1 01 1.', 'Jan 2 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 8]).format('w ww wo'), '1 01 1.', 'Jan 8 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 9]).format('w ww wo'), '2 02 2.', 'Jan 9 2012 should be week 2');
<ide> assert.equal(moment([2012, 0, 15]).format('w ww wo'), '2 02 2.', 'Jan 15 2012 should be week 2');
<ide> });
<ide>
<del>test("lenient ordinal parsing", function (assert) {
<add>test('lenient ordinal parsing', function (assert) {
<ide> var i, ordinalStr, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> ordinalStr = moment([2014, 0, i]).format('YYYY MM Do');
<ide> test("lenient ordinal parsing", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("lenient ordinal parsing of number", function (assert) {
<add>test('lenient ordinal parsing of number', function (assert) {
<ide> var i, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> testMoment = moment('2014 01 ' + i, 'YYYY MM Do');
<ide> test("lenient ordinal parsing of number", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("strict ordinal parsing", function (assert) {
<add>test('strict ordinal parsing', function (assert) {
<ide> var i, ordinalStr, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> ordinalStr = moment([2014, 0, i]).format('YYYY MM Do');
<ide><path>src/test/locale/cv.js
<del>import {localeModule, test} from "../qunit";
<del>import {moment} from "../../moment";
<del>localeModule("cv");
<add>import {localeModule, test} from '../qunit';
<add>import {moment} from '../../moment';
<add>localeModule('cv');
<ide>
<del>test("parse", function (assert) {
<add>test('parse', function (assert) {
<ide> var tests = 'кăрлач кăр_нарăс нар_пуш пуш_ака ака_май май_çĕртме çĕр_утă утă_çурла çур_авăн ав_юпа юпа_чӳк чӳк_раштав раш'.split('_'), i;
<ide> function equalTest(input, mmm, i) {
<ide> assert.equal(moment(input, mmm).month(), i, input + ' should be month ' + (i + 1));
<ide> test("parse", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("format", function (assert) {
<add>test('format', function (assert) {
<ide> var a = [
<ide> ['dddd, MMMM Do YYYY, h:mm:ss a', 'вырсарникун, нарăс 14-мĕш 2010, 3:25:50 pm'],
<ide> ['ddd, hA', 'выр, 3PM'],
<ide> test("format", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("format ordinal", function (assert) {
<add>test('format ordinal', function (assert) {
<ide> assert.equal(moment([2011, 0, 1]).format('DDDo'), '1-мĕш', '1-мĕш');
<ide> assert.equal(moment([2011, 0, 2]).format('DDDo'), '2-мĕш', '2-мĕш');
<ide> assert.equal(moment([2011, 0, 3]).format('DDDo'), '3-мĕш', '3-мĕш');
<ide> test("format ordinal", function (assert) {
<ide> assert.equal(moment([2011, 0, 31]).format('DDDo'), '31-мĕш', '31-мĕш');
<ide> });
<ide>
<del>test("format month", function (assert) {
<add>test('format month', function (assert) {
<ide> var expected = 'кăрлач кăр_нарăс нар_пуш пуш_ака ака_май май_çĕртме çĕр_утă утă_çурла çур_авăн ав_юпа юпа_чӳк чӳк_раштав раш'.split('_'), i;
<ide> for (i = 0; i < expected.length; i++) {
<ide> assert.equal(moment([2011, i, 1]).format('MMMM MMM'), expected[i], expected[i]);
<ide> }
<ide> });
<ide>
<del>test("format week", function (assert) {
<add>test('format week', function (assert) {
<ide> var expected = 'вырсарникун выр вр_тунтикун тун тн_ытларикун ытл ыт_юнкун юн юн_кĕçнерникун кĕç кç_эрнекун эрн эр_шăматкун шăм шм'.split('_'), i;
<ide> for (i = 0; i < expected.length; i++) {
<ide> assert.equal(moment([2011, 0, 2 + i]).format('dddd ddd dd'), expected[i], expected[i]);
<ide> }
<ide> });
<ide>
<del>test("from", function (assert) {
<add>test('from', function (assert) {
<ide> var start = moment([2007, 1, 28]);
<ide> assert.equal(start.from(moment([2007, 1, 28]).add({s: 44}), true), 'пĕр-ик çеккунт', '44 sekunder = a few seconds');
<ide> assert.equal(start.from(moment([2007, 1, 28]).add({s: 45}), true), 'пĕр минут', '45 seconds = a minute');
<ide> test("from", function (assert) {
<ide> assert.equal(start.from(moment([2007, 1, 28]).add({y: 5}), true), '5 çул', '5 years = 5 years');
<ide> });
<ide>
<del>test("suffix", function (assert) {
<add>test('suffix', function (assert) {
<ide> assert.equal(moment(30000).from(0), 'пĕр-ик çеккунтран', 'prefix');
<ide> assert.equal(moment(0).from(30000), 'пĕр-ик çеккунт каялла', 'suffix');
<ide> });
<ide>
<del>test("now from now", function (assert) {
<add>test('now from now', function (assert) {
<ide> assert.equal(moment().fromNow(), 'пĕр-ик çеккунт каялла', 'now from now should display as in the past');
<ide> });
<ide>
<del>test("fromNow", function (assert) {
<add>test('fromNow', function (assert) {
<ide> assert.equal(moment().add({s: 30}).fromNow(), 'пĕр-ик çеккунтран', 'in a few seconds');
<ide> assert.equal(moment().add({d: 5}).fromNow(), '5 кунран', 'in 5 days');
<ide> assert.equal(moment().add({h: 2}).fromNow(), '2 сехетрен', 'in 2 hours, the right suffix!');
<ide> assert.equal(moment().add({y: 3}).fromNow(), '3 çултан', 'in 3 years, the right suffix!');
<ide> });
<ide>
<del>test("calendar day", function (assert) {
<add>test('calendar day', function (assert) {
<ide> var a = moment().hours(2).minutes(0).seconds(0);
<ide> assert.equal(moment(a).calendar(), 'Паян 02:00 сехетре', 'today at the same time');
<ide> assert.equal(moment(a).add({m: 25}).calendar(), 'Паян 02:25 сехетре', 'Now plus 25 min');
<ide> test("calendar day", function (assert) {
<ide> assert.equal(moment(a).subtract({d: 1}).calendar(), 'Ĕнер 02:00 сехетре', 'yesterday at the same time');
<ide> });
<ide>
<del>test("calendar next week", function (assert) {
<add>test('calendar next week', function (assert) {
<ide> var i, m;
<ide>
<ide> for (i = 2; i < 7; i++) {
<ide> test("calendar next week", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("calendar last week", function (assert) {
<add>test('calendar last week', function (assert) {
<ide> var i, m;
<ide>
<ide> for (i = 2; i < 7; i++) {
<ide> test("calendar last week", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("calendar all else", function (assert) {
<add>test('calendar all else', function (assert) {
<ide> var weeksAgo = moment().subtract({w: 1}),
<ide> weeksFromNow = moment().add({w: 1});
<ide>
<ide> test("calendar all else", function (assert) {
<ide> assert.equal(weeksFromNow.calendar(), weeksFromNow.format('L'), 'in 2 weeks');
<ide> });
<ide>
<del>test("weeks year starting sunday", function (assert) {
<add>test('weeks year starting sunday', function (assert) {
<ide> assert.equal(moment([2011, 11, 26]).week(), 1, 'Dec 26 2011 should be week 1');
<ide> assert.equal(moment([2012, 0, 1]).week(), 1, 'Jan 1 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 2]).week(), 2, 'Jan 2 2012 should be week 2');
<ide> assert.equal(moment([2012, 0, 8]).week(), 2, 'Jan 8 2012 should be week 2');
<ide> assert.equal(moment([2012, 0, 9]).week(), 3, 'Jan 9 2012 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting monday", function (assert) {
<add>test('weeks year starting monday', function (assert) {
<ide> assert.equal(moment([2007, 0, 1]).week(), 1, 'Jan 1 2007 should be week 1');
<ide> assert.equal(moment([2007, 0, 7]).week(), 1, 'Jan 7 2007 should be week 1');
<ide> assert.equal(moment([2007, 0, 8]).week(), 2, 'Jan 8 2007 should be week 2');
<ide> assert.equal(moment([2007, 0, 14]).week(), 2, 'Jan 14 2007 should be week 2');
<ide> assert.equal(moment([2007, 0, 15]).week(), 3, 'Jan 15 2007 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting tuesday", function (assert) {
<add>test('weeks year starting tuesday', function (assert) {
<ide> assert.equal(moment([2007, 11, 31]).week(), 1, 'Dec 31 2007 should be week 1');
<ide> assert.equal(moment([2008, 0, 1]).week(), 1, 'Jan 1 2008 should be week 1');
<ide> assert.equal(moment([2008, 0, 6]).week(), 1, 'Jan 6 2008 should be week 1');
<ide> test("weeks year starting tuesday", function (assert) {
<ide> assert.equal(moment([2008, 0, 14]).week(), 3, 'Jan 14 2008 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting wednesday", function (assert) {
<add>test('weeks year starting wednesday', function (assert) {
<ide> assert.equal(moment([2002, 11, 30]).week(), 1, 'Dec 30 2002 should be week 1');
<ide> assert.equal(moment([2003, 0, 1]).week(), 1, 'Jan 1 2003 should be week 1');
<ide> assert.equal(moment([2003, 0, 5]).week(), 1, 'Jan 5 2003 should be week 1');
<ide> test("weeks year starting wednesday", function (assert) {
<ide> assert.equal(moment([2003, 0, 13]).week(), 3, 'Jan 13 2003 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting thursday", function (assert) {
<add>test('weeks year starting thursday', function (assert) {
<ide> assert.equal(moment([2008, 11, 29]).week(), 1, 'Dec 29 2008 should be week 1');
<ide> assert.equal(moment([2009, 0, 1]).week(), 1, 'Jan 1 2009 should be week 1');
<ide> assert.equal(moment([2009, 0, 4]).week(), 1, 'Jan 4 2009 should be week 1');
<ide> test("weeks year starting thursday", function (assert) {
<ide> assert.equal(moment([2009, 0, 12]).week(), 3, 'Jan 12 2009 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting friday", function (assert) {
<add>test('weeks year starting friday', function (assert) {
<ide> assert.equal(moment([2009, 11, 28]).week(), 1, 'Dec 28 2009 should be week 1');
<ide> assert.equal(moment([2010, 0, 1]).week(), 1, 'Jan 1 2010 should be week 1');
<ide> assert.equal(moment([2010, 0, 3]).week(), 1, 'Jan 3 2010 should be week 1');
<ide> test("weeks year starting friday", function (assert) {
<ide> assert.equal(moment([2010, 0, 11]).week(), 3, 'Jan 11 2010 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting saturday", function (assert) {
<add>test('weeks year starting saturday', function (assert) {
<ide> assert.equal(moment([2010, 11, 27]).week(), 1, 'Dec 27 2010 should be week 1');
<ide> assert.equal(moment([2011, 0, 1]).week(), 1, 'Jan 1 2011 should be week 1');
<ide> assert.equal(moment([2011, 0, 2]).week(), 1, 'Jan 2 2011 should be week 1');
<ide> test("weeks year starting saturday", function (assert) {
<ide> assert.equal(moment([2011, 0, 10]).week(), 3, 'Jan 10 2011 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting sunday formatted", function (assert) {
<add>test('weeks year starting sunday formatted', function (assert) {
<ide> assert.equal(moment([2011, 11, 26]).format('w ww wo'), '1 01 1-мĕш', 'Dec 26 2011 should be week 1');
<ide> assert.equal(moment([2012, 0, 1]).format('w ww wo'), '1 01 1-мĕш', 'Jan 1 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 2]).format('w ww wo'), '2 02 2-мĕш', 'Jan 2 2012 should be week 2');
<ide> assert.equal(moment([2012, 0, 8]).format('w ww wo'), '2 02 2-мĕш', 'Jan 8 2012 should be week 2');
<ide> assert.equal(moment([2012, 0, 9]).format('w ww wo'), '3 03 3-мĕш', 'Jan 9 2012 should be week 3');
<ide> });
<ide>
<del>test("lenient ordinal parsing", function (assert) {
<add>test('lenient ordinal parsing', function (assert) {
<ide> var i, ordinalStr, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> ordinalStr = moment([2014, 0, i]).format('YYYY MM Do');
<ide> test("lenient ordinal parsing", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("lenient ordinal parsing of number", function (assert) {
<add>test('lenient ordinal parsing of number', function (assert) {
<ide> var i, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> testMoment = moment('2014 01 ' + i, 'YYYY MM Do');
<ide> test("lenient ordinal parsing of number", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("strict ordinal parsing", function (assert) {
<add>test('strict ordinal parsing', function (assert) {
<ide> var i, ordinalStr, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> ordinalStr = moment([2014, 0, i]).format('YYYY MM Do');
<ide><path>src/test/locale/cy.js
<del>import {localeModule, test} from "../qunit";
<del>import {moment} from "../../moment";
<del>localeModule("cy");
<add>import {localeModule, test} from '../qunit';
<add>import {moment} from '../../moment';
<add>localeModule('cy');
<ide>
<del>test("parse", function (assert) {
<add>test('parse', function (assert) {
<ide> var tests = 'Ionawr Ion_Chwefror Chwe_Mawrth Maw_Ebrill Ebr_Mai Mai_Mehefin Meh_Gorffennaf Gor_Awst Aws_Medi Med_Hydref Hyd_Tachwedd Tach_Rhagfyr Rhag'.split('_'),
<ide> i;
<ide> function equalTest(input, mmm, i) {
<ide> test("parse", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("format", function (assert) {
<add>test('format', function (assert) {
<ide> var a = [
<ide> ['dddd, MMMM Do YYYY, h:mm:ss a', 'Dydd Sul, Chwefror 14eg 2010, 3:25:50 pm'],
<ide> ['ddd, hA', 'Sul, 3PM'],
<ide> test("format", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("format ordinal", function (assert) {
<add>test('format ordinal', function (assert) {
<ide> assert.equal(moment([2011, 0, 1]).format('DDDo'), '1af', '1af');
<ide> assert.equal(moment([2011, 0, 2]).format('DDDo'), '2il', '2il');
<ide> assert.equal(moment([2011, 0, 3]).format('DDDo'), '3ydd', '3ydd');
<ide> test("format ordinal", function (assert) {
<ide> assert.equal(moment([2011, 0, 31]).format('DDDo'), '31ain', '31ain');
<ide> });
<ide>
<del>test("format month", function (assert) {
<add>test('format month', function (assert) {
<ide> var expected = 'Ionawr Ion_Chwefror Chwe_Mawrth Maw_Ebrill Ebr_Mai Mai_Mehefin Meh_Gorffennaf Gor_Awst Aws_Medi Med_Hydref Hyd_Tachwedd Tach_Rhagfyr Rhag'.split('_'), i;
<ide> for (i = 0; i < expected.length; i++) {
<ide> assert.equal(moment([2011, i, 1]).format('MMMM MMM'), expected[i], expected[i]);
<ide> }
<ide> });
<ide>
<del>test("format week", function (assert) {
<add>test('format week', function (assert) {
<ide> var expected = 'Dydd Sul Sul Su_Dydd Llun Llun Ll_Dydd Mawrth Maw Ma_Dydd Mercher Mer Me_Dydd Iau Iau Ia_Dydd Gwener Gwe Gw_Dydd Sadwrn Sad Sa'.split('_'), i;
<ide> for (i = 0; i < expected.length; i++) {
<ide> assert.equal(moment([2011, 0, 2 + i]).format('dddd ddd dd'), expected[i], expected[i]);
<ide> }
<ide> });
<ide>
<del>test("from", function (assert) {
<add>test('from', function (assert) {
<ide> var start = moment([2007, 1, 28]);
<ide> assert.equal(start.from(moment([2007, 1, 28]).add({s: 44}), true), 'ychydig eiliadau', '44 seconds = a few seconds');
<ide> assert.equal(start.from(moment([2007, 1, 28]).add({s: 45}), true), 'munud', '45 seconds = a minute');
<ide> test("from", function (assert) {
<ide> assert.equal(start.from(moment([2007, 1, 28]).add({y: 5}), true), '5 flynedd', '5 years = 5 years');
<ide> });
<ide>
<del>test("suffix", function (assert) {
<add>test('suffix', function (assert) {
<ide> assert.equal(moment(30000).from(0), 'mewn ychydig eiliadau', 'prefix');
<ide> assert.equal(moment(0).from(30000), 'ychydig eiliadau yn ôl', 'suffix');
<ide> });
<ide>
<del>test("fromNow", function (assert) {
<add>test('fromNow', function (assert) {
<ide> assert.equal(moment().add({s: 30}).fromNow(), 'mewn ychydig eiliadau', 'in a few seconds');
<ide> assert.equal(moment().add({d: 5}).fromNow(), 'mewn 5 diwrnod', 'in 5 days');
<ide> });
<ide>
<del>test("same day", function (assert) {
<add>test('same day', function (assert) {
<ide> var a = moment().hours(2).minutes(0).seconds(0);
<ide>
<ide> assert.equal(moment(a).calendar(), 'Heddiw am 02:00', 'today at the same time');
<ide> test("same day", function (assert) {
<ide> assert.equal(moment(a).subtract({d: 1}).calendar(), 'Ddoe am 02:00', 'yesterday at the same time');
<ide> });
<ide>
<del>test("same next week", function (assert) {
<add>test('same next week', function (assert) {
<ide> var i, m;
<ide>
<ide> for (i = 2; i < 7; i++) {
<ide> test("same next week", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("same last week", function (assert) {
<add>test('same last week', function (assert) {
<ide> var i, m;
<ide>
<ide> for (i = 2; i < 7; i++) {
<ide> test("same last week", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("same all else", function (assert) {
<add>test('same all else', function (assert) {
<ide> var weeksAgo = moment().subtract({w: 1}),
<ide> weeksFromNow = moment().add({w: 1});
<ide>
<ide> test("same all else", function (assert) {
<ide> assert.equal(weeksFromNow.calendar(), weeksFromNow.format('L'), 'in 2 weeks');
<ide> });
<ide>
<del>test("weeks year starting sunday", function (assert) {
<add>test('weeks year starting sunday', function (assert) {
<ide> assert.equal(moment([2012, 0, 1]).week(), 52, 'Jan 1 2012 should be week 52');
<ide> assert.equal(moment([2012, 0, 2]).week(), 1, 'Jan 2 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 8]).week(), 1, 'Jan 8 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 9]).week(), 2, 'Jan 9 2012 should be week 2');
<ide> assert.equal(moment([2012, 0, 15]).week(), 2, 'Jan 15 2012 should be week 2');
<ide> });
<ide>
<del>test("weeks year starting monday", function (assert) {
<add>test('weeks year starting monday', function (assert) {
<ide> assert.equal(moment([2007, 0, 1]).week(), 1, 'Jan 1 2007 should be week 1');
<ide> assert.equal(moment([2007, 0, 7]).week(), 1, 'Jan 7 2007 should be week 1');
<ide> assert.equal(moment([2007, 0, 8]).week(), 2, 'Jan 8 2007 should be week 2');
<ide> assert.equal(moment([2007, 0, 14]).week(), 2, 'Jan 14 2007 should be week 2');
<ide> assert.equal(moment([2007, 0, 15]).week(), 3, 'Jan 15 2007 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting tuesday", function (assert) {
<add>test('weeks year starting tuesday', function (assert) {
<ide> assert.equal(moment([2007, 11, 31]).week(), 1, 'Dec 31 2007 should be week 1');
<ide> assert.equal(moment([2008, 0, 1]).week(), 1, 'Jan 1 2008 should be week 1');
<ide> assert.equal(moment([2008, 0, 6]).week(), 1, 'Jan 6 2008 should be week 1');
<ide> test("weeks year starting tuesday", function (assert) {
<ide> assert.equal(moment([2008, 0, 14]).week(), 3, 'Jan 14 2008 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting wednesday", function (assert) {
<add>test('weeks year starting wednesday', function (assert) {
<ide> assert.equal(moment([2002, 11, 30]).week(), 1, 'Dec 30 2002 should be week 1');
<ide> assert.equal(moment([2003, 0, 1]).week(), 1, 'Jan 1 2003 should be week 1');
<ide> assert.equal(moment([2003, 0, 5]).week(), 1, 'Jan 5 2003 should be week 1');
<ide> test("weeks year starting wednesday", function (assert) {
<ide> assert.equal(moment([2003, 0, 13]).week(), 3, 'Jan 13 2003 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting thursday", function (assert) {
<add>test('weeks year starting thursday', function (assert) {
<ide> assert.equal(moment([2008, 11, 29]).week(), 1, 'Dec 29 2008 should be week 1');
<ide> assert.equal(moment([2009, 0, 1]).week(), 1, 'Jan 1 2009 should be week 1');
<ide> assert.equal(moment([2009, 0, 4]).week(), 1, 'Jan 4 2009 should be week 1');
<ide> test("weeks year starting thursday", function (assert) {
<ide> assert.equal(moment([2009, 0, 13]).week(), 3, 'Jan 12 2009 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting friday", function (assert) {
<add>test('weeks year starting friday', function (assert) {
<ide> assert.equal(moment([2009, 11, 28]).week(), 53, 'Dec 28 2009 should be week 53');
<ide> assert.equal(moment([2010, 0, 1]).week(), 53, 'Jan 1 2010 should be week 53');
<ide> assert.equal(moment([2010, 0, 3]).week(), 53, 'Jan 3 2010 should be week 53');
<ide> test("weeks year starting friday", function (assert) {
<ide> assert.equal(moment([2010, 0, 11]).week(), 2, 'Jan 11 2010 should be week 2');
<ide> });
<ide>
<del>test("weeks year starting saturday", function (assert) {
<add>test('weeks year starting saturday', function (assert) {
<ide> assert.equal(moment([2010, 11, 27]).week(), 52, 'Dec 27 2010 should be week 52');
<ide> assert.equal(moment([2011, 0, 1]).week(), 52, 'Jan 1 2011 should be week 52');
<ide> assert.equal(moment([2011, 0, 2]).week(), 52, 'Jan 2 2011 should be week 52');
<ide> test("weeks year starting saturday", function (assert) {
<ide> assert.equal(moment([2011, 0, 10]).week(), 2, 'Jan 10 2011 should be week 2');
<ide> });
<ide>
<del>test("weeks year starting sunday formatted", function (assert) {
<add>test('weeks year starting sunday formatted', function (assert) {
<ide> assert.equal(moment([2012, 0, 1]).format('w ww wo'), '52 52 52ain', 'Jan 1 2012 should be week 52');
<ide> assert.equal(moment([2012, 0, 2]).format('w ww wo'), '1 01 1af', 'Jan 2 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 8]).format('w ww wo'), '1 01 1af', 'Jan 8 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 9]).format('w ww wo'), '2 02 2il', 'Jan 9 2012 should be week 2');
<ide> assert.equal(moment([2012, 0, 15]).format('w ww wo'), '2 02 2il', 'Jan 15 2012 should be week 2');
<ide> });
<ide>
<del>test("lenient ordinal parsing", function (assert) {
<add>test('lenient ordinal parsing', function (assert) {
<ide> var i, ordinalStr, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> ordinalStr = moment([2014, 0, i]).format('YYYY MM Do');
<ide> test("lenient ordinal parsing", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("lenient ordinal parsing of number", function (assert) {
<add>test('lenient ordinal parsing of number', function (assert) {
<ide> var i, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> testMoment = moment('2014 01 ' + i, 'YYYY MM Do');
<ide> test("lenient ordinal parsing of number", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("strict ordinal parsing", function (assert) {
<add>test('strict ordinal parsing', function (assert) {
<ide> var i, ordinalStr, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> ordinalStr = moment([2014, 0, i]).format('YYYY MM Do');
<ide><path>src/test/locale/da.js
<del>import {localeModule, test} from "../qunit";
<del>import {moment} from "../../moment";
<del>localeModule("da");
<add>import {localeModule, test} from '../qunit';
<add>import {moment} from '../../moment';
<add>localeModule('da');
<ide>
<del>test("parse", function (assert) {
<add>test('parse', function (assert) {
<ide> var tests = 'januar jan_februar feb_marts mar_april apr_maj maj_juni jun_juli jul_august aug_september sep_oktober okt_november nov_december dec'.split('_'), i;
<ide> function equalTest(input, mmm, i) {
<ide> assert.equal(moment(input, mmm).month(), i, input + ' should be month ' + (i + 1));
<ide> test("parse", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("format", function (assert) {
<add>test('format', function (assert) {
<ide> var a = [
<ide> ['dddd [den] Do MMMM YYYY, h:mm:ss a', 'søndag den 14. februar 2010, 3:25:50 pm'],
<ide> ['ddd hA', 'søn 3PM'],
<ide> test("format", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("format ordinal", function (assert) {
<add>test('format ordinal', function (assert) {
<ide> assert.equal(moment([2011, 0, 1]).format('DDDo'), '1.', '1.');
<ide> assert.equal(moment([2011, 0, 2]).format('DDDo'), '2.', '2.');
<ide> assert.equal(moment([2011, 0, 3]).format('DDDo'), '3.', '3.');
<ide> test("format ordinal", function (assert) {
<ide> assert.equal(moment([2011, 0, 31]).format('DDDo'), '31.', '31.');
<ide> });
<ide>
<del>test("format month", function (assert) {
<add>test('format month', function (assert) {
<ide> var expected = 'januar jan_februar feb_marts mar_april apr_maj maj_juni jun_juli jul_august aug_september sep_oktober okt_november nov_december dec'.split('_'), i;
<ide> for (i = 0; i < expected.length; i++) {
<ide> assert.equal(moment([2011, i, 1]).format('MMMM MMM'), expected[i], expected[i]);
<ide> }
<ide> });
<ide>
<del>test("format week", function (assert) {
<add>test('format week', function (assert) {
<ide> var expected = 'søndag søn sø_mandag man ma_tirsdag tir ti_onsdag ons on_torsdag tor to_fredag fre fr_lørdag lør lø'.split('_'), i;
<ide> for (i = 0; i < expected.length; i++) {
<ide> assert.equal(moment([2011, 0, 2 + i]).format('dddd ddd dd'), expected[i], expected[i]);
<ide> }
<ide> });
<ide>
<del>test("from", function (assert) {
<add>test('from', function (assert) {
<ide> var start = moment([2007, 1, 28]);
<ide> assert.equal(start.from(moment([2007, 1, 28]).add({s: 44}), true), 'få sekunder', '44 seconds = a few seconds');
<ide> assert.equal(start.from(moment([2007, 1, 28]).add({s: 45}), true), 'et minut', '45 seconds = a minute');
<ide> test("from", function (assert) {
<ide> assert.equal(start.from(moment([2007, 1, 28]).add({y: 5}), true), '5 år', '5 years = 5 years');
<ide> });
<ide>
<del>test("suffix", function (assert) {
<add>test('suffix', function (assert) {
<ide> assert.equal(moment(30000).from(0), 'om få sekunder', 'prefix');
<ide> assert.equal(moment(0).from(30000), 'få sekunder siden', 'suffix');
<ide> });
<ide>
<del>test("now from now", function (assert) {
<add>test('now from now', function (assert) {
<ide> assert.equal(moment().fromNow(), 'få sekunder siden', 'now from now should display as in the past');
<ide> });
<ide>
<del>test("fromNow", function (assert) {
<add>test('fromNow', function (assert) {
<ide> assert.equal(moment().add({s: 30}).fromNow(), 'om få sekunder', 'in a few seconds');
<ide> assert.equal(moment().add({d: 5}).fromNow(), 'om 5 dage', 'in 5 days');
<ide> });
<ide>
<del>test("weeks year starting sunday", function (assert) {
<add>test('weeks year starting sunday', function (assert) {
<ide> assert.equal(moment([2012, 0, 1]).week(), 52, 'Jan 1 2012 should be week 52');
<ide> assert.equal(moment([2012, 0, 2]).week(), 1, 'Jan 2 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 8]).week(), 1, 'Jan 8 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 9]).week(), 2, 'Jan 9 2012 should be week 2');
<ide> assert.equal(moment([2012, 0, 15]).week(), 2, 'Jan 15 2012 should be week 2');
<ide> });
<ide>
<del>test("weeks year starting monday", function (assert) {
<add>test('weeks year starting monday', function (assert) {
<ide> assert.equal(moment([2007, 0, 1]).week(), 1, 'Jan 1 2007 should be week 1');
<ide> assert.equal(moment([2007, 0, 7]).week(), 1, 'Jan 7 2007 should be week 1');
<ide> assert.equal(moment([2007, 0, 8]).week(), 2, 'Jan 8 2007 should be week 2');
<ide> assert.equal(moment([2007, 0, 14]).week(), 2, 'Jan 14 2007 should be week 2');
<ide> assert.equal(moment([2007, 0, 15]).week(), 3, 'Jan 15 2007 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting tuesday", function (assert) {
<add>test('weeks year starting tuesday', function (assert) {
<ide> assert.equal(moment([2007, 11, 31]).week(), 1, 'Dec 31 2007 should be week 1');
<ide> assert.equal(moment([2008, 0, 1]).week(), 1, 'Jan 1 2008 should be week 1');
<ide> assert.equal(moment([2008, 0, 6]).week(), 1, 'Jan 6 2008 should be week 1');
<ide> test("weeks year starting tuesday", function (assert) {
<ide> assert.equal(moment([2008, 0, 14]).week(), 3, 'Jan 14 2008 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting wednesday", function (assert) {
<add>test('weeks year starting wednesday', function (assert) {
<ide> assert.equal(moment([2002, 11, 30]).week(), 1, 'Dec 30 2002 should be week 1');
<ide> assert.equal(moment([2003, 0, 1]).week(), 1, 'Jan 1 2003 should be week 1');
<ide> assert.equal(moment([2003, 0, 5]).week(), 1, 'Jan 5 2003 should be week 1');
<ide> test("weeks year starting wednesday", function (assert) {
<ide> assert.equal(moment([2003, 0, 13]).week(), 3, 'Jan 13 2003 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting thursday", function (assert) {
<add>test('weeks year starting thursday', function (assert) {
<ide> assert.equal(moment([2008, 11, 29]).week(), 1, 'Dec 29 2008 should be week 1');
<ide> assert.equal(moment([2009, 0, 1]).week(), 1, 'Jan 1 2009 should be week 1');
<ide> assert.equal(moment([2009, 0, 4]).week(), 1, 'Jan 4 2009 should be week 1');
<ide> test("weeks year starting thursday", function (assert) {
<ide> assert.equal(moment([2009, 0, 13]).week(), 3, 'Jan 12 2009 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting friday", function (assert) {
<add>test('weeks year starting friday', function (assert) {
<ide> assert.equal(moment([2009, 11, 28]).week(), 53, 'Dec 28 2009 should be week 53');
<ide> assert.equal(moment([2010, 0, 1]).week(), 53, 'Jan 1 2010 should be week 53');
<ide> assert.equal(moment([2010, 0, 3]).week(), 53, 'Jan 3 2010 should be week 53');
<ide> test("weeks year starting friday", function (assert) {
<ide> assert.equal(moment([2010, 0, 11]).week(), 2, 'Jan 11 2010 should be week 2');
<ide> });
<ide>
<del>test("weeks year starting saturday", function (assert) {
<add>test('weeks year starting saturday', function (assert) {
<ide> assert.equal(moment([2010, 11, 27]).week(), 52, 'Dec 27 2010 should be week 52');
<ide> assert.equal(moment([2011, 0, 1]).week(), 52, 'Jan 1 2011 should be week 52');
<ide> assert.equal(moment([2011, 0, 2]).week(), 52, 'Jan 2 2011 should be week 52');
<ide> test("weeks year starting saturday", function (assert) {
<ide> assert.equal(moment([2011, 0, 10]).week(), 2, 'Jan 10 2011 should be week 2');
<ide> });
<ide>
<del>test("weeks year starting sunday formatted", function (assert) {
<add>test('weeks year starting sunday formatted', function (assert) {
<ide> assert.equal(moment([2012, 0, 1]).format('w ww wo'), '52 52 52.', 'Jan 1 2012 should be week 52');
<ide> assert.equal(moment([2012, 0, 2]).format('w ww wo'), '1 01 1.', 'Jan 2 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 8]).format('w ww wo'), '1 01 1.', 'Jan 8 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 9]).format('w ww wo'), '2 02 2.', 'Jan 9 2012 should be week 2');
<ide> assert.equal(moment([2012, 0, 15]).format('w ww wo'), '2 02 2.', 'Jan 15 2012 should be week 2');
<ide> });
<ide>
<del>test("lenient ordinal parsing", function (assert) {
<add>test('lenient ordinal parsing', function (assert) {
<ide> var i, ordinalStr, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> ordinalStr = moment([2014, 0, i]).format('YYYY MM Do');
<ide> test("lenient ordinal parsing", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("lenient ordinal parsing of number", function (assert) {
<add>test('lenient ordinal parsing of number', function (assert) {
<ide> var i, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> testMoment = moment('2014 01 ' + i, 'YYYY MM Do');
<ide> test("lenient ordinal parsing of number", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("strict ordinal parsing", function (assert) {
<add>test('strict ordinal parsing', function (assert) {
<ide> var i, ordinalStr, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> ordinalStr = moment([2014, 0, i]).format('YYYY MM Do');
<ide><path>src/test/locale/de-at.js
<del>import {localeModule, test} from "../qunit";
<del>import {moment} from "../../moment";
<del>localeModule("de-at");
<add>import {localeModule, test} from '../qunit';
<add>import {moment} from '../../moment';
<add>localeModule('de-at');
<ide>
<del>test("parse", function (assert) {
<add>test('parse', function (assert) {
<ide> var tests = 'Jänner Jän._Februar Febr._März Mrz._April Apr._Mai Mai_Juni Jun._Juli Jul._August Aug._September Sept._Oktober Okt._November Nov._Dezember Dez.'.split('_'), i;
<ide>
<ide> function equalTest(input, mmm, i) {
<ide> test("parse", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("format", function (assert) {
<add>test('format', function (assert) {
<ide> var a = [
<ide> ['dddd, Do MMMM YYYY, h:mm:ss a', 'Sonntag, 14. Februar 2010, 3:25:50 pm'],
<ide> ['ddd, hA', 'So., 3PM'],
<ide> test("format", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("format ordinal", function (assert) {
<add>test('format ordinal', function (assert) {
<ide> assert.equal(moment([2011, 0, 1]).format('DDDo'), '1.', '1.');
<ide> assert.equal(moment([2011, 0, 2]).format('DDDo'), '2.', '2.');
<ide> assert.equal(moment([2011, 0, 3]).format('DDDo'), '3.', '3.');
<ide> test("format ordinal", function (assert) {
<ide> assert.equal(moment([2011, 0, 31]).format('DDDo'), '31.', '31.');
<ide> });
<ide>
<del>test("format month", function (assert) {
<add>test('format month', function (assert) {
<ide> var expected = 'Jänner Jän._Februar Febr._März Mrz._April Apr._Mai Mai_Juni Jun._Juli Jul._August Aug._September Sept._Oktober Okt._November Nov._Dezember Dez.'.split('_'), i;
<ide> for (i = 0; i < expected.length; i++) {
<ide> assert.equal(moment([2011, i, 1]).format('MMMM MMM'), expected[i], expected[i]);
<ide> }
<ide> });
<ide>
<del>test("format week", function (assert) {
<add>test('format week', function (assert) {
<ide> var expected = 'Sonntag So. So_Montag Mo. Mo_Dienstag Di. Di_Mittwoch Mi. Mi_Donnerstag Do. Do_Freitag Fr. Fr_Samstag Sa. Sa'.split('_'), i;
<ide> for (i = 0; i < expected.length; i++) {
<ide> assert.equal(moment([2011, 0, 2 + i]).format('dddd ddd dd'), expected[i], expected[i]);
<ide> }
<ide> });
<ide>
<del>test("from", function (assert) {
<add>test('from', function (assert) {
<ide> var start = moment([2007, 1, 28]);
<ide> assert.equal(start.from(moment([2007, 1, 28]).add({s: 44}), true), 'ein paar Sekunden', '44 seconds = a few seconds');
<ide> assert.equal(start.from(moment([2007, 1, 28]).add({s: 45}), true), 'eine Minute', '45 seconds = a minute');
<ide> test("from", function (assert) {
<ide> assert.equal(start.from(moment([2007, 1, 28]).add({y: 5}), true), '5 Jahre', '5 years = 5 years');
<ide> });
<ide>
<del>test("suffix", function (assert) {
<add>test('suffix', function (assert) {
<ide> assert.equal(moment(30000).from(0), 'in ein paar Sekunden', 'prefix');
<ide> assert.equal(moment(0).from(30000), 'vor ein paar Sekunden', 'suffix');
<ide> });
<ide>
<del>test("fromNow", function (assert) {
<add>test('fromNow', function (assert) {
<ide> assert.equal(moment().add({s: 30}).fromNow(), 'in ein paar Sekunden', 'in a few seconds');
<ide> assert.equal(moment().add({d: 5}).fromNow(), 'in 5 Tagen', 'in 5 days');
<ide> });
<ide>
<del>test("calendar day", function (assert) {
<add>test('calendar day', function (assert) {
<ide> var a = moment().hours(2).minutes(0).seconds(0);
<ide>
<ide> assert.equal(moment(a).calendar(), 'Heute um 02:00 Uhr', 'today at the same time');
<ide> test("calendar day", function (assert) {
<ide> assert.equal(moment(a).subtract({d: 1}).calendar(), 'Gestern um 02:00 Uhr', 'yesterday at the same time');
<ide> });
<ide>
<del>test("calendar next week", function (assert) {
<add>test('calendar next week', function (assert) {
<ide> var i, m;
<ide> for (i = 2; i < 7; i++) {
<ide> m = moment().add({d: i});
<ide> test("calendar next week", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("calendar last week", function (assert) {
<add>test('calendar last week', function (assert) {
<ide> var i, m;
<ide> for (i = 2; i < 7; i++) {
<ide> m = moment().subtract({d: i});
<ide> test("calendar last week", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("calendar all else", function (assert) {
<add>test('calendar all else', function (assert) {
<ide> var weeksAgo = moment().subtract({w: 1}),
<ide> weeksFromNow = moment().add({w: 1});
<ide>
<ide> test("calendar all else", function (assert) {
<ide> assert.equal(weeksFromNow.calendar(), weeksFromNow.format('L'), 'in 2 weeks');
<ide> });
<ide>
<del>test("weeks year starting sunday", function (assert) {
<add>test('weeks year starting sunday', function (assert) {
<ide> assert.equal(moment([2012, 0, 1]).week(), 52, 'Jan 1 2012 should be week 52');
<ide> assert.equal(moment([2012, 0, 2]).week(), 1, 'Jan 2 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 8]).week(), 1, 'Jan 8 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 9]).week(), 2, 'Jan 9 2012 should be week 2');
<ide> assert.equal(moment([2012, 0, 15]).week(), 2, 'Jan 15 2012 should be week 2');
<ide> });
<ide>
<del>test("weeks year starting monday", function (assert) {
<add>test('weeks year starting monday', function (assert) {
<ide> assert.equal(moment([2007, 0, 1]).week(), 1, 'Jan 1 2007 should be week 1');
<ide> assert.equal(moment([2007, 0, 7]).week(), 1, 'Jan 7 2007 should be week 1');
<ide> assert.equal(moment([2007, 0, 8]).week(), 2, 'Jan 8 2007 should be week 2');
<ide> assert.equal(moment([2007, 0, 14]).week(), 2, 'Jan 14 2007 should be week 2');
<ide> assert.equal(moment([2007, 0, 15]).week(), 3, 'Jan 15 2007 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting tuesday", function (assert) {
<add>test('weeks year starting tuesday', function (assert) {
<ide> assert.equal(moment([2007, 11, 31]).week(), 1, 'Dec 31 2007 should be week 1');
<ide> assert.equal(moment([2008, 0, 1]).week(), 1, 'Jan 1 2008 should be week 1');
<ide> assert.equal(moment([2008, 0, 6]).week(), 1, 'Jan 6 2008 should be week 1');
<ide> test("weeks year starting tuesday", function (assert) {
<ide> assert.equal(moment([2008, 0, 14]).week(), 3, 'Jan 14 2008 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting wednesday", function (assert) {
<add>test('weeks year starting wednesday', function (assert) {
<ide> assert.equal(moment([2002, 11, 30]).week(), 1, 'Dec 30 2002 should be week 1');
<ide> assert.equal(moment([2003, 0, 1]).week(), 1, 'Jan 1 2003 should be week 1');
<ide> assert.equal(moment([2003, 0, 5]).week(), 1, 'Jan 5 2003 should be week 1');
<ide> test("weeks year starting wednesday", function (assert) {
<ide> assert.equal(moment([2003, 0, 13]).week(), 3, 'Jan 13 2003 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting thursday", function (assert) {
<add>test('weeks year starting thursday', function (assert) {
<ide> assert.equal(moment([2008, 11, 29]).week(), 1, 'Dec 29 2008 should be week 1');
<ide> assert.equal(moment([2009, 0, 1]).week(), 1, 'Jan 1 2009 should be week 1');
<ide> assert.equal(moment([2009, 0, 4]).week(), 1, 'Jan 4 2009 should be week 1');
<ide> test("weeks year starting thursday", function (assert) {
<ide> assert.equal(moment([2009, 0, 13]).week(), 3, 'Jan 12 2009 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting friday", function (assert) {
<add>test('weeks year starting friday', function (assert) {
<ide> assert.equal(moment([2009, 11, 28]).week(), 53, 'Dec 28 2009 should be week 53');
<ide> assert.equal(moment([2010, 0, 1]).week(), 53, 'Jan 1 2010 should be week 53');
<ide> assert.equal(moment([2010, 0, 3]).week(), 53, 'Jan 3 2010 should be week 53');
<ide> test("weeks year starting friday", function (assert) {
<ide> assert.equal(moment([2010, 0, 11]).week(), 2, 'Jan 11 2010 should be week 2');
<ide> });
<ide>
<del>test("weeks year starting saturday", function (assert) {
<add>test('weeks year starting saturday', function (assert) {
<ide> assert.equal(moment([2010, 11, 27]).week(), 52, 'Dec 27 2010 should be week 52');
<ide> assert.equal(moment([2011, 0, 1]).week(), 52, 'Jan 1 2011 should be week 52');
<ide> assert.equal(moment([2011, 0, 2]).week(), 52, 'Jan 2 2011 should be week 52');
<ide> test("weeks year starting saturday", function (assert) {
<ide> assert.equal(moment([2011, 0, 10]).week(), 2, 'Jan 10 2011 should be week 2');
<ide> });
<ide>
<del>test("weeks year starting sunday formatted", function (assert) {
<add>test('weeks year starting sunday formatted', function (assert) {
<ide> assert.equal(moment([2012, 0, 1]).format('w ww wo'), '52 52 52.', 'Jan 1 2012 should be week 52');
<ide> assert.equal(moment([2012, 0, 2]).format('w ww wo'), '1 01 1.', 'Jan 2 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 8]).format('w ww wo'), '1 01 1.', 'Jan 8 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 9]).format('w ww wo'), '2 02 2.', 'Jan 9 2012 should be week 2');
<ide> assert.equal(moment([2012, 0, 15]).format('w ww wo'), '2 02 2.', 'Jan 15 2012 should be week 2');
<ide> });
<ide>
<del>test("lenient ordinal parsing", function (assert) {
<add>test('lenient ordinal parsing', function (assert) {
<ide> var i, ordinalStr, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> ordinalStr = moment([2014, 0, i]).format('YYYY MM Do');
<ide> test("lenient ordinal parsing", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("lenient ordinal parsing of number", function (assert) {
<add>test('lenient ordinal parsing of number', function (assert) {
<ide> var i, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> testMoment = moment('2014 01 ' + i, 'YYYY MM Do');
<ide> test("lenient ordinal parsing of number", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("strict ordinal parsing", function (assert) {
<add>test('strict ordinal parsing', function (assert) {
<ide> var i, ordinalStr, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> ordinalStr = moment([2014, 0, i]).format('YYYY MM Do');
<ide><path>src/test/locale/de.js
<del>import {localeModule, test} from "../qunit";
<del>import {moment} from "../../moment";
<del>localeModule("de");
<add>import {localeModule, test} from '../qunit';
<add>import {moment} from '../../moment';
<add>localeModule('de');
<ide>
<del>test("parse", function (assert) {
<add>test('parse', function (assert) {
<ide> var tests = 'Januar Jan._Februar Febr._März Mrz._April Apr._Mai Mai_Juni Jun._Juli Jul._August Aug._September Sept._Oktober Okt._November Nov._Dezember Dez.'.split('_'), i;
<ide> function equalTest(input, mmm, i) {
<ide> assert.equal(moment(input, mmm).month(), i, input + ' should be month ' + (i + 1));
<ide> test("parse", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("format", function (assert) {
<add>test('format', function (assert) {
<ide> var a = [
<ide> ['dddd, Do MMMM YYYY, h:mm:ss a', 'Sonntag, 14. Februar 2010, 3:25:50 pm'],
<ide> ['ddd, hA', 'So., 3PM'],
<ide> test("format", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("format ordinal", function (assert) {
<add>test('format ordinal', function (assert) {
<ide> assert.equal(moment([2011, 0, 1]).format('DDDo'), '1.', '1.');
<ide> assert.equal(moment([2011, 0, 2]).format('DDDo'), '2.', '2.');
<ide> assert.equal(moment([2011, 0, 3]).format('DDDo'), '3.', '3.');
<ide> test("format ordinal", function (assert) {
<ide> assert.equal(moment([2011, 0, 31]).format('DDDo'), '31.', '31.');
<ide> });
<ide>
<del>test("format month", function (assert) {
<add>test('format month', function (assert) {
<ide> var expected = 'Januar Jan._Februar Febr._März Mrz._April Apr._Mai Mai_Juni Jun._Juli Jul._August Aug._September Sept._Oktober Okt._November Nov._Dezember Dez.'.split('_'), i;
<ide> for (i = 0; i < expected.length; i++) {
<ide> assert.equal(moment([2011, i, 1]).format('MMMM MMM'), expected[i], expected[i]);
<ide> }
<ide> });
<ide>
<del>test("format week", function (assert) {
<add>test('format week', function (assert) {
<ide> var expected = 'Sonntag So. So_Montag Mo. Mo_Dienstag Di. Di_Mittwoch Mi. Mi_Donnerstag Do. Do_Freitag Fr. Fr_Samstag Sa. Sa'.split('_'), i;
<ide> for (i = 0; i < expected.length; i++) {
<ide> assert.equal(moment([2011, 0, 2 + i]).format('dddd ddd dd'), expected[i], expected[i]);
<ide> }
<ide> });
<ide>
<del>test("from", function (assert) {
<add>test('from', function (assert) {
<ide> var start = moment([2007, 1, 28]);
<ide> assert.equal(start.from(moment([2007, 1, 28]).add({s: 44}), true), 'ein paar Sekunden', '44 seconds = a few seconds');
<ide> assert.equal(start.from(moment([2007, 1, 28]).add({s: 45}), true), 'eine Minute', '45 seconds = a minute');
<ide> test("from", function (assert) {
<ide> assert.equal(start.from(moment([2007, 1, 28]).add({y: 5}), true), '5 Jahre', '5 years = 5 years');
<ide> });
<ide>
<del>test("suffix", function (assert) {
<add>test('suffix', function (assert) {
<ide> assert.equal(moment(30000).from(0), 'in ein paar Sekunden', 'prefix');
<ide> assert.equal(moment(0).from(30000), 'vor ein paar Sekunden', 'suffix');
<ide> });
<ide>
<del>test("fromNow", function (assert) {
<add>test('fromNow', function (assert) {
<ide> assert.equal(moment().add({s: 30}).fromNow(), 'in ein paar Sekunden', 'in a few seconds');
<ide> assert.equal(moment().add({d: 5}).fromNow(), 'in 5 Tagen', 'in 5 days');
<ide> });
<ide>
<del>test("calendar day", function (assert) {
<add>test('calendar day', function (assert) {
<ide> var a = moment().hours(2).minutes(0).seconds(0);
<ide>
<ide> assert.equal(moment(a).calendar(), 'Heute um 02:00 Uhr', 'today at the same time');
<ide> test("calendar day", function (assert) {
<ide> assert.equal(moment(a).subtract({d: 1}).calendar(), 'Gestern um 02:00 Uhr', 'yesterday at the same time');
<ide> });
<ide>
<del>test("calendar next week", function (assert) {
<add>test('calendar next week', function (assert) {
<ide> var i, m;
<ide> for (i = 2; i < 7; i++) {
<ide> m = moment().add({d: i});
<ide> test("calendar next week", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("calendar last week", function (assert) {
<add>test('calendar last week', function (assert) {
<ide> var i, m;
<ide> for (i = 2; i < 7; i++) {
<ide> m = moment().subtract({d: i});
<ide> test("calendar last week", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("calendar all else", function (assert) {
<add>test('calendar all else', function (assert) {
<ide> var weeksAgo = moment().subtract({w: 1}),
<ide> weeksFromNow = moment().add({w: 1});
<ide>
<ide> test("calendar all else", function (assert) {
<ide> assert.equal(weeksFromNow.calendar(), weeksFromNow.format('L'), 'in 2 weeks');
<ide> });
<ide>
<del>test("weeks year starting sunday", function (assert) {
<add>test('weeks year starting sunday', function (assert) {
<ide> assert.equal(moment([2012, 0, 1]).week(), 52, 'Jan 1 2012 should be week 52');
<ide> assert.equal(moment([2012, 0, 2]).week(), 1, 'Jan 2 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 8]).week(), 1, 'Jan 8 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 9]).week(), 2, 'Jan 9 2012 should be week 2');
<ide> assert.equal(moment([2012, 0, 15]).week(), 2, 'Jan 15 2012 should be week 2');
<ide> });
<ide>
<del>test("weeks year starting monday", function (assert) {
<add>test('weeks year starting monday', function (assert) {
<ide> assert.equal(moment([2007, 0, 1]).week(), 1, 'Jan 1 2007 should be week 1');
<ide> assert.equal(moment([2007, 0, 7]).week(), 1, 'Jan 7 2007 should be week 1');
<ide> assert.equal(moment([2007, 0, 8]).week(), 2, 'Jan 8 2007 should be week 2');
<ide> assert.equal(moment([2007, 0, 14]).week(), 2, 'Jan 14 2007 should be week 2');
<ide> assert.equal(moment([2007, 0, 15]).week(), 3, 'Jan 15 2007 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting tuesday", function (assert) {
<add>test('weeks year starting tuesday', function (assert) {
<ide> assert.equal(moment([2007, 11, 31]).week(), 1, 'Dec 31 2007 should be week 1');
<ide> assert.equal(moment([2008, 0, 1]).week(), 1, 'Jan 1 2008 should be week 1');
<ide> assert.equal(moment([2008, 0, 6]).week(), 1, 'Jan 6 2008 should be week 1');
<ide> test("weeks year starting tuesday", function (assert) {
<ide> assert.equal(moment([2008, 0, 14]).week(), 3, 'Jan 14 2008 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting wednesday", function (assert) {
<add>test('weeks year starting wednesday', function (assert) {
<ide> assert.equal(moment([2002, 11, 30]).week(), 1, 'Dec 30 2002 should be week 1');
<ide> assert.equal(moment([2003, 0, 1]).week(), 1, 'Jan 1 2003 should be week 1');
<ide> assert.equal(moment([2003, 0, 5]).week(), 1, 'Jan 5 2003 should be week 1');
<ide> test("weeks year starting wednesday", function (assert) {
<ide> assert.equal(moment([2003, 0, 13]).week(), 3, 'Jan 13 2003 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting thursday", function (assert) {
<add>test('weeks year starting thursday', function (assert) {
<ide> assert.equal(moment([2008, 11, 29]).week(), 1, 'Dec 29 2008 should be week 1');
<ide> assert.equal(moment([2009, 0, 1]).week(), 1, 'Jan 1 2009 should be week 1');
<ide> assert.equal(moment([2009, 0, 4]).week(), 1, 'Jan 4 2009 should be week 1');
<ide> test("weeks year starting thursday", function (assert) {
<ide> assert.equal(moment([2009, 0, 13]).week(), 3, 'Jan 12 2009 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting friday", function (assert) {
<add>test('weeks year starting friday', function (assert) {
<ide> assert.equal(moment([2009, 11, 28]).week(), 53, 'Dec 28 2009 should be week 53');
<ide> assert.equal(moment([2010, 0, 1]).week(), 53, 'Jan 1 2010 should be week 53');
<ide> assert.equal(moment([2010, 0, 3]).week(), 53, 'Jan 3 2010 should be week 53');
<ide> test("weeks year starting friday", function (assert) {
<ide> assert.equal(moment([2010, 0, 11]).week(), 2, 'Jan 11 2010 should be week 2');
<ide> });
<ide>
<del>test("weeks year starting saturday", function (assert) {
<add>test('weeks year starting saturday', function (assert) {
<ide> assert.equal(moment([2010, 11, 27]).week(), 52, 'Dec 27 2010 should be week 52');
<ide> assert.equal(moment([2011, 0, 1]).week(), 52, 'Jan 1 2011 should be week 52');
<ide> assert.equal(moment([2011, 0, 2]).week(), 52, 'Jan 2 2011 should be week 52');
<ide> test("weeks year starting saturday", function (assert) {
<ide> assert.equal(moment([2011, 0, 10]).week(), 2, 'Jan 10 2011 should be week 2');
<ide> });
<ide>
<del>test("weeks year starting sunday formatted", function (assert) {
<add>test('weeks year starting sunday formatted', function (assert) {
<ide> assert.equal(moment([2012, 0, 1]).format('w ww wo'), '52 52 52.', 'Jan 1 2012 should be week 52');
<ide> assert.equal(moment([2012, 0, 2]).format('w ww wo'), '1 01 1.', 'Jan 2 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 8]).format('w ww wo'), '1 01 1.', 'Jan 8 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 9]).format('w ww wo'), '2 02 2.', 'Jan 9 2012 should be week 2');
<ide> assert.equal(moment([2012, 0, 15]).format('w ww wo'), '2 02 2.', 'Jan 15 2012 should be week 2');
<ide> });
<ide>
<del>test("lenient ordinal parsing", function (assert) {
<add>test('lenient ordinal parsing', function (assert) {
<ide> var i, ordinalStr, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> ordinalStr = moment([2014, 0, i]).format('YYYY MM Do');
<ide> test("lenient ordinal parsing", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("lenient ordinal parsing of number", function (assert) {
<add>test('lenient ordinal parsing of number', function (assert) {
<ide> var i, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> testMoment = moment('2014 01 ' + i, 'YYYY MM Do');
<ide> test("lenient ordinal parsing of number", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("strict ordinal parsing", function (assert) {
<add>test('strict ordinal parsing', function (assert) {
<ide> var i, ordinalStr, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> ordinalStr = moment([2014, 0, i]).format('YYYY MM Do');
<ide><path>src/test/locale/el.js
<del>import {localeModule, test} from "../qunit";
<del>import {moment} from "../../moment";
<del>localeModule("el");
<add>import {localeModule, test} from '../qunit';
<add>import {moment} from '../../moment';
<add>localeModule('el');
<ide>
<del>test("parse", function (assert) {
<add>test('parse', function (assert) {
<ide> var i,
<ide> tests = 'Ιανουάριος Ιαν_Φεβρουάριος Φεβ_Μάρτιος Μαρ_Απρίλιος Απρ_Μάιος Μαϊ_Ιούνιος Ιουν_Ιούλιος Ιουλ_Αύγουστος Αυγ_Σεπτέμβριος Σεπ_Οκτώβριος Οκτ_Νοέμβριος Νοε_Δεκέμβριος Δεκ'.split('_');
<ide>
<ide> test("parse", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("parse meridiem", function (assert) {
<add>test('parse meridiem', function (assert) {
<ide> var i,
<ide> b = moment(),
<ide> meridiemTests = [
<ide> test("parse meridiem", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("format", function (assert) {
<add>test('format', function (assert) {
<ide> var a = [
<ide> ['dddd, MMMM Do YYYY, h:mm:ss a', 'Κυριακή, Φεβρουάριος 14η 2010, 3:25:50 μμ'],
<ide> ['dddd, D MMMM YYYY, h:mm:ss a', 'Κυριακή, 14 Φεβρουαρίου 2010, 3:25:50 μμ'],
<ide> test("format", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("format ordinal", function (assert) {
<add>test('format ordinal', function (assert) {
<ide> assert.equal(moment([2011, 0, 1]).format('DDDo'), '1η', '1η');
<ide> assert.equal(moment([2011, 0, 2]).format('DDDo'), '2η', '2η');
<ide> assert.equal(moment([2011, 0, 3]).format('DDDo'), '3η', '3η');
<ide> test("format ordinal", function (assert) {
<ide> assert.equal(moment([2011, 0, 31]).format('DDDo'), '31η', '31η');
<ide> });
<ide>
<del>test("format month", function (assert) {
<add>test('format month', function (assert) {
<ide> var i,
<ide> expected = 'Ιανουάριος Ιαν_Φεβρουάριος Φεβ_Μάρτιος Μαρ_Απρίλιος Απρ_Μάιος Μαϊ_Ιούνιος Ιουν_Ιούλιος Ιουλ_Αύγουστος Αυγ_Σεπτέμβριος Σεπ_Οκτώβριος Οκτ_Νοέμβριος Νοε_Δεκέμβριος Δεκ'.split('_');
<ide>
<ide> test("format month", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("format week", function (assert) {
<add>test('format week', function (assert) {
<ide> var i,
<ide> expected = 'Κυριακή Κυρ Κυ_Δευτέρα Δευ Δε_Τρίτη Τρι Τρ_Τετάρτη Τετ Τε_Πέμπτη Πεμ Πε_Παρασκευή Παρ Πα_Σάββατο Σαβ Σα'.split('_');
<ide>
<ide> test("format week", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("from", function (assert) {
<add>test('from', function (assert) {
<ide> var start = moment([2007, 1, 28]);
<ide>
<ide> assert.equal(start.from(moment([2007, 1, 28]).add({s: 44}), true), 'λίγα δευτερόλεπτα', '44 seconds = a few seconds');
<ide> test("from", function (assert) {
<ide> assert.equal(start.from(moment([2007, 1, 28]).add({y: 5}), true), '5 χρόνια', '5 years = 5 years');
<ide> });
<ide>
<del>test("suffix", function (assert) {
<add>test('suffix', function (assert) {
<ide> assert.equal(moment(30000).from(0), 'σε λίγα δευτερόλεπτα', 'prefix');
<ide> assert.equal(moment(0).from(30000), 'λίγα δευτερόλεπτα πριν', 'suffix');
<ide> });
<ide>
<del>test("now from now", function (assert) {
<add>test('now from now', function (assert) {
<ide> assert.equal(moment().fromNow(), 'λίγα δευτερόλεπτα πριν', 'now from now should display as in the past');
<ide> });
<ide>
<del>test("fromNow", function (assert) {
<add>test('fromNow', function (assert) {
<ide> assert.equal(moment().add({s: 30}).fromNow(), 'σε λίγα δευτερόλεπτα', 'in a few seconds');
<ide> assert.equal(moment().add({d: 5}).fromNow(), 'σε 5 μέρες', 'in 5 days');
<ide> });
<ide>
<del>test("calendar day", function (assert) {
<add>test('calendar day', function (assert) {
<ide> var a = moment().hours(2).minutes(0).seconds(0);
<ide>
<ide> assert.equal(moment(a).calendar(), 'Σήμερα στις 2:00 ΠΜ', 'today at the same time');
<ide> test("calendar day", function (assert) {
<ide> assert.equal(moment(a).subtract({d: 1}).calendar(), 'Χθες στις 2:00 ΠΜ', 'yesterday at the same time');
<ide> });
<ide>
<del>test("calendar next week", function (assert) {
<add>test('calendar next week', function (assert) {
<ide> var i, m;
<ide> for (i = 2; i < 7; i++) {
<ide> m = moment().add({d: i});
<ide> test("calendar next week", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("calendar last week", function (assert) {
<add>test('calendar last week', function (assert) {
<ide> var i, m, dayString;
<ide> for (i = 2; i < 7; i++) {
<ide> m = moment().subtract({d: i});
<ide> test("calendar last week", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("calendar all else", function (assert) {
<add>test('calendar all else', function (assert) {
<ide> var weeksAgo = moment().subtract({w: 1}),
<ide> weeksFromNow = moment().add({w: 1});
<ide>
<ide> test("calendar all else", function (assert) {
<ide> assert.equal(weeksFromNow.calendar(), weeksFromNow.format('L'), 'in 2 weeks');
<ide> });
<ide>
<del>test("weeks year starting sunday", function (assert) {
<add>test('weeks year starting sunday', function (assert) {
<ide> assert.equal(moment([2012, 0, 1]).week(), 52, 'Jan 1 2012 should be week 52');
<ide> assert.equal(moment([2012, 0, 7]).week(), 1, 'Jan 7 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 8]).week(), 1, 'Jan 8 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 14]).week(), 2, 'Jan 14 2012 should be week 2');
<ide> assert.equal(moment([2012, 0, 15]).week(), 2, 'Jan 15 2012 should be week 2');
<ide> });
<ide>
<del>test("weeks year starting monday", function (assert) {
<add>test('weeks year starting monday', function (assert) {
<ide> assert.equal(moment([2006, 11, 31]).week(), 52, 'Dec 31 2006 should be week 52');
<ide> assert.equal(moment([2007, 0, 1]).week(), 1, 'Jan 1 2007 should be week 1');
<ide> assert.equal(moment([2007, 0, 6]).week(), 1, 'Jan 6 2007 should be week 1');
<ide> test("weeks year starting monday", function (assert) {
<ide> assert.equal(moment([2007, 0, 14]).week(), 2, 'Jan 14 2007 should be week 2');
<ide> });
<ide>
<del>test("weeks year starting tuesday", function (assert) {
<add>test('weeks year starting tuesday', function (assert) {
<ide> assert.equal(moment([2007, 11, 30]).week(), 52, 'Dec 30 2007 should be week 52');
<ide> assert.equal(moment([2008, 0, 1]).week(), 1, 'Jan 1 2008 should be week 1');
<ide> assert.equal(moment([2008, 0, 5]).week(), 1, 'Jan 5 2008 should be week 1');
<ide> test("weeks year starting tuesday", function (assert) {
<ide> assert.equal(moment([2008, 0, 13]).week(), 2, 'Jan 13 2008 should be week 2');
<ide> });
<ide>
<del>test("weeks year starting wednesday", function (assert) {
<add>test('weeks year starting wednesday', function (assert) {
<ide> assert.equal(moment([2002, 11, 29]).week(), 52, 'Dec 29 2002 should be week 52');
<ide> assert.equal(moment([2003, 0, 1]).week(), 1, 'Jan 1 2003 should be week 1');
<ide> assert.equal(moment([2003, 0, 4]).week(), 1, 'Jan 4 2003 should be week 1');
<ide> test("weeks year starting wednesday", function (assert) {
<ide> assert.equal(moment([2003, 0, 12]).week(), 2, 'Jan 12 2003 should be week 2');
<ide> });
<ide>
<del>test("weeks year starting thursday", function (assert) {
<add>test('weeks year starting thursday', function (assert) {
<ide> assert.equal(moment([2008, 11, 28]).week(), 52, 'Dec 28 2008 should be week 52');
<ide> assert.equal(moment([2009, 0, 1]).week(), 1, 'Jan 1 2009 should be week 1');
<ide> assert.equal(moment([2009, 0, 3]).week(), 1, 'Jan 3 2009 should be week 1');
<ide> test("weeks year starting thursday", function (assert) {
<ide> assert.equal(moment([2009, 0, 11]).week(), 2, 'Jan 11 2009 should be week 2');
<ide> });
<ide>
<del>test("weeks year starting friday", function (assert) {
<add>test('weeks year starting friday', function (assert) {
<ide> assert.equal(moment([2009, 11, 27]).week(), 52, 'Dec 27 2009 should be week 52');
<ide> assert.equal(moment([2010, 0, 1]).week(), 53, 'Jan 1 2010 should be week 53');
<ide> assert.equal(moment([2010, 0, 2]).week(), 53, 'Jan 2 2010 should be week 53');
<ide> test("weeks year starting friday", function (assert) {
<ide> assert.equal(moment([2010, 0, 11]).week(), 2, 'Jan 11 2010 should be week 2');
<ide> });
<ide>
<del>test("weeks year starting saturday", function (assert) {
<add>test('weeks year starting saturday', function (assert) {
<ide> assert.equal(moment([2010, 11, 26]).week(), 51, 'Dec 26 2010 should be week 51');
<ide> assert.equal(moment([2011, 0, 1]).week(), 52, 'Jan 1 2011 should be week 52');
<ide> assert.equal(moment([2011, 0, 2]).week(), 52, 'Jan 2 2011 should be week 52');
<ide> test("weeks year starting saturday", function (assert) {
<ide> assert.equal(moment([2011, 0, 10]).week(), 2, 'Jan 10 2011 should be week 2');
<ide> });
<ide>
<del>test("weeks year starting sunday format", function (assert) {
<add>test('weeks year starting sunday format', function (assert) {
<ide> assert.equal(moment([2012, 0, 1]).format('w ww wo'), '52 52 52η', 'Jan 1 2012 should be week 52');
<ide> assert.equal(moment([2012, 0, 7]).format('w ww wo'), '1 01 1η', 'Jan 7 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 8]).format('w ww wo'), '1 01 1η', 'Jan 8 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 14]).format('w ww wo'), '2 02 2η', 'Jan 14 2012 should be week 2');
<ide> assert.equal(moment([2012, 0, 15]).format('w ww wo'), '2 02 2η', 'Jan 15 2012 should be week 2');
<ide> });
<ide>
<del>test("lenient ordinal parsing", function (assert) {
<add>test('lenient ordinal parsing', function (assert) {
<ide> var i, ordinalStr, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> ordinalStr = moment([2014, 0, i]).format('YYYY MM Do');
<ide> test("lenient ordinal parsing", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("lenient ordinal parsing of number", function (assert) {
<add>test('lenient ordinal parsing of number', function (assert) {
<ide> var i, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> testMoment = moment('2014 01 ' + i, 'YYYY MM Do');
<ide> test("lenient ordinal parsing of number", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("strict ordinal parsing", function (assert) {
<add>test('strict ordinal parsing', function (assert) {
<ide> var i, ordinalStr, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> ordinalStr = moment([2014, 0, i]).format('YYYY MM Do');
<ide><path>src/test/locale/en-au.js
<del>import {localeModule, test} from "../qunit";
<del>import {moment} from "../../moment";
<del>localeModule("en-au");
<add>import {localeModule, test} from '../qunit';
<add>import {moment} from '../../moment';
<add>localeModule('en-au');
<ide>
<del>test("parse", function (assert) {
<add>test('parse', function (assert) {
<ide> var tests = 'January Jan_February Feb_March Mar_April Apr_May May_June Jun_July Jul_August Aug_September Sep_October Oct_November Nov_December Dec'.split('_'), i;
<ide> function equalTest(input, mmm, i) {
<ide> assert.equal(moment(input, mmm).month(), i, input + ' should be month ' + (i + 1));
<ide> test("parse", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("format", function (assert) {
<add>test('format', function (assert) {
<ide> var a = [
<ide> ['dddd, MMMM Do YYYY, h:mm:ss a', 'Sunday, February 14th 2010, 3:25:50 pm'],
<ide> ['ddd, hA', 'Sun, 3PM'],
<ide> test("format", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("format ordinal", function (assert) {
<add>test('format ordinal', function (assert) {
<ide> assert.equal(moment([2011, 0, 1]).format('DDDo'), '1st', '1st');
<ide> assert.equal(moment([2011, 0, 2]).format('DDDo'), '2nd', '2nd');
<ide> assert.equal(moment([2011, 0, 3]).format('DDDo'), '3rd', '3rd');
<ide> test("format ordinal", function (assert) {
<ide> assert.equal(moment([2011, 0, 31]).format('DDDo'), '31st', '31st');
<ide> });
<ide>
<del>test("format month", function (assert) {
<add>test('format month', function (assert) {
<ide> var expected = 'January Jan_February Feb_March Mar_April Apr_May May_June Jun_July Jul_August Aug_September Sep_October Oct_November Nov_December Dec'.split('_'), i;
<ide> for (i = 0; i < expected.length; i++) {
<ide> assert.equal(moment([2011, i, 1]).format('MMMM MMM'), expected[i], expected[i]);
<ide> }
<ide> });
<ide>
<del>test("format week", function (assert) {
<add>test('format week', function (assert) {
<ide> var expected = 'Sunday Sun Su_Monday Mon Mo_Tuesday Tue Tu_Wednesday Wed We_Thursday Thu Th_Friday Fri Fr_Saturday Sat Sa'.split('_'), i;
<ide> for (i = 0; i < expected.length; i++) {
<ide> assert.equal(moment([2011, 0, 2 + i]).format('dddd ddd dd'), expected[i], expected[i]);
<ide> }
<ide> });
<ide>
<del>test("from", function (assert) {
<add>test('from', function (assert) {
<ide> var start = moment([2007, 1, 28]);
<ide> assert.equal(start.from(moment([2007, 1, 28]).add({s: 44}), true), 'a few seconds', '44 seconds = a few seconds');
<ide> assert.equal(start.from(moment([2007, 1, 28]).add({s: 45}), true), 'a minute', '45 seconds = a minute');
<ide> test("from", function (assert) {
<ide> assert.equal(start.from(moment([2007, 1, 28]).add({y: 5}), true), '5 years', '5 years = 5 years');
<ide> });
<ide>
<del>test("suffix", function (assert) {
<add>test('suffix', function (assert) {
<ide> assert.equal(moment(30000).from(0), 'in a few seconds', 'prefix');
<ide> assert.equal(moment(0).from(30000), 'a few seconds ago', 'suffix');
<ide> });
<ide>
<del>test("now from now", function (assert) {
<add>test('now from now', function (assert) {
<ide> assert.equal(moment().fromNow(), 'a few seconds ago', 'now from now should display as in the past');
<ide> });
<ide>
<del>test("fromNow", function (assert) {
<add>test('fromNow', function (assert) {
<ide> assert.equal(moment().add({s: 30}).fromNow(), 'in a few seconds', 'in a few seconds');
<ide> assert.equal(moment().add({d: 5}).fromNow(), 'in 5 days', 'in 5 days');
<ide> });
<ide>
<del>test("calendar day", function (assert) {
<add>test('calendar day', function (assert) {
<ide> var a = moment().hours(2).minutes(0).seconds(0);
<ide>
<ide> assert.equal(moment(a).calendar(), 'Today at 2:00 AM', 'today at the same time');
<ide> test("calendar day", function (assert) {
<ide> assert.equal(moment(a).subtract({d: 1}).calendar(), 'Yesterday at 2:00 AM', 'yesterday at the same time');
<ide> });
<ide>
<del>test("calendar next week", function (assert) {
<add>test('calendar next week', function (assert) {
<ide> var i, m;
<ide> for (i = 2; i < 7; i++) {
<ide> m = moment().add({d: i});
<ide> test("calendar next week", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("calendar last week", function (assert) {
<add>test('calendar last week', function (assert) {
<ide> var i, m;
<ide>
<ide> for (i = 2; i < 7; i++) {
<ide> test("calendar last week", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("calendar all else", function (assert) {
<add>test('calendar all else', function (assert) {
<ide> var weeksAgo = moment().subtract({w: 1}),
<ide> weeksFromNow = moment().add({w: 1});
<ide>
<ide> test("calendar all else", function (assert) {
<ide> assert.equal(weeksFromNow.calendar(), weeksFromNow.format('L'), 'in 2 weeks');
<ide> });
<ide>
<del>test("weeks year starting sunday", function (assert) {
<add>test('weeks year starting sunday', function (assert) {
<ide> assert.equal(moment([2012, 0, 1]).week(), 52, 'Jan 1 2012 should be week 52');
<ide> assert.equal(moment([2012, 0, 2]).week(), 1, 'Jan 2 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 8]).week(), 1, 'Jan 8 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 9]).week(), 2, 'Jan 9 2012 should be week 2');
<ide> assert.equal(moment([2012, 0, 15]).week(), 2, 'Jan 15 2012 should be week 2');
<ide> });
<ide>
<del>test("weeks year starting monday", function (assert) {
<add>test('weeks year starting monday', function (assert) {
<ide> assert.equal(moment([2007, 0, 1]).week(), 1, 'Jan 1 2007 should be week 1');
<ide> assert.equal(moment([2007, 0, 7]).week(), 1, 'Jan 7 2007 should be week 1');
<ide> assert.equal(moment([2007, 0, 8]).week(), 2, 'Jan 8 2007 should be week 2');
<ide> assert.equal(moment([2007, 0, 14]).week(), 2, 'Jan 14 2007 should be week 2');
<ide> assert.equal(moment([2007, 0, 15]).week(), 3, 'Jan 15 2007 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting tuesday", function (assert) {
<add>test('weeks year starting tuesday', function (assert) {
<ide> assert.equal(moment([2007, 11, 31]).week(), 1, 'Dec 31 2007 should be week 1');
<ide> assert.equal(moment([2008, 0, 1]).week(), 1, 'Jan 1 2008 should be week 1');
<ide> assert.equal(moment([2008, 0, 6]).week(), 1, 'Jan 6 2008 should be week 1');
<ide> test("weeks year starting tuesday", function (assert) {
<ide> assert.equal(moment([2008, 0, 14]).week(), 3, 'Jan 14 2008 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting wednesday", function (assert) {
<add>test('weeks year starting wednesday', function (assert) {
<ide> assert.equal(moment([2002, 11, 30]).week(), 1, 'Dec 30 2002 should be week 1');
<ide> assert.equal(moment([2003, 0, 1]).week(), 1, 'Jan 1 2003 should be week 1');
<ide> assert.equal(moment([2003, 0, 5]).week(), 1, 'Jan 5 2003 should be week 1');
<ide> test("weeks year starting wednesday", function (assert) {
<ide> assert.equal(moment([2003, 0, 13]).week(), 3, 'Jan 13 2003 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting thursday", function (assert) {
<add>test('weeks year starting thursday', function (assert) {
<ide> assert.equal(moment([2008, 11, 29]).week(), 1, 'Dec 29 2008 should be week 1');
<ide> assert.equal(moment([2009, 0, 1]).week(), 1, 'Jan 1 2009 should be week 1');
<ide> assert.equal(moment([2009, 0, 4]).week(), 1, 'Jan 4 2009 should be week 1');
<ide> test("weeks year starting thursday", function (assert) {
<ide> assert.equal(moment([2009, 0, 13]).week(), 3, 'Jan 12 2009 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting friday", function (assert) {
<add>test('weeks year starting friday', function (assert) {
<ide> assert.equal(moment([2009, 11, 28]).week(), 53, 'Dec 28 2009 should be week 53');
<ide> assert.equal(moment([2010, 0, 1]).week(), 53, 'Jan 1 2010 should be week 53');
<ide> assert.equal(moment([2010, 0, 3]).week(), 53, 'Jan 3 2010 should be week 53');
<ide> test("weeks year starting friday", function (assert) {
<ide> assert.equal(moment([2010, 0, 11]).week(), 2, 'Jan 11 2010 should be week 2');
<ide> });
<ide>
<del>test("weeks year starting saturday", function (assert) {
<add>test('weeks year starting saturday', function (assert) {
<ide> assert.equal(moment([2010, 11, 27]).week(), 52, 'Dec 27 2010 should be week 52');
<ide> assert.equal(moment([2011, 0, 1]).week(), 52, 'Jan 1 2011 should be week 52');
<ide> assert.equal(moment([2011, 0, 2]).week(), 52, 'Jan 2 2011 should be week 52');
<ide> test("weeks year starting saturday", function (assert) {
<ide> assert.equal(moment([2011, 0, 10]).week(), 2, 'Jan 10 2011 should be week 2');
<ide> });
<ide>
<del>test("weeks year starting sunday formatted", function (assert) {
<add>test('weeks year starting sunday formatted', function (assert) {
<ide> assert.equal(moment([2012, 0, 1]).format('w ww wo'), '52 52 52nd', 'Jan 1 2012 should be week 52');
<ide> assert.equal(moment([2012, 0, 2]).format('w ww wo'), '1 01 1st', 'Jan 2 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 8]).format('w ww wo'), '1 01 1st', 'Jan 8 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 9]).format('w ww wo'), '2 02 2nd', 'Jan 9 2012 should be week 2');
<ide> assert.equal(moment([2012, 0, 15]).format('w ww wo'), '2 02 2nd', 'Jan 15 2012 should be week 2');
<ide> });
<ide>
<del>test("lenient ordinal parsing", function (assert) {
<add>test('lenient ordinal parsing', function (assert) {
<ide> var i, ordinalStr, testStr;
<ide> for (i = 1; i <= 31; ++i) {
<ide> ordinalStr = moment([2014, 0, i]).format('YYYY MM Do');
<ide> test("lenient ordinal parsing", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("lenient ordinal parsing of number", function (assert) {
<add>test('lenient ordinal parsing of number', function (assert) {
<ide> var i, testStr;
<ide> for (i = 1; i <= 31; ++i) {
<ide> testStr = moment('2014 01 ' + i, 'YYYY MM Do').format('YYYY MM D');
<ide> test("lenient ordinal parsing of number", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("strict ordinal parsing", function (assert) {
<add>test('strict ordinal parsing', function (assert) {
<ide> var i, ordinalStr, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> ordinalStr = moment([2014, 0, i]).format('YYYY MMM Do');
<ide><path>src/test/locale/en-ca.js
<del>import {localeModule, test} from "../qunit";
<del>import {moment} from "../../moment";
<del>localeModule("en-ca");
<add>import {localeModule, test} from '../qunit';
<add>import {moment} from '../../moment';
<add>localeModule('en-ca');
<ide>
<del>test("parse", function (assert) {
<add>test('parse', function (assert) {
<ide> var i,
<ide> tests = 'January Jan_February Feb_March Mar_April Apr_May May_June Jun_July Jul_August Aug_September Sep_October Oct_November Nov_December Dec'.split('_');
<ide>
<ide> test("parse", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("format", function (assert) {
<add>test('format', function (assert) {
<ide> var a = [
<ide> ['dddd, MMMM Do YYYY, h:mm:ss a', 'Sunday, February 14th 2010, 3:25:50 pm'],
<ide> ['ddd, hA', 'Sun, 3PM'],
<ide> test("format", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("format ordinal", function (assert) {
<add>test('format ordinal', function (assert) {
<ide> assert.equal(moment([2011, 0, 1]).format('DDDo'), '1st', '1st');
<ide> assert.equal(moment([2011, 0, 2]).format('DDDo'), '2nd', '2nd');
<ide> assert.equal(moment([2011, 0, 3]).format('DDDo'), '3rd', '3rd');
<ide> test("format ordinal", function (assert) {
<ide> assert.equal(moment([2011, 0, 31]).format('DDDo'), '31st', '31st');
<ide> });
<ide>
<del>test("format month", function (assert) {
<add>test('format month', function (assert) {
<ide> var i,
<ide> expected = 'January Jan_February Feb_March Mar_April Apr_May May_June Jun_July Jul_August Aug_September Sep_October Oct_November Nov_December Dec'.split('_');
<ide>
<ide> test("format month", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("format week", function (assert) {
<add>test('format week', function (assert) {
<ide> var i,
<ide> expected = 'Sunday Sun Su_Monday Mon Mo_Tuesday Tue Tu_Wednesday Wed We_Thursday Thu Th_Friday Fri Fr_Saturday Sat Sa'.split('_');
<ide>
<ide> test("format week", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("from", function (assert) {
<add>test('from', function (assert) {
<ide> var start = moment([2007, 1, 28]);
<ide> assert.equal(start.from(moment([2007, 1, 28]).add({s: 44}), true), 'a few seconds', '44 seconds = a few seconds');
<ide> assert.equal(start.from(moment([2007, 1, 28]).add({s: 45}), true), 'a minute', '45 seconds = a minute');
<ide> test("from", function (assert) {
<ide> assert.equal(start.from(moment([2007, 1, 28]).add({y: 5}), true), '5 years', '5 years = 5 years');
<ide> });
<ide>
<del>test("suffix", function (assert) {
<add>test('suffix', function (assert) {
<ide> assert.equal(moment(30000).from(0), 'in a few seconds', 'prefix');
<ide> assert.equal(moment(0).from(30000), 'a few seconds ago', 'suffix');
<ide> });
<ide>
<del>test("now from now", function (assert) {
<add>test('now from now', function (assert) {
<ide> assert.equal(moment().fromNow(), 'a few seconds ago', 'now from now should display as in the past');
<ide> });
<ide>
<del>test("fromNow", function (assert) {
<add>test('fromNow', function (assert) {
<ide> assert.equal(moment().add({s: 30}).fromNow(), 'in a few seconds', 'in a few seconds');
<ide> assert.equal(moment().add({d: 5}).fromNow(), 'in 5 days', 'in 5 days');
<ide> });
<ide>
<del>test("calendar day", function (assert) {
<add>test('calendar day', function (assert) {
<ide> var a = moment().hours(2).minutes(0).seconds(0);
<ide>
<ide> assert.equal(moment(a).calendar(), 'Today at 2:00 AM', 'today at the same time');
<ide> test("calendar day", function (assert) {
<ide> assert.equal(moment(a).subtract({d: 1}).calendar(), 'Yesterday at 2:00 AM', 'yesterday at the same time');
<ide> });
<ide>
<del>test("calendar next week", function (assert) {
<add>test('calendar next week', function (assert) {
<ide> var i, m;
<ide>
<ide> for (i = 2; i < 7; i++) {
<ide> test("calendar next week", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("calendar last week", function (assert) {
<add>test('calendar last week', function (assert) {
<ide> var i, m;
<ide>
<ide> for (i = 2; i < 7; i++) {
<ide> test("calendar last week", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("calendar all else", function (assert) {
<add>test('calendar all else', function (assert) {
<ide> var weeksAgo = moment().subtract({w: 1}),
<ide> weeksFromNow = moment().add({w: 1});
<ide>
<ide> test("calendar all else", function (assert) {
<ide> assert.equal(weeksFromNow.calendar(), weeksFromNow.format('L'), 'in 2 weeks');
<ide> });
<ide>
<del>test("weeks year starting sunday", function (assert) {
<add>test('weeks year starting sunday', function (assert) {
<ide> assert.equal(moment([2012, 0, 1]).week(), 1, 'Jan 1 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 7]).week(), 1, 'Jan 7 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 8]).week(), 2, 'Jan 8 2012 should be week 2');
<ide> assert.equal(moment([2012, 0, 14]).week(), 2, 'Jan 14 2012 should be week 2');
<ide> assert.equal(moment([2012, 0, 15]).week(), 3, 'Jan 15 2012 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting monday", function (assert) {
<add>test('weeks year starting monday', function (assert) {
<ide> assert.equal(moment([2006, 11, 31]).week(), 1, 'Dec 31 2006 should be week 1');
<ide> assert.equal(moment([2007, 0, 1]).week(), 1, 'Jan 1 2007 should be week 1');
<ide> assert.equal(moment([2007, 0, 6]).week(), 1, 'Jan 6 2007 should be week 1');
<ide> test("weeks year starting monday", function (assert) {
<ide> assert.equal(moment([2007, 0, 14]).week(), 3, 'Jan 14 2007 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting tuesday", function (assert) {
<add>test('weeks year starting tuesday', function (assert) {
<ide> assert.equal(moment([2007, 11, 29]).week(), 52, 'Dec 29 2007 should be week 52');
<ide> assert.equal(moment([2008, 0, 1]).week(), 1, 'Jan 1 2008 should be week 1');
<ide> assert.equal(moment([2008, 0, 5]).week(), 1, 'Jan 5 2008 should be week 1');
<ide> test("weeks year starting tuesday", function (assert) {
<ide> assert.equal(moment([2008, 0, 13]).week(), 3, 'Jan 13 2008 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting wednesday", function (assert) {
<add>test('weeks year starting wednesday', function (assert) {
<ide> assert.equal(moment([2002, 11, 29]).week(), 1, 'Dec 29 2002 should be week 1');
<ide> assert.equal(moment([2003, 0, 1]).week(), 1, 'Jan 1 2003 should be week 1');
<ide> assert.equal(moment([2003, 0, 4]).week(), 1, 'Jan 4 2003 should be week 1');
<ide> test("weeks year starting wednesday", function (assert) {
<ide> assert.equal(moment([2003, 0, 12]).week(), 3, 'Jan 12 2003 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting thursday", function (assert) {
<add>test('weeks year starting thursday', function (assert) {
<ide> assert.equal(moment([2008, 11, 28]).week(), 1, 'Dec 28 2008 should be week 1');
<ide> assert.equal(moment([2009, 0, 1]).week(), 1, 'Jan 1 2009 should be week 1');
<ide> assert.equal(moment([2009, 0, 3]).week(), 1, 'Jan 3 2009 should be week 1');
<ide> test("weeks year starting thursday", function (assert) {
<ide> assert.equal(moment([2009, 0, 11]).week(), 3, 'Jan 11 2009 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting friday", function (assert) {
<add>test('weeks year starting friday', function (assert) {
<ide> assert.equal(moment([2009, 11, 27]).week(), 1, 'Dec 27 2009 should be week 1');
<ide> assert.equal(moment([2010, 0, 1]).week(), 1, 'Jan 1 2010 should be week 1');
<ide> assert.equal(moment([2010, 0, 2]).week(), 1, 'Jan 2 2010 should be week 1');
<ide> test("weeks year starting friday", function (assert) {
<ide> assert.equal(moment([2010, 0, 10]).week(), 3, 'Jan 10 2010 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting saturday", function (assert) {
<add>test('weeks year starting saturday', function (assert) {
<ide> assert.equal(moment([2010, 11, 26]).week(), 1, 'Dec 26 2010 should be week 1');
<ide> assert.equal(moment([2011, 0, 1]).week(), 1, 'Jan 1 2011 should be week 1');
<ide> assert.equal(moment([2011, 0, 2]).week(), 2, 'Jan 2 2011 should be week 2');
<ide> assert.equal(moment([2011, 0, 8]).week(), 2, 'Jan 8 2011 should be week 2');
<ide> assert.equal(moment([2011, 0, 9]).week(), 3, 'Jan 9 2011 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting sunday format", function (assert) {
<add>test('weeks year starting sunday format', function (assert) {
<ide> assert.equal(moment([2012, 0, 1]).format('w ww wo'), '1 01 1st', 'Jan 1 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 7]).format('w ww wo'), '1 01 1st', 'Jan 7 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 8]).format('w ww wo'), '2 02 2nd', 'Jan 8 2012 should be week 2');
<ide> assert.equal(moment([2012, 0, 14]).format('w ww wo'), '2 02 2nd', 'Jan 14 2012 should be week 2');
<ide> assert.equal(moment([2012, 0, 15]).format('w ww wo'), '3 03 3rd', 'Jan 15 2012 should be week 3');
<ide> });
<ide>
<del>test("lenient ordinal parsing", function (assert) {
<add>test('lenient ordinal parsing', function (assert) {
<ide> var i, ordinalStr, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> ordinalStr = moment([2014, 0, i]).format('YYYY MM Do');
<ide> test("lenient ordinal parsing", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("lenient ordinal parsing of number", function (assert) {
<add>test('lenient ordinal parsing of number', function (assert) {
<ide> var i, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> testMoment = moment('2014 01 ' + i, 'YYYY MM Do');
<ide> test("lenient ordinal parsing of number", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("strict ordinal parsing", function (assert) {
<add>test('strict ordinal parsing', function (assert) {
<ide> var i, ordinalStr, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> ordinalStr = moment([2014, 0, i]).format('YYYY MM Do');
<ide><path>src/test/locale/en-gb.js
<del>import {localeModule, test} from "../qunit";
<del>import {moment} from "../../moment";
<del>localeModule("en-gb");
<add>import {localeModule, test} from '../qunit';
<add>import {moment} from '../../moment';
<add>localeModule('en-gb');
<ide>
<del>test("parse", function (assert) {
<add>test('parse', function (assert) {
<ide> var tests = 'January Jan_February Feb_March Mar_April Apr_May May_June Jun_July Jul_August Aug_September Sep_October Oct_November Nov_December Dec'.split('_'), i;
<ide> function equalTest(input, mmm, i) {
<ide> assert.equal(moment(input, mmm).month(), i, input + ' should be month ' + (i + 1));
<ide> test("parse", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("format", function (assert) {
<add>test('format', function (assert) {
<ide> var a = [
<ide> ['dddd, MMMM Do YYYY, h:mm:ss a', 'Sunday, February 14th 2010, 3:25:50 pm'],
<ide> ['ddd, hA', 'Sun, 3PM'],
<ide> test("format", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("format ordinal", function (assert) {
<add>test('format ordinal', function (assert) {
<ide> assert.equal(moment([2011, 0, 1]).format('DDDo'), '1st', '1st');
<ide> assert.equal(moment([2011, 0, 2]).format('DDDo'), '2nd', '2nd');
<ide> assert.equal(moment([2011, 0, 3]).format('DDDo'), '3rd', '3rd');
<ide> test("format ordinal", function (assert) {
<ide> assert.equal(moment([2011, 0, 31]).format('DDDo'), '31st', '31st');
<ide> });
<ide>
<del>test("format month", function (assert) {
<add>test('format month', function (assert) {
<ide> var expected = 'January Jan_February Feb_March Mar_April Apr_May May_June Jun_July Jul_August Aug_September Sep_October Oct_November Nov_December Dec'.split('_'), i;
<ide> for (i = 0; i < expected.length; i++) {
<ide> assert.equal(moment([2011, i, 1]).format('MMMM MMM'), expected[i], expected[i]);
<ide> }
<ide> });
<ide>
<del>test("format week", function (assert) {
<add>test('format week', function (assert) {
<ide> var expected = 'Sunday Sun Su_Monday Mon Mo_Tuesday Tue Tu_Wednesday Wed We_Thursday Thu Th_Friday Fri Fr_Saturday Sat Sa'.split('_'), i;
<ide> for (i = 0; i < expected.length; i++) {
<ide> assert.equal(moment([2011, 0, 2 + i]).format('dddd ddd dd'), expected[i], expected[i]);
<ide> }
<ide> });
<ide>
<del>test("from", function (assert) {
<add>test('from', function (assert) {
<ide> var start = moment([2007, 1, 28]);
<ide> assert.equal(start.from(moment([2007, 1, 28]).add({s: 44}), true), 'a few seconds', '44 seconds = a few seconds');
<ide> assert.equal(start.from(moment([2007, 1, 28]).add({s: 45}), true), 'a minute', '45 seconds = a minute');
<ide> test("from", function (assert) {
<ide> assert.equal(start.from(moment([2007, 1, 28]).add({y: 5}), true), '5 years', '5 years = 5 years');
<ide> });
<ide>
<del>test("suffix", function (assert) {
<add>test('suffix', function (assert) {
<ide> assert.equal(moment(30000).from(0), 'in a few seconds', 'prefix');
<ide> assert.equal(moment(0).from(30000), 'a few seconds ago', 'suffix');
<ide> });
<ide>
<del>test("now from now", function (assert) {
<add>test('now from now', function (assert) {
<ide> assert.equal(moment().fromNow(), 'a few seconds ago', 'now from now should display as in the past');
<ide> });
<ide>
<del>test("fromNow", function (assert) {
<add>test('fromNow', function (assert) {
<ide> assert.equal(moment().add({s: 30}).fromNow(), 'in a few seconds', 'in a few seconds');
<ide> assert.equal(moment().add({d: 5}).fromNow(), 'in 5 days', 'in 5 days');
<ide> });
<ide>
<del>test("calendar day", function (assert) {
<add>test('calendar day', function (assert) {
<ide> var a = moment().hours(2).minutes(0).seconds(0);
<ide>
<ide> assert.equal(moment(a).calendar(), 'Today at 02:00', 'today at the same time');
<ide> test("calendar day", function (assert) {
<ide> assert.equal(moment(a).subtract({d: 1}).calendar(), 'Yesterday at 02:00', 'yesterday at the same time');
<ide> });
<ide>
<del>test("calendar next week", function (assert) {
<add>test('calendar next week', function (assert) {
<ide> var i, m;
<ide> for (i = 2; i < 7; i++) {
<ide> m = moment().add({d: i});
<ide> test("calendar next week", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("calendar last week", function (assert) {
<add>test('calendar last week', function (assert) {
<ide> var i, m;
<ide>
<ide> for (i = 2; i < 7; i++) {
<ide> test("calendar last week", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("calendar all else", function (assert) {
<add>test('calendar all else', function (assert) {
<ide> var weeksAgo = moment().subtract({w: 1}),
<ide> weeksFromNow = moment().add({w: 1});
<ide>
<ide> test("calendar all else", function (assert) {
<ide> assert.equal(weeksFromNow.calendar(), weeksFromNow.format('L'), 'in 2 weeks');
<ide> });
<ide>
<del>test("weeks year starting sunday", function (assert) {
<add>test('weeks year starting sunday', function (assert) {
<ide> assert.equal(moment([2012, 0, 1]).week(), 52, 'Jan 1 2012 should be week 52');
<ide> assert.equal(moment([2012, 0, 2]).week(), 1, 'Jan 2 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 8]).week(), 1, 'Jan 8 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 9]).week(), 2, 'Jan 9 2012 should be week 2');
<ide> assert.equal(moment([2012, 0, 15]).week(), 2, 'Jan 15 2012 should be week 2');
<ide> });
<ide>
<del>test("weeks year starting monday", function (assert) {
<add>test('weeks year starting monday', function (assert) {
<ide> assert.equal(moment([2007, 0, 1]).week(), 1, 'Jan 1 2007 should be week 1');
<ide> assert.equal(moment([2007, 0, 7]).week(), 1, 'Jan 7 2007 should be week 1');
<ide> assert.equal(moment([2007, 0, 8]).week(), 2, 'Jan 8 2007 should be week 2');
<ide> assert.equal(moment([2007, 0, 14]).week(), 2, 'Jan 14 2007 should be week 2');
<ide> assert.equal(moment([2007, 0, 15]).week(), 3, 'Jan 15 2007 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting tuesday", function (assert) {
<add>test('weeks year starting tuesday', function (assert) {
<ide> assert.equal(moment([2007, 11, 31]).week(), 1, 'Dec 31 2007 should be week 1');
<ide> assert.equal(moment([2008, 0, 1]).week(), 1, 'Jan 1 2008 should be week 1');
<ide> assert.equal(moment([2008, 0, 6]).week(), 1, 'Jan 6 2008 should be week 1');
<ide> test("weeks year starting tuesday", function (assert) {
<ide> assert.equal(moment([2008, 0, 14]).week(), 3, 'Jan 14 2008 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting wednesday", function (assert) {
<add>test('weeks year starting wednesday', function (assert) {
<ide> assert.equal(moment([2002, 11, 30]).week(), 1, 'Dec 30 2002 should be week 1');
<ide> assert.equal(moment([2003, 0, 1]).week(), 1, 'Jan 1 2003 should be week 1');
<ide> assert.equal(moment([2003, 0, 5]).week(), 1, 'Jan 5 2003 should be week 1');
<ide> test("weeks year starting wednesday", function (assert) {
<ide> assert.equal(moment([2003, 0, 13]).week(), 3, 'Jan 13 2003 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting thursday", function (assert) {
<add>test('weeks year starting thursday', function (assert) {
<ide> assert.equal(moment([2008, 11, 29]).week(), 1, 'Dec 29 2008 should be week 1');
<ide> assert.equal(moment([2009, 0, 1]).week(), 1, 'Jan 1 2009 should be week 1');
<ide> assert.equal(moment([2009, 0, 4]).week(), 1, 'Jan 4 2009 should be week 1');
<ide> test("weeks year starting thursday", function (assert) {
<ide> assert.equal(moment([2009, 0, 13]).week(), 3, 'Jan 12 2009 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting friday", function (assert) {
<add>test('weeks year starting friday', function (assert) {
<ide> assert.equal(moment([2009, 11, 28]).week(), 53, 'Dec 28 2009 should be week 53');
<ide> assert.equal(moment([2010, 0, 1]).week(), 53, 'Jan 1 2010 should be week 53');
<ide> assert.equal(moment([2010, 0, 3]).week(), 53, 'Jan 3 2010 should be week 53');
<ide> test("weeks year starting friday", function (assert) {
<ide> assert.equal(moment([2010, 0, 11]).week(), 2, 'Jan 11 2010 should be week 2');
<ide> });
<ide>
<del>test("weeks year starting saturday", function (assert) {
<add>test('weeks year starting saturday', function (assert) {
<ide> assert.equal(moment([2010, 11, 27]).week(), 52, 'Dec 27 2010 should be week 52');
<ide> assert.equal(moment([2011, 0, 1]).week(), 52, 'Jan 1 2011 should be week 52');
<ide> assert.equal(moment([2011, 0, 2]).week(), 52, 'Jan 2 2011 should be week 52');
<ide> test("weeks year starting saturday", function (assert) {
<ide> assert.equal(moment([2011, 0, 10]).week(), 2, 'Jan 10 2011 should be week 2');
<ide> });
<ide>
<del>test("weeks year starting sunday formatted", function (assert) {
<add>test('weeks year starting sunday formatted', function (assert) {
<ide> assert.equal(moment([2012, 0, 1]).format('w ww wo'), '52 52 52nd', 'Jan 1 2012 should be week 52');
<ide> assert.equal(moment([2012, 0, 2]).format('w ww wo'), '1 01 1st', 'Jan 2 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 8]).format('w ww wo'), '1 01 1st', 'Jan 8 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 9]).format('w ww wo'), '2 02 2nd', 'Jan 9 2012 should be week 2');
<ide> assert.equal(moment([2012, 0, 15]).format('w ww wo'), '2 02 2nd', 'Jan 15 2012 should be week 2');
<ide> });
<ide>
<del>test("lenient ordinal parsing", function (assert) {
<add>test('lenient ordinal parsing', function (assert) {
<ide> var i, ordinalStr, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> ordinalStr = moment([2014, 0, i]).format('YYYY MM Do');
<ide> test("lenient ordinal parsing", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("lenient ordinal parsing of number", function (assert) {
<add>test('lenient ordinal parsing of number', function (assert) {
<ide> var i, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> testMoment = moment('2014 01 ' + i, 'YYYY MM Do');
<ide> test("lenient ordinal parsing of number", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("strict ordinal parsing", function (assert) {
<add>test('strict ordinal parsing', function (assert) {
<ide> var i, ordinalStr, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> ordinalStr = moment([2014, 0, i]).format('YYYY MM Do');
<ide><path>src/test/locale/en.js
<del>import {localeModule, test} from "../qunit";
<del>import {moment} from "../../moment";
<del>localeModule("en");
<add>import {localeModule, test} from '../qunit';
<add>import {moment} from '../../moment';
<add>localeModule('en');
<ide>
<del>test("parse", function (assert) {
<add>test('parse', function (assert) {
<ide> var i,
<ide> tests = 'January Jan_February Feb_March Mar_April Apr_May May_June Jun_July Jul_August Aug_September Sep_October Oct_November Nov_December Dec'.split('_');
<ide>
<ide> test("parse", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("format", function (assert) {
<add>test('format', function (assert) {
<ide> var a = [
<ide> ['dddd, MMMM Do YYYY, h:mm:ss a', 'Sunday, February 14th 2010, 3:25:50 pm'],
<ide> ['ddd, hA', 'Sun, 3PM'],
<ide> test("format", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("format ordinal", function (assert) {
<add>test('format ordinal', function (assert) {
<ide> assert.equal(moment([2011, 0, 1]).format('DDDo'), '1st', '1st');
<ide> assert.equal(moment([2011, 0, 2]).format('DDDo'), '2nd', '2nd');
<ide> assert.equal(moment([2011, 0, 3]).format('DDDo'), '3rd', '3rd');
<ide> test("format ordinal", function (assert) {
<ide> assert.equal(moment([2011, 0, 31]).format('DDDo'), '31st', '31st');
<ide> });
<ide>
<del>test("format month", function (assert) {
<add>test('format month', function (assert) {
<ide> var i,
<ide> expected = 'January Jan_February Feb_March Mar_April Apr_May May_June Jun_July Jul_August Aug_September Sep_October Oct_November Nov_December Dec'.split('_');
<ide>
<ide> test("format month", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("format week", function (assert) {
<add>test('format week', function (assert) {
<ide> var i,
<ide> expected = 'Sunday Sun Su_Monday Mon Mo_Tuesday Tue Tu_Wednesday Wed We_Thursday Thu Th_Friday Fri Fr_Saturday Sat Sa'.split('_');
<ide>
<ide> test("format week", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("from", function (assert) {
<add>test('from', function (assert) {
<ide> var start = moment([2007, 1, 28]);
<ide>
<ide> assert.equal(start.from(moment([2007, 1, 28]).add({s: 44}), true), 'a few seconds', '44 seconds = a few seconds');
<ide> test("from", function (assert) {
<ide> assert.equal(start.from(moment([2007, 1, 28]).add({y: 5}), true), '5 years', '5 years = 5 years');
<ide> });
<ide>
<del>test("suffix", function (assert) {
<add>test('suffix', function (assert) {
<ide> assert.equal(moment(30000).from(0), 'in a few seconds', 'prefix');
<ide> assert.equal(moment(0).from(30000), 'a few seconds ago', 'suffix');
<ide> });
<ide>
<del>test("now from now", function (assert) {
<add>test('now from now', function (assert) {
<ide> assert.equal(moment().fromNow(), 'a few seconds ago', 'now from now should display as in the past');
<ide> });
<ide>
<del>test("fromNow", function (assert) {
<add>test('fromNow', function (assert) {
<ide> assert.equal(moment().add({s: 30}).fromNow(), 'in a few seconds', 'in a few seconds');
<ide> assert.equal(moment().add({d: 5}).fromNow(), 'in 5 days', 'in 5 days');
<ide> });
<ide>
<del>test("calendar day", function (assert) {
<add>test('calendar day', function (assert) {
<ide> var a = moment().hours(2).minutes(0).seconds(0);
<ide>
<ide> assert.equal(moment(a).calendar(), 'Today at 2:00 AM', 'today at the same time');
<ide> test("calendar day", function (assert) {
<ide> assert.equal(moment(a).subtract({d: 1}).calendar(), 'Yesterday at 2:00 AM', 'yesterday at the same time');
<ide> });
<ide>
<del>test("calendar next week", function (assert) {
<add>test('calendar next week', function (assert) {
<ide> var i, m;
<ide>
<ide> for (i = 2; i < 7; i++) {
<ide> test("calendar next week", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("calendar last week", function (assert) {
<add>test('calendar last week', function (assert) {
<ide> var i, m;
<ide>
<ide> for (i = 2; i < 7; i++) {
<ide> test("calendar last week", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("calendar all else", function (assert) {
<add>test('calendar all else', function (assert) {
<ide> var weeksAgo = moment().subtract({w: 1}),
<ide> weeksFromNow = moment().add({w: 1});
<ide>
<ide> test("calendar all else", function (assert) {
<ide> assert.equal(weeksFromNow.calendar(), weeksFromNow.format('L'), 'in 2 weeks');
<ide> });
<ide>
<del>test("weeks year starting sunday", function (assert) {
<add>test('weeks year starting sunday', function (assert) {
<ide> assert.equal(moment([2012, 0, 1]).week(), 1, 'Jan 1 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 7]).week(), 1, 'Jan 7 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 8]).week(), 2, 'Jan 8 2012 should be week 2');
<ide> assert.equal(moment([2012, 0, 14]).week(), 2, 'Jan 14 2012 should be week 2');
<ide> assert.equal(moment([2012, 0, 15]).week(), 3, 'Jan 15 2012 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting monday", function (assert) {
<add>test('weeks year starting monday', function (assert) {
<ide> assert.equal(moment([2006, 11, 31]).week(), 1, 'Dec 31 2006 should be week 1');
<ide> assert.equal(moment([2007, 0, 1]).week(), 1, 'Jan 1 2007 should be week 1');
<ide> assert.equal(moment([2007, 0, 6]).week(), 1, 'Jan 6 2007 should be week 1');
<ide> test("weeks year starting monday", function (assert) {
<ide> assert.equal(moment([2007, 0, 14]).week(), 3, 'Jan 14 2007 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting tuesday", function (assert) {
<add>test('weeks year starting tuesday', function (assert) {
<ide> assert.equal(moment([2007, 11, 29]).week(), 52, 'Dec 29 2007 should be week 52');
<ide> assert.equal(moment([2008, 0, 1]).week(), 1, 'Jan 1 2008 should be week 1');
<ide> assert.equal(moment([2008, 0, 5]).week(), 1, 'Jan 5 2008 should be week 1');
<ide> test("weeks year starting tuesday", function (assert) {
<ide> assert.equal(moment([2008, 0, 13]).week(), 3, 'Jan 13 2008 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting wednesday", function (assert) {
<add>test('weeks year starting wednesday', function (assert) {
<ide> assert.equal(moment([2002, 11, 29]).week(), 1, 'Dec 29 2002 should be week 1');
<ide> assert.equal(moment([2003, 0, 1]).week(), 1, 'Jan 1 2003 should be week 1');
<ide> assert.equal(moment([2003, 0, 4]).week(), 1, 'Jan 4 2003 should be week 1');
<ide> test("weeks year starting wednesday", function (assert) {
<ide> assert.equal(moment([2003, 0, 12]).week(), 3, 'Jan 12 2003 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting thursday", function (assert) {
<add>test('weeks year starting thursday', function (assert) {
<ide> assert.equal(moment([2008, 11, 28]).week(), 1, 'Dec 28 2008 should be week 1');
<ide> assert.equal(moment([2009, 0, 1]).week(), 1, 'Jan 1 2009 should be week 1');
<ide> assert.equal(moment([2009, 0, 3]).week(), 1, 'Jan 3 2009 should be week 1');
<ide> test("weeks year starting thursday", function (assert) {
<ide> assert.equal(moment([2009, 0, 11]).week(), 3, 'Jan 11 2009 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting friday", function (assert) {
<add>test('weeks year starting friday', function (assert) {
<ide> assert.equal(moment([2009, 11, 27]).week(), 1, 'Dec 27 2009 should be week 1');
<ide> assert.equal(moment([2010, 0, 1]).week(), 1, 'Jan 1 2010 should be week 1');
<ide> assert.equal(moment([2010, 0, 2]).week(), 1, 'Jan 2 2010 should be week 1');
<ide> test("weeks year starting friday", function (assert) {
<ide> assert.equal(moment([2010, 0, 10]).week(), 3, 'Jan 10 2010 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting saturday", function (assert) {
<add>test('weeks year starting saturday', function (assert) {
<ide> assert.equal(moment([2010, 11, 26]).week(), 1, 'Dec 26 2010 should be week 1');
<ide> assert.equal(moment([2011, 0, 1]).week(), 1, 'Jan 1 2011 should be week 1');
<ide> assert.equal(moment([2011, 0, 2]).week(), 2, 'Jan 2 2011 should be week 2');
<ide> assert.equal(moment([2011, 0, 8]).week(), 2, 'Jan 8 2011 should be week 2');
<ide> assert.equal(moment([2011, 0, 9]).week(), 3, 'Jan 9 2011 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting sunday format", function (assert) {
<add>test('weeks year starting sunday format', function (assert) {
<ide> assert.equal(moment([2012, 0, 1]).format('w ww wo'), '1 01 1st', 'Jan 1 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 7]).format('w ww wo'), '1 01 1st', 'Jan 7 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 8]).format('w ww wo'), '2 02 2nd', 'Jan 8 2012 should be week 2');
<ide> assert.equal(moment([2012, 0, 14]).format('w ww wo'), '2 02 2nd', 'Jan 14 2012 should be week 2');
<ide> assert.equal(moment([2012, 0, 15]).format('w ww wo'), '3 03 3rd', 'Jan 15 2012 should be week 3');
<ide> });
<ide>
<del>test("lenient ordinal parsing", function (assert) {
<add>test('lenient ordinal parsing', function (assert) {
<ide> var i, ordinalStr, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> ordinalStr = moment([2014, 0, i]).format('YYYY MM Do');
<ide> test("lenient ordinal parsing", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("lenient ordinal parsing of number", function (assert) {
<add>test('lenient ordinal parsing of number', function (assert) {
<ide> var i, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> testMoment = moment('2014 01 ' + i, 'YYYY MM Do');
<ide> test("lenient ordinal parsing of number", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("strict ordinal parsing", function (assert) {
<add>test('strict ordinal parsing', function (assert) {
<ide> var i, ordinalStr, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> ordinalStr = moment([2014, 0, i]).format('YYYY MM Do');
<ide><path>src/test/locale/eo.js
<del>import {localeModule, test} from "../qunit";
<del>import {moment} from "../../moment";
<del>localeModule("eo");
<add>import {localeModule, test} from '../qunit';
<add>import {moment} from '../../moment';
<add>localeModule('eo');
<ide>
<del>test("parse", function (assert) {
<add>test('parse', function (assert) {
<ide> var tests = 'januaro jan_februaro feb_marto mar_aprilo apr_majo maj_junio jun_julio jul_aŭgusto aŭg_septembro sep_oktobro okt_novembro nov_decembro dec'.split('_'), i;
<ide> function equalTest(input, mmm, i) {
<ide> assert.equal(moment(input, mmm).month(), i, input + ' should be month ' + (i + 1));
<ide> test("parse", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("format", function (assert) {
<add>test('format', function (assert) {
<ide> var a = [
<ide> ['dddd, MMMM Do YYYY, h:mm:ss a', 'Dimanĉo, februaro 14a 2010, 3:25:50 p.t.m.'],
<ide> ['ddd, hA', 'Dim, 3P.T.M.'],
<ide> test("format", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("format ordinal", function (assert) {
<add>test('format ordinal', function (assert) {
<ide> assert.equal(moment([2011, 0, 1]).format('DDDo'), '1a', '1a');
<ide> assert.equal(moment([2011, 0, 2]).format('DDDo'), '2a', '2a');
<ide> assert.equal(moment([2011, 0, 3]).format('DDDo'), '3a', '3a');
<ide> test("format ordinal", function (assert) {
<ide> assert.equal(moment([2011, 0, 31]).format('DDDo'), '31a', '31a');
<ide> });
<ide>
<del>test("format month", function (assert) {
<add>test('format month', function (assert) {
<ide> var expected = 'januaro jan_februaro feb_marto mar_aprilo apr_majo maj_junio jun_julio jul_aŭgusto aŭg_septembro sep_oktobro okt_novembro nov_decembro dec'.split('_'), i;
<ide> for (i = 0; i < expected.length; i++) {
<ide> assert.equal(moment([2011, i, 1]).format('MMMM MMM'), expected[i], expected[i]);
<ide> }
<ide> });
<ide>
<del>test("format week", function (assert) {
<add>test('format week', function (assert) {
<ide> var expected = 'Dimanĉo Dim Di_Lundo Lun Lu_Mardo Mard Ma_Merkredo Merk Me_Ĵaŭdo Ĵaŭ Ĵa_Vendredo Ven Ve_Sabato Sab Sa'.split('_'), i;
<ide> for (i = 0; i < expected.length; i++) {
<ide> assert.equal(moment([2011, 0, 2 + i]).format('dddd ddd dd'), expected[i], expected[i]);
<ide> }
<ide> });
<ide>
<del>test("from", function (assert) {
<add>test('from', function (assert) {
<ide> var start = moment([2007, 1, 28]);
<ide> assert.equal(start.from(moment([2007, 1, 28]).add({s: 44}), true), 'sekundoj', '44 seconds = a few seconds');
<ide> assert.equal(start.from(moment([2007, 1, 28]).add({s: 45}), true), 'minuto', '45 seconds = a minute');
<ide> test("from", function (assert) {
<ide> assert.equal(start.from(moment([2007, 1, 28]).add({y: 5}), true), '5 jaroj', '5 years = 5 years');
<ide> });
<ide>
<del>test("suffix", function (assert) {
<add>test('suffix', function (assert) {
<ide> assert.equal(moment(30000).from(0), 'je sekundoj', 'je prefix');
<ide> assert.equal(moment(0).from(30000), 'antaŭ sekundoj', 'antaŭ prefix');
<ide> });
<ide>
<del>test("now from now", function (assert) {
<add>test('now from now', function (assert) {
<ide> assert.equal(moment().fromNow(), 'antaŭ sekundoj', 'now from now should display as in the past');
<ide> });
<ide>
<del>test("fromNow", function (assert) {
<add>test('fromNow', function (assert) {
<ide> assert.equal(moment().add({s: 30}).fromNow(), 'je sekundoj', 'je sekundoj');
<ide> assert.equal(moment().add({d: 5}).fromNow(), 'je 5 tagoj', 'je 5 tagoj');
<ide> });
<ide>
<del>test("calendar day", function (assert) {
<add>test('calendar day', function (assert) {
<ide> var a = moment().hours(2).minutes(0).seconds(0);
<ide>
<ide> assert.equal(moment(a).calendar(), 'Hodiaŭ je 02:00', 'today at the same time');
<ide> test("calendar day", function (assert) {
<ide> assert.equal(moment(a).subtract({d: 1}).calendar(), 'Hieraŭ je 02:00', 'yesterday at the same time');
<ide> });
<ide>
<del>test("calendar next week", function (assert) {
<add>test('calendar next week', function (assert) {
<ide> var i, m;
<ide>
<ide> for (i = 2; i < 7; i++) {
<ide> test("calendar next week", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("calendar last week", function (assert) {
<add>test('calendar last week', function (assert) {
<ide> var i, m;
<ide>
<ide> for (i = 2; i < 7; i++) {
<ide> test("calendar last week", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("calendar all else", function (assert) {
<add>test('calendar all else', function (assert) {
<ide> var weeksAgo = moment().subtract({w: 1}),
<ide> weeksFromNow = moment().add({w: 1});
<ide>
<ide> test("calendar all else", function (assert) {
<ide> assert.equal(weeksFromNow.calendar(), weeksFromNow.format('L'), 'in 2 weeks');
<ide> });
<ide>
<del>test("weeks year starting sunday", function (assert) {
<add>test('weeks year starting sunday', function (assert) {
<ide> assert.equal(moment([2011, 11, 26]).week(), 1, 'Dec 26 2011 should be week 1');
<ide> assert.equal(moment([2012, 0, 1]).week(), 1, 'Jan 1 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 2]).week(), 2, 'Jan 2 2012 should be week 2');
<ide> assert.equal(moment([2012, 0, 8]).week(), 2, 'Jan 8 2012 should be week 2');
<ide> assert.equal(moment([2012, 0, 9]).week(), 3, 'Jan 9 2012 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting monday", function (assert) {
<add>test('weeks year starting monday', function (assert) {
<ide> assert.equal(moment([2007, 0, 1]).week(), 1, 'Jan 1 2007 should be week 1');
<ide> assert.equal(moment([2007, 0, 7]).week(), 1, 'Jan 7 2007 should be week 1');
<ide> assert.equal(moment([2007, 0, 8]).week(), 2, 'Jan 8 2007 should be week 2');
<ide> assert.equal(moment([2007, 0, 14]).week(), 2, 'Jan 14 2007 should be week 2');
<ide> assert.equal(moment([2007, 0, 15]).week(), 3, 'Jan 15 2007 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting tuesday", function (assert) {
<add>test('weeks year starting tuesday', function (assert) {
<ide> assert.equal(moment([2007, 11, 31]).week(), 1, 'Dec 31 2007 should be week 1');
<ide> assert.equal(moment([2008, 0, 1]).week(), 1, 'Jan 1 2008 should be week 1');
<ide> assert.equal(moment([2008, 0, 6]).week(), 1, 'Jan 6 2008 should be week 1');
<ide> test("weeks year starting tuesday", function (assert) {
<ide> assert.equal(moment([2008, 0, 14]).week(), 3, 'Jan 14 2008 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting wednesday", function (assert) {
<add>test('weeks year starting wednesday', function (assert) {
<ide> assert.equal(moment([2002, 11, 30]).week(), 1, 'Dec 30 2002 should be week 1');
<ide> assert.equal(moment([2003, 0, 1]).week(), 1, 'Jan 1 2003 should be week 1');
<ide> assert.equal(moment([2003, 0, 5]).week(), 1, 'Jan 5 2003 should be week 1');
<ide> test("weeks year starting wednesday", function (assert) {
<ide> assert.equal(moment([2003, 0, 13]).week(), 3, 'Jan 13 2003 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting thursday", function (assert) {
<add>test('weeks year starting thursday', function (assert) {
<ide> assert.equal(moment([2008, 11, 29]).week(), 1, 'Dec 29 2008 should be week 1');
<ide> assert.equal(moment([2009, 0, 1]).week(), 1, 'Jan 1 2009 should be week 1');
<ide> assert.equal(moment([2009, 0, 4]).week(), 1, 'Jan 4 2009 should be week 1');
<ide> test("weeks year starting thursday", function (assert) {
<ide> assert.equal(moment([2009, 0, 12]).week(), 3, 'Jan 12 2009 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting friday", function (assert) {
<add>test('weeks year starting friday', function (assert) {
<ide> assert.equal(moment([2009, 11, 28]).week(), 1, 'Dec 28 2009 should be week 1');
<ide> assert.equal(moment([2010, 0, 1]).week(), 1, 'Jan 1 2010 should be week 1');
<ide> assert.equal(moment([2010, 0, 3]).week(), 1, 'Jan 3 2010 should be week 1');
<ide> test("weeks year starting friday", function (assert) {
<ide> assert.equal(moment([2010, 0, 11]).week(), 3, 'Jan 11 2010 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting saturday", function (assert) {
<add>test('weeks year starting saturday', function (assert) {
<ide> assert.equal(moment([2010, 11, 27]).week(), 1, 'Dec 27 2010 should be week 1');
<ide> assert.equal(moment([2011, 0, 1]).week(), 1, 'Jan 1 2011 should be week 1');
<ide> assert.equal(moment([2011, 0, 2]).week(), 1, 'Jan 2 2011 should be week 1');
<ide> test("weeks year starting saturday", function (assert) {
<ide> assert.equal(moment([2011, 0, 10]).week(), 3, 'Jan 10 2011 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting sunday formatted", function (assert) {
<add>test('weeks year starting sunday formatted', function (assert) {
<ide> assert.equal(moment([2011, 11, 26]).format('w ww wo'), '1 01 1a', 'Dec 26 2011 should be week 1');
<ide> assert.equal(moment([2012, 0, 1]).format('w ww wo'), '1 01 1a', 'Jan 1 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 2]).format('w ww wo'), '2 02 2a', 'Jan 2 2012 should be week 2');
<ide> assert.equal(moment([2012, 0, 8]).format('w ww wo'), '2 02 2a', 'Jan 8 2012 should be week 2');
<ide> assert.equal(moment([2012, 0, 9]).format('w ww wo'), '3 03 3a', 'Jan 9 2012 should be week 3');
<ide> });
<ide>
<del>test("lenient ordinal parsing", function (assert) {
<add>test('lenient ordinal parsing', function (assert) {
<ide> var i, ordinalStr, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> ordinalStr = moment([2014, 0, i]).format('YYYY MM Do');
<ide> test("lenient ordinal parsing", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("lenient ordinal parsing of number", function (assert) {
<add>test('lenient ordinal parsing of number', function (assert) {
<ide> var i, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> testMoment = moment('2014 01 ' + i, 'YYYY MM Do');
<ide> test("lenient ordinal parsing of number", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("strict ordinal parsing", function (assert) {
<add>test('strict ordinal parsing', function (assert) {
<ide> var i, ordinalStr, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> ordinalStr = moment([2014, 0, i]).format('YYYY MM Do');
<ide><path>src/test/locale/es.js
<del>import {localeModule, test} from "../qunit";
<del>import {moment} from "../../moment";
<del>localeModule("es");
<add>import {localeModule, test} from '../qunit';
<add>import {moment} from '../../moment';
<add>localeModule('es');
<ide>
<del>test("parse", function (assert) {
<add>test('parse', function (assert) {
<ide> var tests = 'enero ene._febrero feb._marzo mar._abril abr._mayo may._junio jun._julio jul._agosto ago._septiembre sep._octubre oct._noviembre nov._diciembre dic.'.split('_'), i;
<ide> function equalTest(input, mmm, i) {
<ide> assert.equal(moment(input, mmm).month(), i, input + ' should be month ' + (i + 1));
<ide> test("parse", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("format", function (assert) {
<add>test('format', function (assert) {
<ide> var a = [
<ide> ['dddd, MMMM Do YYYY, h:mm:ss a', 'domingo, febrero 14º 2010, 3:25:50 pm'],
<ide> ['ddd, hA', 'dom., 3PM'],
<ide> test("format", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("format ordinal", function (assert) {
<add>test('format ordinal', function (assert) {
<ide> assert.equal(moment([2011, 0, 1]).format('DDDo'), '1º', '1º');
<ide> assert.equal(moment([2011, 0, 2]).format('DDDo'), '2º', '2º');
<ide> assert.equal(moment([2011, 0, 3]).format('DDDo'), '3º', '3º');
<ide> test("format ordinal", function (assert) {
<ide> assert.equal(moment([2011, 0, 31]).format('DDDo'), '31º', '31º');
<ide> });
<ide>
<del>test("format month", function (assert) {
<add>test('format month', function (assert) {
<ide> var expected = 'enero ene._febrero feb._marzo mar._abril abr._mayo may._junio jun._julio jul._agosto ago._septiembre sep._octubre oct._noviembre nov._diciembre dic.'.split('_'), i;
<ide> for (i = 0; i < expected.length; i++) {
<ide> assert.equal(moment([2011, i, 1]).format('MMMM MMM'), expected[i], expected[i]);
<ide> }
<ide> });
<ide>
<del>test("format week", function (assert) {
<add>test('format week', function (assert) {
<ide> var expected = 'domingo dom. Do_lunes lun. Lu_martes mar. Ma_miércoles mié. Mi_jueves jue. Ju_viernes vie. Vi_sábado sáb. Sá'.split('_'), i;
<ide> for (i = 0; i < expected.length; i++) {
<ide> assert.equal(moment([2011, 0, 2 + i]).format('dddd ddd dd'), expected[i], expected[i]);
<ide> }
<ide> });
<ide>
<del>test("from", function (assert) {
<add>test('from', function (assert) {
<ide> var start = moment([2007, 1, 28]);
<ide> assert.equal(start.from(moment([2007, 1, 28]).add({s: 44}), true), 'unos segundos', '44 seconds = a few seconds');
<ide> assert.equal(start.from(moment([2007, 1, 28]).add({s: 45}), true), 'un minuto', '45 seconds = a minute');
<ide> test("from", function (assert) {
<ide> assert.equal(start.from(moment([2007, 1, 28]).add({y: 5}), true), '5 años', '5 years = 5 years');
<ide> });
<ide>
<del>test("suffix", function (assert) {
<add>test('suffix', function (assert) {
<ide> assert.equal(moment(30000).from(0), 'en unos segundos', 'prefix');
<ide> assert.equal(moment(0).from(30000), 'hace unos segundos', 'suffix');
<ide> });
<ide>
<del>test("now from now", function (assert) {
<add>test('now from now', function (assert) {
<ide> assert.equal(moment().fromNow(), 'hace unos segundos', 'now from now should display as in the past');
<ide> });
<ide>
<del>test("fromNow", function (assert) {
<add>test('fromNow', function (assert) {
<ide> assert.equal(moment().add({s: 30}).fromNow(), 'en unos segundos', 'en unos segundos');
<ide> assert.equal(moment().add({d: 5}).fromNow(), 'en 5 días', 'en 5 días');
<ide> });
<ide>
<del>test("calendar day", function (assert) {
<add>test('calendar day', function (assert) {
<ide> var a = moment().hours(2).minutes(0).seconds(0);
<ide>
<ide> assert.equal(moment(a).calendar(), 'hoy a las 2:00', 'today at the same time');
<ide> test("calendar day", function (assert) {
<ide> assert.equal(moment(a).subtract({d: 1}).calendar(), 'ayer a las 2:00', 'yesterday at the same time');
<ide> });
<ide>
<del>test("calendar next week", function (assert) {
<add>test('calendar next week', function (assert) {
<ide> var i, m;
<ide>
<ide> for (i = 2; i < 7; i++) {
<ide> test("calendar next week", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("calendar last week", function (assert) {
<add>test('calendar last week', function (assert) {
<ide> var i, m;
<ide>
<ide> for (i = 2; i < 7; i++) {
<ide> test("calendar last week", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("calendar all else", function (assert) {
<add>test('calendar all else', function (assert) {
<ide> var weeksAgo = moment().subtract({w: 1}),
<ide> weeksFromNow = moment().add({w: 1});
<ide>
<ide> test("calendar all else", function (assert) {
<ide> assert.equal(weeksFromNow.calendar(), weeksFromNow.format('L'), 'in 2 weeks');
<ide> });
<ide>
<del>test("weeks year starting sunday", function (assert) {
<add>test('weeks year starting sunday', function (assert) {
<ide> assert.equal(moment([2012, 0, 1]).week(), 52, 'Jan 1 2012 should be week 52');
<ide> assert.equal(moment([2012, 0, 2]).week(), 1, 'Jan 2 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 8]).week(), 1, 'Jan 8 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 9]).week(), 2, 'Jan 9 2012 should be week 2');
<ide> assert.equal(moment([2012, 0, 15]).week(), 2, 'Jan 15 2012 should be week 2');
<ide> });
<ide>
<del>test("weeks year starting monday", function (assert) {
<add>test('weeks year starting monday', function (assert) {
<ide> assert.equal(moment([2007, 0, 1]).week(), 1, 'Jan 1 2007 should be week 1');
<ide> assert.equal(moment([2007, 0, 7]).week(), 1, 'Jan 7 2007 should be week 1');
<ide> assert.equal(moment([2007, 0, 8]).week(), 2, 'Jan 8 2007 should be week 2');
<ide> assert.equal(moment([2007, 0, 14]).week(), 2, 'Jan 14 2007 should be week 2');
<ide> assert.equal(moment([2007, 0, 15]).week(), 3, 'Jan 15 2007 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting tuesday", function (assert) {
<add>test('weeks year starting tuesday', function (assert) {
<ide> assert.equal(moment([2007, 11, 31]).week(), 1, 'Dec 31 2007 should be week 1');
<ide> assert.equal(moment([2008, 0, 1]).week(), 1, 'Jan 1 2008 should be week 1');
<ide> assert.equal(moment([2008, 0, 6]).week(), 1, 'Jan 6 2008 should be week 1');
<ide> test("weeks year starting tuesday", function (assert) {
<ide> assert.equal(moment([2008, 0, 14]).week(), 3, 'Jan 14 2008 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting wednesday", function (assert) {
<add>test('weeks year starting wednesday', function (assert) {
<ide> assert.equal(moment([2002, 11, 30]).week(), 1, 'Dec 30 2002 should be week 1');
<ide> assert.equal(moment([2003, 0, 1]).week(), 1, 'Jan 1 2003 should be week 1');
<ide> assert.equal(moment([2003, 0, 5]).week(), 1, 'Jan 5 2003 should be week 1');
<ide> test("weeks year starting wednesday", function (assert) {
<ide> assert.equal(moment([2003, 0, 13]).week(), 3, 'Jan 13 2003 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting thursday", function (assert) {
<add>test('weeks year starting thursday', function (assert) {
<ide> assert.equal(moment([2008, 11, 29]).week(), 1, 'Dec 29 2008 should be week 1');
<ide> assert.equal(moment([2009, 0, 1]).week(), 1, 'Jan 1 2009 should be week 1');
<ide> assert.equal(moment([2009, 0, 4]).week(), 1, 'Jan 4 2009 should be week 1');
<ide> test("weeks year starting thursday", function (assert) {
<ide> assert.equal(moment([2009, 0, 13]).week(), 3, 'Jan 12 2009 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting friday", function (assert) {
<add>test('weeks year starting friday', function (assert) {
<ide> assert.equal(moment([2009, 11, 28]).week(), 53, 'Dec 28 2009 should be week 53');
<ide> assert.equal(moment([2010, 0, 1]).week(), 53, 'Jan 1 2010 should be week 53');
<ide> assert.equal(moment([2010, 0, 3]).week(), 53, 'Jan 3 2010 should be week 53');
<ide> test("weeks year starting friday", function (assert) {
<ide> assert.equal(moment([2010, 0, 11]).week(), 2, 'Jan 11 2010 should be week 2');
<ide> });
<ide>
<del>test("weeks year starting saturday", function (assert) {
<add>test('weeks year starting saturday', function (assert) {
<ide> assert.equal(moment([2010, 11, 27]).week(), 52, 'Dec 27 2010 should be week 52');
<ide> assert.equal(moment([2011, 0, 1]).week(), 52, 'Jan 1 2011 should be week 52');
<ide> assert.equal(moment([2011, 0, 2]).week(), 52, 'Jan 2 2011 should be week 52');
<ide> test("weeks year starting saturday", function (assert) {
<ide> assert.equal(moment([2011, 0, 10]).week(), 2, 'Jan 10 2011 should be week 2');
<ide> });
<ide>
<del>test("weeks year starting sunday formatted", function (assert) {
<add>test('weeks year starting sunday formatted', function (assert) {
<ide> assert.equal(moment([2012, 0, 1]).format('w ww wo'), '52 52 52º', 'Jan 1 2012 should be week 52');
<ide> assert.equal(moment([2012, 0, 2]).format('w ww wo'), '1 01 1º', 'Jan 2 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 8]).format('w ww wo'), '1 01 1º', 'Jan 8 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 9]).format('w ww wo'), '2 02 2º', 'Jan 9 2012 should be week 2');
<ide> assert.equal(moment([2012, 0, 15]).format('w ww wo'), '2 02 2º', 'Jan 15 2012 should be week 2');
<ide> });
<ide>
<del>test("lenient ordinal parsing", function (assert) {
<add>test('lenient ordinal parsing', function (assert) {
<ide> var i, ordinalStr, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> ordinalStr = moment([2014, 0, i]).format('YYYY MM Do');
<ide> test("lenient ordinal parsing", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("lenient ordinal parsing of number", function (assert) {
<add>test('lenient ordinal parsing of number', function (assert) {
<ide> var i, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> testMoment = moment('2014 01 ' + i, 'YYYY MM Do');
<ide> test("lenient ordinal parsing of number", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("strict ordinal parsing", function (assert) {
<add>test('strict ordinal parsing', function (assert) {
<ide> var i, ordinalStr, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> ordinalStr = moment([2014, 0, i]).format('YYYY MM Do');
<ide><path>src/test/locale/et.js
<del>import {localeModule, test} from "../qunit";
<del>import {moment} from "../../moment";
<del>localeModule("et");
<add>import {localeModule, test} from '../qunit';
<add>import {moment} from '../../moment';
<add>localeModule('et');
<ide>
<del>test("parse", function (assert) {
<add>test('parse', function (assert) {
<ide> var tests = 'jaanuar jaan_veebruar veebr_märts märts_aprill apr_mai mai_juuni juuni_juuli juuli_august aug_september sept_oktoober okt_november nov_detsember dets'.split('_'), i;
<ide> function equalTest(input, mmm, i) {
<ide> assert.equal(moment(input, mmm).month(), i, input + ' peaks olema kuu ' + (i + 1));
<ide> test("parse", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("format", function (assert) {
<add>test('format', function (assert) {
<ide> var a = [
<ide> ['dddd, Do MMMM YYYY, H:mm:ss', 'pühapäev, 14. veebruar 2010, 15:25:50'],
<ide> ['ddd, h', 'P, 3'],
<ide> test("format", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("format ordinal", function (assert) {
<add>test('format ordinal', function (assert) {
<ide> assert.equal(moment([2011, 0, 1]).format('DDDo'), '1.', '1.');
<ide> assert.equal(moment([2011, 0, 2]).format('DDDo'), '2.', '2.');
<ide> assert.equal(moment([2011, 0, 3]).format('DDDo'), '3.', '3.');
<ide> test("format ordinal", function (assert) {
<ide> assert.equal(moment([2011, 0, 31]).format('DDDo'), '31.', '31.');
<ide> });
<ide>
<del>test("format month", function (assert) {
<add>test('format month', function (assert) {
<ide> var expected = 'jaanuar jaan_veebruar veebr_märts märts_aprill apr_mai mai_juuni juuni_juuli juuli_august aug_september sept_oktoober okt_november nov_detsember dets'.split('_'), i;
<ide> for (i = 0; i < expected.length; i++) {
<ide> assert.equal(moment([2011, i, 1]).format('MMMM MMM'), expected[i], expected[i]);
<ide> }
<ide> });
<ide>
<del>test("format week", function (assert) {
<add>test('format week', function (assert) {
<ide> var expected = 'pühapäev P P_esmaspäev E E_teisipäev T T_kolmapäev K K_neljapäev N N_reede R R_laupäev L L'.split('_'), i;
<ide> for (i = 0; i < expected.length; i++) {
<ide> assert.equal(moment([2011, 0, 2 + i]).format('dddd ddd dd'), expected[i], expected[i]);
<ide> }
<ide> });
<ide>
<del>test("from", function (assert) {
<add>test('from', function (assert) {
<ide> var start = moment([2007, 1, 28]);
<ide> assert.equal(start.from(moment([2007, 1, 28]).add({s: 44}), true), 'paar sekundit', '44 seconds = paar sekundit');
<ide> assert.equal(start.from(moment([2007, 1, 28]).add({s: 45}), true), 'üks minut', '45 seconds = üks minut');
<ide> test("from", function (assert) {
<ide> assert.equal(start.from(moment([2007, 1, 28]).add({y: 5}), true), '5 aastat', '5 years = 5 aastat');
<ide> });
<ide>
<del>test("suffix", function (assert) {
<add>test('suffix', function (assert) {
<ide> assert.equal(moment(30000).from(0), 'mõne sekundi pärast', 'prefix');
<ide> assert.equal(moment(0).from(30000), 'mõni sekund tagasi', 'suffix');
<ide> });
<ide>
<del>test("now from now", function (assert) {
<add>test('now from now', function (assert) {
<ide> assert.equal(moment().fromNow(), 'mõni sekund tagasi', 'now from now should display as in the past');
<ide> });
<ide>
<del>test("fromNow", function (assert) {
<add>test('fromNow', function (assert) {
<ide> assert.equal(moment().add({s: 30}).fromNow(), 'mõne sekundi pärast', 'in a few seconds');
<ide> assert.equal(moment().subtract({s: 30}).fromNow(), 'mõni sekund tagasi', 'a few seconds ago');
<ide>
<ide> test("fromNow", function (assert) {
<ide> assert.equal(moment().subtract({y: 5}).fromNow(), '5 aastat tagasi', '5 years ago');
<ide> });
<ide>
<del>test("calendar day", function (assert) {
<add>test('calendar day', function (assert) {
<ide> var a = moment().hours(2).minutes(0).seconds(0);
<ide>
<ide> assert.equal(moment(a).calendar(), 'Täna, 2:00', 'today at the same time');
<ide> test("calendar day", function (assert) {
<ide> assert.equal(moment(a).subtract({d: 1}).calendar(), 'Eile, 2:00', 'yesterday at the same time');
<ide> });
<ide>
<del>test("calendar next week", function (assert) {
<add>test('calendar next week', function (assert) {
<ide> var i, m;
<ide> for (i = 2; i < 7; i++) {
<ide> m = moment().add({d: i});
<ide> test("calendar next week", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("calendar last week", function (assert) {
<add>test('calendar last week', function (assert) {
<ide> var i, m;
<ide> for (i = 2; i < 7; i++) {
<ide> m = moment().subtract({d: i});
<ide> test("calendar last week", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("calendar all else", function (assert) {
<add>test('calendar all else', function (assert) {
<ide> var weeksAgo = moment().subtract({w: 1}),
<ide> weeksFromNow = moment().add({w: 1});
<ide>
<ide> test("calendar all else", function (assert) {
<ide> assert.equal(weeksFromNow.calendar(), weeksFromNow.format('L'), '2 nädala pärast');
<ide> });
<ide>
<del>test("weeks year starting sunday", function (assert) {
<add>test('weeks year starting sunday', function (assert) {
<ide> assert.equal(moment([2012, 0, 1]).week(), 52, 'Jan 1 2012 should be week 52');
<ide> assert.equal(moment([2012, 0, 2]).week(), 1, 'Jan 2 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 8]).week(), 1, 'Jan 8 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 9]).week(), 2, 'Jan 9 2012 should be week 2');
<ide> assert.equal(moment([2012, 0, 15]).week(), 2, 'Jan 15 2012 should be week 2');
<ide> });
<ide>
<del>test("weeks year starting monday", function (assert) {
<add>test('weeks year starting monday', function (assert) {
<ide> assert.equal(moment([2007, 0, 1]).week(), 1, 'Jan 1 2007 should be week 1');
<ide> assert.equal(moment([2007, 0, 7]).week(), 1, 'Jan 7 2007 should be week 1');
<ide> assert.equal(moment([2007, 0, 8]).week(), 2, 'Jan 8 2007 should be week 2');
<ide> assert.equal(moment([2007, 0, 14]).week(), 2, 'Jan 14 2007 should be week 2');
<ide> assert.equal(moment([2007, 0, 15]).week(), 3, 'Jan 15 2007 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting tuesday", function (assert) {
<add>test('weeks year starting tuesday', function (assert) {
<ide> assert.equal(moment([2007, 11, 31]).week(), 1, 'Dec 31 2007 should be week 1');
<ide> assert.equal(moment([2008, 0, 1]).week(), 1, 'Jan 1 2008 should be week 1');
<ide> assert.equal(moment([2008, 0, 6]).week(), 1, 'Jan 6 2008 should be week 1');
<ide> test("weeks year starting tuesday", function (assert) {
<ide> assert.equal(moment([2008, 0, 14]).week(), 3, 'Jan 14 2008 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting wednesday", function (assert) {
<add>test('weeks year starting wednesday', function (assert) {
<ide> assert.equal(moment([2002, 11, 30]).week(), 1, 'Dec 30 2002 should be week 1');
<ide> assert.equal(moment([2003, 0, 1]).week(), 1, 'Jan 1 2003 should be week 1');
<ide> assert.equal(moment([2003, 0, 5]).week(), 1, 'Jan 5 2003 should be week 1');
<ide> test("weeks year starting wednesday", function (assert) {
<ide> assert.equal(moment([2003, 0, 13]).week(), 3, 'Jan 13 2003 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting thursday", function (assert) {
<add>test('weeks year starting thursday', function (assert) {
<ide> assert.equal(moment([2008, 11, 29]).week(), 1, 'Dec 29 2008 should be week 1');
<ide> assert.equal(moment([2009, 0, 1]).week(), 1, 'Jan 1 2009 should be week 1');
<ide> assert.equal(moment([2009, 0, 4]).week(), 1, 'Jan 4 2009 should be week 1');
<ide> test("weeks year starting thursday", function (assert) {
<ide> assert.equal(moment([2009, 0, 13]).week(), 3, 'Jan 12 2009 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting friday", function (assert) {
<add>test('weeks year starting friday', function (assert) {
<ide> assert.equal(moment([2009, 11, 28]).week(), 53, 'Dec 28 2009 should be week 53');
<ide> assert.equal(moment([2010, 0, 1]).week(), 53, 'Jan 1 2010 should be week 53');
<ide> assert.equal(moment([2010, 0, 3]).week(), 53, 'Jan 3 2010 should be week 53');
<ide> test("weeks year starting friday", function (assert) {
<ide> assert.equal(moment([2010, 0, 11]).week(), 2, 'Jan 11 2010 should be week 2');
<ide> });
<ide>
<del>test("weeks year starting saturday", function (assert) {
<add>test('weeks year starting saturday', function (assert) {
<ide> assert.equal(moment([2010, 11, 27]).week(), 52, 'Dec 27 2010 should be week 52');
<ide> assert.equal(moment([2011, 0, 1]).week(), 52, 'Jan 1 2011 should be week 52');
<ide> assert.equal(moment([2011, 0, 2]).week(), 52, 'Jan 2 2011 should be week 52');
<ide> test("weeks year starting saturday", function (assert) {
<ide> assert.equal(moment([2011, 0, 10]).week(), 2, 'Jan 10 2011 should be week 2');
<ide> });
<ide>
<del>test("weeks year starting sunday formatted", function (assert) {
<add>test('weeks year starting sunday formatted', function (assert) {
<ide> assert.equal(moment([2012, 0, 1]).format('w ww wo'), '52 52 52.', 'Jan 1 2012 should be week 52');
<ide> assert.equal(moment([2012, 0, 2]).format('w ww wo'), '1 01 1.', 'Jan 2 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 8]).format('w ww wo'), '1 01 1.', 'Jan 8 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 9]).format('w ww wo'), '2 02 2.', 'Jan 9 2012 should be week 2');
<ide> assert.equal(moment([2012, 0, 15]).format('w ww wo'), '2 02 2.', 'Jan 15 2012 should be week 2');
<ide> });
<ide>
<del>test("lenient ordinal parsing", function (assert) {
<add>test('lenient ordinal parsing', function (assert) {
<ide> var i, ordinalStr, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> ordinalStr = moment([2014, 0, i]).format('YYYY MM Do');
<ide> test("lenient ordinal parsing", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("lenient ordinal parsing of number", function (assert) {
<add>test('lenient ordinal parsing of number', function (assert) {
<ide> var i, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> testMoment = moment('2014 01 ' + i, 'YYYY MM Do');
<ide> test("lenient ordinal parsing of number", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("strict ordinal parsing", function (assert) {
<add>test('strict ordinal parsing', function (assert) {
<ide> var i, ordinalStr, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> ordinalStr = moment([2014, 0, i]).format('YYYY MM Do');
<ide><path>src/test/locale/eu.js
<del>import {localeModule, test} from "../qunit";
<del>import {moment} from "../../moment";
<del>localeModule("eu");
<add>import {localeModule, test} from '../qunit';
<add>import {moment} from '../../moment';
<add>localeModule('eu');
<ide>
<del>test("parse", function (assert) {
<add>test('parse', function (assert) {
<ide> var tests = 'urtarrila urt._otsaila ots._martxoa mar._apirila api._maiatza mai._ekaina eka._uztaila uzt._abuztua abu._iraila ira._urria urr._azaroa aza._abendua abe.'.split('_'), i;
<ide> function equalTest(input, mmm, i) {
<ide> assert.equal(moment(input, mmm).month(), i, input + ' should be month ' + (i + 1));
<ide> test("parse", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("format", function (assert) {
<add>test('format', function (assert) {
<ide> var a = [
<ide> ['dddd, MMMM Do YYYY, h:mm:ss a', 'igandea, otsaila 14. 2010, 3:25:50 pm'],
<ide> ['ddd, hA', 'ig., 3PM'],
<ide> test("format", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("format ordinal", function (assert) {
<add>test('format ordinal', function (assert) {
<ide> assert.equal(moment([2011, 0, 1]).format('DDDo'), '1.', '1.');
<ide> assert.equal(moment([2011, 0, 2]).format('DDDo'), '2.', '2.');
<ide> assert.equal(moment([2011, 0, 3]).format('DDDo'), '3.', '3.');
<ide> test("format ordinal", function (assert) {
<ide> assert.equal(moment([2011, 0, 31]).format('DDDo'), '31.', '31.');
<ide> });
<ide>
<del>test("format month", function (assert) {
<add>test('format month', function (assert) {
<ide> var expected = 'urtarrila urt._otsaila ots._martxoa mar._apirila api._maiatza mai._ekaina eka._uztaila uzt._abuztua abu._iraila ira._urria urr._azaroa aza._abendua abe.'.split('_'), i;
<ide> for (i = 0; i < expected.length; i++) {
<ide> assert.equal(moment([2011, i, 1]).format('MMMM MMM'), expected[i], expected[i]);
<ide> }
<ide> });
<ide>
<del>test("format week", function (assert) {
<add>test('format week', function (assert) {
<ide> var expected = 'igandea ig. ig_astelehena al. al_asteartea ar. ar_asteazkena az. az_osteguna og. og_ostirala ol. ol_larunbata lr. lr'.split('_'), i;
<ide> for (i = 0; i < expected.length; i++) {
<ide> assert.equal(moment([2011, 0, 2 + i]).format('dddd ddd dd'), expected[i], expected[i]);
<ide> }
<ide> });
<ide>
<del>test("from", function (assert) {
<add>test('from', function (assert) {
<ide> var start = moment([2007, 1, 28]);
<ide> assert.equal(start.from(moment([2007, 1, 28]).add({s: 44}), true), 'segundo batzuk', '44 seconds = a few seconds');
<ide> assert.equal(start.from(moment([2007, 1, 28]).add({s: 45}), true), 'minutu bat', '45 seconds = a minute');
<ide> test("from", function (assert) {
<ide> assert.equal(start.from(moment([2007, 1, 28]).add({y: 5}), true), '5 urte', '5 years = 5 years');
<ide> });
<ide>
<del>test("suffix", function (assert) {
<add>test('suffix', function (assert) {
<ide> assert.equal(moment(30000).from(0), 'segundo batzuk barru', 'prefix');
<ide> assert.equal(moment(0).from(30000), 'duela segundo batzuk', 'suffix');
<ide> });
<ide>
<del>test("now from now", function (assert) {
<add>test('now from now', function (assert) {
<ide> assert.equal(moment().fromNow(), 'duela segundo batzuk', 'now from now should display as in the past');
<ide> });
<ide>
<del>test("fromNow", function (assert) {
<add>test('fromNow', function (assert) {
<ide> assert.equal(moment().add({s: 30}).fromNow(), 'segundo batzuk barru', 'in seconds');
<ide> assert.equal(moment().add({d: 5}).fromNow(), '5 egun barru', 'in 5 days');
<ide> });
<ide>
<del>test("calendar day", function (assert) {
<add>test('calendar day', function (assert) {
<ide> var a = moment().hours(2).minutes(0).seconds(0);
<ide>
<ide> assert.equal(moment(a).calendar(), 'gaur 02:00etan', 'today at the same time');
<ide> test("calendar day", function (assert) {
<ide> assert.equal(moment(a).subtract({d: 1}).calendar(), 'atzo 02:00etan', 'yesterday at the same time');
<ide> });
<ide>
<del>test("calendar next week", function (assert) {
<add>test('calendar next week', function (assert) {
<ide> var i, m;
<ide> for (i = 2; i < 7; i++) {
<ide> m = moment().add({d: i});
<ide> test("calendar next week", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("calendar last week", function (assert) {
<add>test('calendar last week', function (assert) {
<ide> var i, m;
<ide> for (i = 2; i < 7; i++) {
<ide> m = moment().subtract({d: i});
<ide> test("calendar last week", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("calendar all else", function (assert) {
<add>test('calendar all else', function (assert) {
<ide> var weeksAgo = moment().subtract({w: 1}),
<ide> weeksFromNow = moment().add({w: 1});
<ide>
<ide> test("calendar all else", function (assert) {
<ide> assert.equal(weeksFromNow.calendar(), weeksFromNow.format('L'), 'in 2 weeks');
<ide> });
<ide>
<del>test("weeks year starting sunday", function (assert) {
<add>test('weeks year starting sunday', function (assert) {
<ide> assert.equal(moment([2011, 11, 26]).week(), 1, 'Dec 26 2011 should be week 1');
<ide> assert.equal(moment([2012, 0, 1]).week(), 1, 'Jan 1 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 2]).week(), 2, 'Jan 2 2012 should be week 2');
<ide> assert.equal(moment([2012, 0, 8]).week(), 2, 'Jan 8 2012 should be week 2');
<ide> assert.equal(moment([2012, 0, 9]).week(), 3, 'Jan 9 2012 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting monday", function (assert) {
<add>test('weeks year starting monday', function (assert) {
<ide> assert.equal(moment([2007, 0, 1]).week(), 1, 'Jan 1 2007 should be week 1');
<ide> assert.equal(moment([2007, 0, 7]).week(), 1, 'Jan 7 2007 should be week 1');
<ide> assert.equal(moment([2007, 0, 8]).week(), 2, 'Jan 8 2007 should be week 2');
<ide> assert.equal(moment([2007, 0, 14]).week(), 2, 'Jan 14 2007 should be week 2');
<ide> assert.equal(moment([2007, 0, 15]).week(), 3, 'Jan 15 2007 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting tuesday", function (assert) {
<add>test('weeks year starting tuesday', function (assert) {
<ide> assert.equal(moment([2007, 11, 31]).week(), 1, 'Dec 31 2007 should be week 1');
<ide> assert.equal(moment([2008, 0, 1]).week(), 1, 'Jan 1 2008 should be week 1');
<ide> assert.equal(moment([2008, 0, 6]).week(), 1, 'Jan 6 2008 should be week 1');
<ide> test("weeks year starting tuesday", function (assert) {
<ide> assert.equal(moment([2008, 0, 14]).week(), 3, 'Jan 14 2008 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting wednesday", function (assert) {
<add>test('weeks year starting wednesday', function (assert) {
<ide> assert.equal(moment([2002, 11, 30]).week(), 1, 'Dec 30 2002 should be week 1');
<ide> assert.equal(moment([2003, 0, 1]).week(), 1, 'Jan 1 2003 should be week 1');
<ide> assert.equal(moment([2003, 0, 5]).week(), 1, 'Jan 5 2003 should be week 1');
<ide> test("weeks year starting wednesday", function (assert) {
<ide> assert.equal(moment([2003, 0, 13]).week(), 3, 'Jan 13 2003 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting thursday", function (assert) {
<add>test('weeks year starting thursday', function (assert) {
<ide> assert.equal(moment([2008, 11, 29]).week(), 1, 'Dec 29 2008 should be week 1');
<ide> assert.equal(moment([2009, 0, 1]).week(), 1, 'Jan 1 2009 should be week 1');
<ide> assert.equal(moment([2009, 0, 4]).week(), 1, 'Jan 4 2009 should be week 1');
<ide> test("weeks year starting thursday", function (assert) {
<ide> assert.equal(moment([2009, 0, 12]).week(), 3, 'Jan 12 2009 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting friday", function (assert) {
<add>test('weeks year starting friday', function (assert) {
<ide> assert.equal(moment([2009, 11, 28]).week(), 1, 'Dec 28 2009 should be week 1');
<ide> assert.equal(moment([2010, 0, 1]).week(), 1, 'Jan 1 2010 should be week 1');
<ide> assert.equal(moment([2010, 0, 3]).week(), 1, 'Jan 3 2010 should be week 1');
<ide> test("weeks year starting friday", function (assert) {
<ide> assert.equal(moment([2010, 0, 11]).week(), 3, 'Jan 11 2010 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting saturday", function (assert) {
<add>test('weeks year starting saturday', function (assert) {
<ide> assert.equal(moment([2010, 11, 27]).week(), 1, 'Dec 27 2010 should be week 1');
<ide> assert.equal(moment([2011, 0, 1]).week(), 1, 'Jan 1 2011 should be week 1');
<ide> assert.equal(moment([2011, 0, 2]).week(), 1, 'Jan 2 2011 should be week 1');
<ide> test("weeks year starting saturday", function (assert) {
<ide> assert.equal(moment([2011, 0, 10]).week(), 3, 'Jan 10 2011 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting sunday formatted", function (assert) {
<add>test('weeks year starting sunday formatted', function (assert) {
<ide> assert.equal(moment([2011, 11, 26]).format('w ww wo'), '1 01 1.', 'Dec 26 2011 should be week 1');
<ide> assert.equal(moment([2012, 0, 1]).format('w ww wo'), '1 01 1.', 'Jan 1 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 2]).format('w ww wo'), '2 02 2.', 'Jan 2 2012 should be week 2');
<ide> assert.equal(moment([2012, 0, 8]).format('w ww wo'), '2 02 2.', 'Jan 8 2012 should be week 2');
<ide> assert.equal(moment([2012, 0, 9]).format('w ww wo'), '3 03 3.', 'Jan 9 2012 should be week 3');
<ide> });
<ide>
<del>test("lenient ordinal parsing", function (assert) {
<add>test('lenient ordinal parsing', function (assert) {
<ide> var i, ordinalStr, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> ordinalStr = moment([2014, 0, i]).format('YYYY MM Do');
<ide> test("lenient ordinal parsing", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("lenient ordinal parsing of number", function (assert) {
<add>test('lenient ordinal parsing of number', function (assert) {
<ide> var i, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> testMoment = moment('2014 01 ' + i, 'YYYY MM Do');
<ide> test("lenient ordinal parsing of number", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("strict ordinal parsing", function (assert) {
<add>test('strict ordinal parsing', function (assert) {
<ide> var i, ordinalStr, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> ordinalStr = moment([2014, 0, i]).format('YYYY MM Do');
<ide><path>src/test/locale/fa.js
<del>import {localeModule, test} from "../qunit";
<del>import {moment} from "../../moment";
<del>localeModule("fa");
<add>import {localeModule, test} from '../qunit';
<add>import {moment} from '../../moment';
<add>localeModule('fa');
<ide>
<del>test("parse", function (assert) {
<add>test('parse', function (assert) {
<ide> var tests = 'ژانویه_فوریه_مارس_آوریل_مه_ژوئن_ژوئیه_اوت_سپتامبر_اکتبر_نوامبر_دسامبر'.split('_'), i;
<ide> function equalTest(input, mmm, i) {
<ide> assert.equal(moment(input, mmm).month(), i, input + ' should be month ' + (i + 1) + ' instead is month ' + moment(input, mmm).month());
<ide> test("parse", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("format", function (assert) {
<add>test('format', function (assert) {
<ide> var a = [
<ide> ['dddd, MMMM Do YYYY, h:mm:ss a', 'یک\u200cشنبه، فوریه ۱۴م ۲۰۱۰، ۳:۲۵:۵۰ بعد از ظهر'],
<ide> ['ddd, hA', 'یک\u200cشنبه، ۳بعد از ظهر'],
<ide> test("format", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("format ordinal", function (assert) {
<add>test('format ordinal', function (assert) {
<ide> assert.equal(moment([2011, 0, 1]).format('DDDo'), '۱م', '1');
<ide> assert.equal(moment([2011, 0, 2]).format('DDDo'), '۲م', '2');
<ide> assert.equal(moment([2011, 0, 3]).format('DDDo'), '۳م', '3');
<ide> test("format ordinal", function (assert) {
<ide> assert.equal(moment([2011, 0, 31]).format('DDDo'), '۳۱م', '31');
<ide> });
<ide>
<del>test("format month", function (assert) {
<add>test('format month', function (assert) {
<ide> var expected = 'ژانویه ژانویه_فوریه فوریه_مارس مارس_آوریل آوریل_مه مه_ژوئن ژوئن_ژوئیه ژوئیه_اوت اوت_سپتامبر سپتامبر_اکتبر اکتبر_نوامبر نوامبر_دسامبر دسامبر'.split('_'), i;
<ide> for (i = 0; i < expected.length; i++) {
<ide> assert.equal(moment([2011, i, 1]).format('MMMM MMM'), expected[i], expected[i]);
<ide> }
<ide> });
<ide>
<del>test("format week", function (assert) {
<add>test('format week', function (assert) {
<ide> var expected = 'یک\u200cشنبه یک\u200cشنبه ی_دوشنبه دوشنبه د_سه\u200cشنبه سه\u200cشنبه س_چهارشنبه چهارشنبه چ_پنج\u200cشنبه پنج\u200cشنبه پ_جمعه جمعه ج_شنبه شنبه ش'.split('_'), i;
<ide> for (i = 0; i < expected.length; i++) {
<ide> assert.equal(moment([2011, 0, 2 + i]).format('dddd ddd dd'), expected[i], expected[i]);
<ide> }
<ide> });
<ide>
<del>test("from", function (assert) {
<add>test('from', function (assert) {
<ide> var start = moment([2007, 1, 28]);
<ide> assert.equal(start.from(moment([2007, 1, 28]).add({s: 44}), true), 'چندین ثانیه', '44 seconds = a few seconds');
<ide> assert.equal(start.from(moment([2007, 1, 28]).add({s: 45}), true), 'یک دقیقه', '45 seconds = a minute');
<ide> test("from", function (assert) {
<ide> assert.equal(start.from(moment([2007, 1, 28]).add({y: 5}), true), '۵ سال', '5 years = 5 years');
<ide> });
<ide>
<del>test("suffix", function (assert) {
<add>test('suffix', function (assert) {
<ide> assert.equal(moment(30000).from(0), 'در چندین ثانیه', 'prefix');
<ide> assert.equal(moment(0).from(30000), 'چندین ثانیه پیش', 'suffix');
<ide> });
<ide>
<del>test("now from now", function (assert) {
<add>test('now from now', function (assert) {
<ide> assert.equal(moment().fromNow(), 'چندین ثانیه پیش', 'now from now should display as in the past');
<ide> });
<ide>
<del>test("fromNow", function (assert) {
<add>test('fromNow', function (assert) {
<ide> assert.equal(moment().add({s: 30}).fromNow(), 'در چندین ثانیه', 'in a few seconds');
<ide> assert.equal(moment().add({d: 5}).fromNow(), 'در ۵ روز', 'in 5 days');
<ide> });
<ide>
<del>test("calendar day", function (assert) {
<add>test('calendar day', function (assert) {
<ide> var a = moment().hours(2).minutes(0).seconds(0);
<ide>
<ide> assert.equal(moment(a).calendar(), 'امروز ساعت ۰۲:۰۰', 'today at the same time');
<ide> test("calendar day", function (assert) {
<ide> assert.equal(moment(a).subtract({d: 1}).calendar(), 'دیروز ساعت ۰۲:۰۰', 'yesterday at the same time');
<ide> });
<ide>
<del>test("calendar next week", function (assert) {
<add>test('calendar next week', function (assert) {
<ide> var i, m;
<ide> for (i = 2; i < 7; i++) {
<ide> m = moment().add({d: i});
<ide> test("calendar next week", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("calendar last week", function (assert) {
<add>test('calendar last week', function (assert) {
<ide> var i, m;
<ide> for (i = 2; i < 7; i++) {
<ide> m = moment().subtract({d: i});
<ide> test("calendar last week", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("calendar all else", function (assert) {
<add>test('calendar all else', function (assert) {
<ide> var weeksAgo = moment().subtract({w: 1}),
<ide> weeksFromNow = moment().add({w: 1});
<ide>
<ide> test("calendar all else", function (assert) {
<ide> assert.equal(weeksFromNow.calendar(), weeksFromNow.format('L'), 'in 2 weeks');
<ide> });
<ide>
<del>test("weeks year starting sunday", function (assert) {
<add>test('weeks year starting sunday', function (assert) {
<ide> assert.equal(moment([2011, 11, 31]).week(), 1, 'Dec 31 2011 should be week 1');
<ide> assert.equal(moment([2012, 0, 6]).week(), 1, 'Jan 6 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 7]).week(), 2, 'Jan 7 2012 should be week 2');
<ide> assert.equal(moment([2012, 0, 13]).week(), 2, 'Jan 13 2012 should be week 2');
<ide> assert.equal(moment([2012, 0, 14]).week(), 3, 'Jan 14 2012 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting monday", function (assert) {
<add>test('weeks year starting monday', function (assert) {
<ide> assert.equal(moment([2006, 11, 30]).week(), 1, 'Dec 30 2006 should be week 1');
<ide> assert.equal(moment([2007, 0, 5]).week(), 1, 'Jan 5 2007 should be week 1');
<ide> assert.equal(moment([2007, 0, 6]).week(), 2, 'Jan 6 2007 should be week 2');
<ide> assert.equal(moment([2007, 0, 12]).week(), 2, 'Jan 12 2007 should be week 2');
<ide> assert.equal(moment([2007, 0, 13]).week(), 3, 'Jan 13 2007 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting tuesday", function (assert) {
<add>test('weeks year starting tuesday', function (assert) {
<ide> assert.equal(moment([2007, 11, 29]).week(), 1, 'Dec 29 2007 should be week 1');
<ide> assert.equal(moment([2008, 0, 1]).week(), 1, 'Jan 1 2008 should be week 1');
<ide> assert.equal(moment([2008, 0, 4]).week(), 1, 'Jan 4 2008 should be week 1');
<ide> test("weeks year starting tuesday", function (assert) {
<ide> assert.equal(moment([2008, 0, 12]).week(), 3, 'Jan 12 2008 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting wednesday", function (assert) {
<add>test('weeks year starting wednesday', function (assert) {
<ide> assert.equal(moment([2002, 11, 28]).week(), 1, 'Dec 28 2002 should be week 1');
<ide> assert.equal(moment([2003, 0, 1]).week(), 1, 'Jan 1 2003 should be week 1');
<ide> assert.equal(moment([2003, 0, 3]).week(), 1, 'Jan 3 2003 should be week 1');
<ide> test("weeks year starting wednesday", function (assert) {
<ide> assert.equal(moment([2003, 0, 11]).week(), 3, 'Jan 11 2003 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting thursday", function (assert) {
<add>test('weeks year starting thursday', function (assert) {
<ide> assert.equal(moment([2008, 11, 27]).week(), 1, 'Dec 27 2008 should be week 1');
<ide> assert.equal(moment([2009, 0, 1]).week(), 1, 'Jan 1 2009 should be week 1');
<ide> assert.equal(moment([2009, 0, 2]).week(), 1, 'Jan 2 2009 should be week 1');
<ide> test("weeks year starting thursday", function (assert) {
<ide> assert.equal(moment([2009, 0, 10]).week(), 3, 'Jan 10 2009 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting friday", function (assert) {
<add>test('weeks year starting friday', function (assert) {
<ide> assert.equal(moment([2009, 11, 26]).week(), 1, 'Dec 26 2009 should be week 1');
<ide> assert.equal(moment([2010, 0, 1]).week(), 1, 'Jan 1 2010 should be week 1');
<ide> assert.equal(moment([2010, 0, 2]).week(), 2, 'Jan 2 2010 should be week 2');
<ide> assert.equal(moment([2010, 0, 8]).week(), 2, 'Jan 8 2010 should be week 2');
<ide> assert.equal(moment([2010, 0, 9]).week(), 3, 'Jan 9 2010 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting saturday", function (assert) {
<add>test('weeks year starting saturday', function (assert) {
<ide> assert.equal(moment([2011, 0, 1]).week(), 1, 'Jan 1 2011 should be week 1');
<ide> assert.equal(moment([2011, 0, 7]).week(), 1, 'Jan 7 2011 should be week 1');
<ide> assert.equal(moment([2011, 0, 8]).week(), 2, 'Jan 8 2011 should be week 2');
<ide> assert.equal(moment([2011, 0, 14]).week(), 2, 'Jan 14 2011 should be week 2');
<ide> assert.equal(moment([2011, 0, 15]).week(), 3, 'Jan 15 2011 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting sunday formatted", function (assert) {
<add>test('weeks year starting sunday formatted', function (assert) {
<ide> assert.equal(moment([2011, 11, 31]).format('w ww wo'), '۱ ۰۱ ۱م', 'Dec 31 2011 should be week 1');
<ide> assert.equal(moment([2012, 0, 6]).format('w ww wo'), '۱ ۰۱ ۱م', 'Jan 6 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 7]).format('w ww wo'), '۲ ۰۲ ۲م', 'Jan 7 2012 should be week 2');
<ide> assert.equal(moment([2012, 0, 13]).format('w ww wo'), '۲ ۰۲ ۲م', 'Jan 13 2012 should be week 2');
<ide> assert.equal(moment([2012, 0, 14]).format('w ww wo'), '۳ ۰۳ ۳م', 'Jan 14 2012 should be week 3');
<ide> });
<ide>
<del>test("lenient ordinal parsing", function (assert) {
<add>test('lenient ordinal parsing', function (assert) {
<ide> var i, ordinalStr, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> ordinalStr = moment([2014, 0, i]).format('YYYY MM Do');
<ide> test("lenient ordinal parsing", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("lenient ordinal parsing of number", function (assert) {
<add>test('lenient ordinal parsing of number', function (assert) {
<ide> var i, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> testMoment = moment('2014 01 ' + i, 'YYYY MM Do');
<ide> test("lenient ordinal parsing of number", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("strict ordinal parsing", function (assert) {
<add>test('strict ordinal parsing', function (assert) {
<ide> var i, ordinalStr, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> ordinalStr = moment([2014, 0, i]).format('YYYY MM Do');
<ide><path>src/test/locale/fi.js
<del>import {localeModule, test} from "../qunit";
<del>import {moment} from "../../moment";
<del>localeModule("fi");
<add>import {localeModule, test} from '../qunit';
<add>import {moment} from '../../moment';
<add>localeModule('fi');
<ide>
<del>test("parse", function (assert) {
<add>test('parse', function (assert) {
<ide> var tests = 'tammikuu tammi_helmikuu helmi_maaliskuu maalis_huhtikuu huhti_toukokuu touko_kesäkuu kesä_heinäkuu heinä_elokuu elo_syyskuu syys_lokakuu loka_marraskuu marras_joulukuu joulu'.split('_'), i;
<ide> function equalTest(input, mmm, i) {
<ide> assert.equal(moment(input, mmm).month(), i, input + ' should be month ' + (i + 1));
<ide> test("parse", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("format", function (assert) {
<add>test('format', function (assert) {
<ide> var a = [
<ide> ['dddd, MMMM Do YYYY, h:mm:ss a', 'sunnuntai, helmikuu 14. 2010, 3:25:50 pm'],
<ide> ['ddd, hA', 'su, 3PM'],
<ide> test("format", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("format ordinal", function (assert) {
<add>test('format ordinal', function (assert) {
<ide> assert.equal(moment([2011, 0, 1]).format('DDDo'), '1.', '1st');
<ide> assert.equal(moment([2011, 0, 2]).format('DDDo'), '2.', '2nd');
<ide> assert.equal(moment([2011, 0, 3]).format('DDDo'), '3.', '3rd');
<ide> test("format ordinal", function (assert) {
<ide> assert.equal(moment([2011, 0, 31]).format('DDDo'), '31.', '31st');
<ide> });
<ide>
<del>test("format month", function (assert) {
<add>test('format month', function (assert) {
<ide> var expected = 'tammikuu tammi_helmikuu helmi_maaliskuu maalis_huhtikuu huhti_toukokuu touko_kesäkuu kesä_heinäkuu heinä_elokuu elo_syyskuu syys_lokakuu loka_marraskuu marras_joulukuu joulu'.split('_'), i;
<ide> for (i = 0; i < expected.length; i++) {
<ide> assert.equal(moment([2011, i, 1]).format('MMMM MMM'), expected[i], expected[i]);
<ide> }
<ide> });
<ide>
<del>test("format week", function (assert) {
<add>test('format week', function (assert) {
<ide> var expected = 'sunnuntai su su_maanantai ma ma_tiistai ti ti_keskiviikko ke ke_torstai to to_perjantai pe pe_lauantai la la'.split('_'), i;
<ide> for (i = 0; i < expected.length; i++) {
<ide> assert.equal(moment([2011, 0, 2 + i]).format('dddd ddd dd'), expected[i], expected[i]);
<ide> }
<ide> });
<ide>
<del>test("from", function (assert) {
<add>test('from', function (assert) {
<ide> var start = moment([2007, 1, 28]);
<ide> assert.equal(start.from(moment([2007, 1, 28]).add({s: 44}), true), 'muutama sekunti', '44 seconds = few seconds');
<ide> assert.equal(start.from(moment([2007, 1, 28]).add({s: 45}), true), 'minuutti', '45 seconds = a minute');
<ide> test("from", function (assert) {
<ide> assert.equal(start.from(moment([2007, 1, 28]).add({y: 5}), true), 'viisi vuotta', '5 years = 5 years');
<ide> });
<ide>
<del>test("suffix", function (assert) {
<add>test('suffix', function (assert) {
<ide> assert.equal(moment(30000).from(0), 'muutaman sekunnin päästä', 'prefix');
<ide> assert.equal(moment(0).from(30000), 'muutama sekunti sitten', 'suffix');
<ide> });
<ide>
<del>test("now from now", function (assert) {
<add>test('now from now', function (assert) {
<ide> assert.equal(moment().fromNow(), 'muutama sekunti sitten', 'now from now should display as in the past');
<ide> });
<ide>
<del>test("fromNow", function (assert) {
<add>test('fromNow', function (assert) {
<ide> assert.equal(moment().add({s: 30}).fromNow(), 'muutaman sekunnin päästä', 'in a few seconds');
<ide> assert.equal(moment().add({d: 5}).fromNow(), 'viiden päivän päästä', 'in 5 days');
<ide> });
<ide>
<del>test("calendar day", function (assert) {
<add>test('calendar day', function (assert) {
<ide> var a = moment().hours(2).minutes(0).seconds(0);
<ide>
<ide> assert.equal(moment(a).calendar(), 'tänään klo 02.00', 'today at the same time');
<ide> test("calendar day", function (assert) {
<ide> assert.equal(moment(a).subtract({d: 1}).calendar(), 'eilen klo 02.00', 'yesterday at the same time');
<ide> });
<ide>
<del>test("calendar next week", function (assert) {
<add>test('calendar next week', function (assert) {
<ide> var i, m;
<ide>
<ide> for (i = 2; i < 7; i++) {
<ide> test("calendar next week", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("calendar last week", function (assert) {
<add>test('calendar last week', function (assert) {
<ide> var i, m;
<ide> for (i = 2; i < 7; i++) {
<ide> m = moment().subtract({d: i});
<ide> test("calendar last week", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("calendar all else", function (assert) {
<add>test('calendar all else', function (assert) {
<ide> var weeksAgo = moment().subtract({w: 1}),
<ide> weeksFromNow = moment().add({w: 1});
<ide>
<ide> test("calendar all else", function (assert) {
<ide> assert.equal(weeksFromNow.calendar(), weeksFromNow.format('L'), 'kaden viikon päästä');
<ide> });
<ide>
<del>test("weeks year starting sunday", function (assert) {
<add>test('weeks year starting sunday', function (assert) {
<ide> assert.equal(moment([2012, 0, 1]).week(), 52, 'Jan 1 2012 should be week 52');
<ide> assert.equal(moment([2012, 0, 2]).week(), 1, 'Jan 2 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 8]).week(), 1, 'Jan 8 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 9]).week(), 2, 'Jan 9 2012 should be week 2');
<ide> assert.equal(moment([2012, 0, 15]).week(), 2, 'Jan 15 2012 should be week 2');
<ide> });
<ide>
<del>test("weeks year starting monday", function (assert) {
<add>test('weeks year starting monday', function (assert) {
<ide> assert.equal(moment([2007, 0, 1]).week(), 1, 'Jan 1 2007 should be week 1');
<ide> assert.equal(moment([2007, 0, 7]).week(), 1, 'Jan 7 2007 should be week 1');
<ide> assert.equal(moment([2007, 0, 8]).week(), 2, 'Jan 8 2007 should be week 2');
<ide> assert.equal(moment([2007, 0, 14]).week(), 2, 'Jan 14 2007 should be week 2');
<ide> assert.equal(moment([2007, 0, 15]).week(), 3, 'Jan 15 2007 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting tuesday", function (assert) {
<add>test('weeks year starting tuesday', function (assert) {
<ide> assert.equal(moment([2007, 11, 31]).week(), 1, 'Dec 31 2007 should be week 1');
<ide> assert.equal(moment([2008, 0, 1]).week(), 1, 'Jan 1 2008 should be week 1');
<ide> assert.equal(moment([2008, 0, 6]).week(), 1, 'Jan 6 2008 should be week 1');
<ide> test("weeks year starting tuesday", function (assert) {
<ide> assert.equal(moment([2008, 0, 14]).week(), 3, 'Jan 14 2008 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting wednesday", function (assert) {
<add>test('weeks year starting wednesday', function (assert) {
<ide> assert.equal(moment([2002, 11, 30]).week(), 1, 'Dec 30 2002 should be week 1');
<ide> assert.equal(moment([2003, 0, 1]).week(), 1, 'Jan 1 2003 should be week 1');
<ide> assert.equal(moment([2003, 0, 5]).week(), 1, 'Jan 5 2003 should be week 1');
<ide> test("weeks year starting wednesday", function (assert) {
<ide> assert.equal(moment([2003, 0, 13]).week(), 3, 'Jan 13 2003 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting thursday", function (assert) {
<add>test('weeks year starting thursday', function (assert) {
<ide> assert.equal(moment([2008, 11, 29]).week(), 1, 'Dec 29 2008 should be week 1');
<ide> assert.equal(moment([2009, 0, 1]).week(), 1, 'Jan 1 2009 should be week 1');
<ide> assert.equal(moment([2009, 0, 4]).week(), 1, 'Jan 4 2009 should be week 1');
<ide> test("weeks year starting thursday", function (assert) {
<ide> assert.equal(moment([2009, 0, 13]).week(), 3, 'Jan 12 2009 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting friday", function (assert) {
<add>test('weeks year starting friday', function (assert) {
<ide> assert.equal(moment([2009, 11, 28]).week(), 53, 'Dec 28 2009 should be week 53');
<ide> assert.equal(moment([2010, 0, 1]).week(), 53, 'Jan 1 2010 should be week 53');
<ide> assert.equal(moment([2010, 0, 3]).week(), 53, 'Jan 3 2010 should be week 53');
<ide> test("weeks year starting friday", function (assert) {
<ide> assert.equal(moment([2010, 0, 11]).week(), 2, 'Jan 11 2010 should be week 2');
<ide> });
<ide>
<del>test("weeks year starting saturday", function (assert) {
<add>test('weeks year starting saturday', function (assert) {
<ide> assert.equal(moment([2010, 11, 27]).week(), 52, 'Dec 27 2010 should be week 52');
<ide> assert.equal(moment([2011, 0, 1]).week(), 52, 'Jan 1 2011 should be week 52');
<ide> assert.equal(moment([2011, 0, 2]).week(), 52, 'Jan 2 2011 should be week 52');
<ide> test("weeks year starting saturday", function (assert) {
<ide> assert.equal(moment([2011, 0, 10]).week(), 2, 'Jan 10 2011 should be week 2');
<ide> });
<ide>
<del>test("weeks year starting sunday formatted", function (assert) {
<add>test('weeks year starting sunday formatted', function (assert) {
<ide> assert.equal(moment([2012, 0, 1]).format('w ww wo'), '52 52 52.', 'Jan 1 2012 should be week 52');
<ide> assert.equal(moment([2012, 0, 2]).format('w ww wo'), '1 01 1.', 'Jan 2 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 8]).format('w ww wo'), '1 01 1.', 'Jan 8 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 9]).format('w ww wo'), '2 02 2.', 'Jan 9 2012 should be week 2');
<ide> assert.equal(moment([2012, 0, 15]).format('w ww wo'), '2 02 2.', 'Jan 15 2012 should be week 2');
<ide> });
<ide>
<del>test("lenient ordinal parsing", function (assert) {
<add>test('lenient ordinal parsing', function (assert) {
<ide> var i, ordinalStr, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> ordinalStr = moment([2014, 0, i]).format('YYYY MM Do');
<ide> test("lenient ordinal parsing", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("lenient ordinal parsing of number", function (assert) {
<add>test('lenient ordinal parsing of number', function (assert) {
<ide> var i, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> testMoment = moment('2014 01 ' + i, 'YYYY MM Do');
<ide> test("lenient ordinal parsing of number", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("strict ordinal parsing", function (assert) {
<add>test('strict ordinal parsing', function (assert) {
<ide> var i, ordinalStr, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> ordinalStr = moment([2014, 0, i]).format('YYYY MM Do');
<ide><path>src/test/locale/fo.js
<del>import {localeModule, test} from "../qunit";
<del>import {moment} from "../../moment";
<del>localeModule("fo");
<add>import {localeModule, test} from '../qunit';
<add>import {moment} from '../../moment';
<add>localeModule('fo');
<ide>
<del>test("parse", function (assert) {
<add>test('parse', function (assert) {
<ide> var tests = 'januar jan_februar feb_mars mar_apríl apr_mai mai_juni jun_juli jul_august aug_september sep_oktober okt_november nov_desember des'.split('_'), i;
<ide> function equalTest(input, mmm, i) {
<ide> assert.equal(moment(input, mmm).month(), i, input + ' should be month ' + (i + 1));
<ide> test("parse", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("format", function (assert) {
<add>test('format', function (assert) {
<ide> var a = [
<ide> ['dddd [tann] Do MMMM YYYY, h:mm:ss a', 'sunnudagur tann 14. februar 2010, 3:25:50 pm'],
<ide> ['ddd hA', 'sun 3PM'],
<ide> test("format", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("format ordinal", function (assert) {
<add>test('format ordinal', function (assert) {
<ide> assert.equal(moment([2011, 0, 1]).format('DDDo'), '1.', '1.');
<ide> assert.equal(moment([2011, 0, 2]).format('DDDo'), '2.', '2.');
<ide> assert.equal(moment([2011, 0, 3]).format('DDDo'), '3.', '3.');
<ide> test("format ordinal", function (assert) {
<ide> assert.equal(moment([2011, 0, 31]).format('DDDo'), '31.', '31.');
<ide> });
<ide>
<del>test("format month", function (assert) {
<add>test('format month', function (assert) {
<ide> var expected = 'januar jan_februar feb_mars mar_apríl apr_mai mai_juni jun_juli jul_august aug_september sep_oktober okt_november nov_desember des'.split('_'), i;
<ide> for (i = 0; i < expected.length; i++) {
<ide> assert.equal(moment([2011, i, 1]).format('MMMM MMM'), expected[i], expected[i]);
<ide> }
<ide> });
<ide>
<del>test("format week", function (assert) {
<add>test('format week', function (assert) {
<ide> var expected = 'sunnudagur sun su_mánadagur mán má_týsdagur týs tý_mikudagur mik mi_hósdagur hós hó_fríggjadagur frí fr_leygardagur ley le'.split('_'), i;
<ide> for (i = 0; i < expected.length; i++) {
<ide> assert.equal(moment([2011, 0, 2 + i]).format('dddd ddd dd'), expected[i], expected[i]);
<ide> }
<ide> });
<ide>
<del>test("from", function (assert) {
<add>test('from', function (assert) {
<ide> var start = moment([2007, 1, 28]);
<ide> assert.equal(start.from(moment([2007, 1, 28]).add({s: 44}), true), 'fá sekund', '44 seconds = a few seconds');
<ide> assert.equal(start.from(moment([2007, 1, 28]).add({s: 45}), true), 'ein minutt', '45 seconds = a minute');
<ide> test("from", function (assert) {
<ide> assert.equal(start.from(moment([2007, 1, 28]).add({y: 5}), true), '5 ár', '5 years = 5 years');
<ide> });
<ide>
<del>test("suffix", function (assert) {
<add>test('suffix', function (assert) {
<ide> assert.equal(moment(30000).from(0), 'um fá sekund', 'prefix');
<ide> assert.equal(moment(0).from(30000), 'fá sekund síðani', 'suffix');
<ide> });
<ide>
<del>test("now from now", function (assert) {
<add>test('now from now', function (assert) {
<ide> assert.equal(moment().fromNow(), 'fá sekund síðani', 'now from now should display as in the past');
<ide> });
<ide>
<del>test("fromNow", function (assert) {
<add>test('fromNow', function (assert) {
<ide> assert.equal(moment().add({s: 30}).fromNow(), 'um fá sekund', 'in a few seconds');
<ide> assert.equal(moment().add({d: 5}).fromNow(), 'um 5 dagar', 'in 5 days');
<ide> });
<ide>
<del>test("weeks year starting sunday", function (assert) {
<add>test('weeks year starting sunday', function (assert) {
<ide> assert.equal(moment([2012, 0, 1]).week(), 52, 'Jan 1 2012 should be week 52');
<ide> assert.equal(moment([2012, 0, 2]).week(), 1, 'Jan 2 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 8]).week(), 1, 'Jan 8 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 9]).week(), 2, 'Jan 9 2012 should be week 2');
<ide> assert.equal(moment([2012, 0, 15]).week(), 2, 'Jan 15 2012 should be week 2');
<ide> });
<ide>
<del>test("weeks year starting monday", function (assert) {
<add>test('weeks year starting monday', function (assert) {
<ide> assert.equal(moment([2007, 0, 1]).week(), 1, 'Jan 1 2007 should be week 1');
<ide> assert.equal(moment([2007, 0, 7]).week(), 1, 'Jan 7 2007 should be week 1');
<ide> assert.equal(moment([2007, 0, 8]).week(), 2, 'Jan 8 2007 should be week 2');
<ide> assert.equal(moment([2007, 0, 14]).week(), 2, 'Jan 14 2007 should be week 2');
<ide> assert.equal(moment([2007, 0, 15]).week(), 3, 'Jan 15 2007 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting tuesday", function (assert) {
<add>test('weeks year starting tuesday', function (assert) {
<ide> assert.equal(moment([2007, 11, 31]).week(), 1, 'Dec 31 2007 should be week 1');
<ide> assert.equal(moment([2008, 0, 1]).week(), 1, 'Jan 1 2008 should be week 1');
<ide> assert.equal(moment([2008, 0, 6]).week(), 1, 'Jan 6 2008 should be week 1');
<ide> test("weeks year starting tuesday", function (assert) {
<ide> assert.equal(moment([2008, 0, 14]).week(), 3, 'Jan 14 2008 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting wednesday", function (assert) {
<add>test('weeks year starting wednesday', function (assert) {
<ide> assert.equal(moment([2002, 11, 30]).week(), 1, 'Dec 30 2002 should be week 1');
<ide> assert.equal(moment([2003, 0, 1]).week(), 1, 'Jan 1 2003 should be week 1');
<ide> assert.equal(moment([2003, 0, 5]).week(), 1, 'Jan 5 2003 should be week 1');
<ide> test("weeks year starting wednesday", function (assert) {
<ide> assert.equal(moment([2003, 0, 13]).week(), 3, 'Jan 13 2003 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting thursday", function (assert) {
<add>test('weeks year starting thursday', function (assert) {
<ide> assert.equal(moment([2008, 11, 29]).week(), 1, 'Dec 29 2008 should be week 1');
<ide> assert.equal(moment([2009, 0, 1]).week(), 1, 'Jan 1 2009 should be week 1');
<ide> assert.equal(moment([2009, 0, 4]).week(), 1, 'Jan 4 2009 should be week 1');
<ide> test("weeks year starting thursday", function (assert) {
<ide> assert.equal(moment([2009, 0, 13]).week(), 3, 'Jan 12 2009 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting friday", function (assert) {
<add>test('weeks year starting friday', function (assert) {
<ide> assert.equal(moment([2009, 11, 28]).week(), 53, 'Dec 28 2009 should be week 53');
<ide> assert.equal(moment([2010, 0, 1]).week(), 53, 'Jan 1 2010 should be week 53');
<ide> assert.equal(moment([2010, 0, 3]).week(), 53, 'Jan 3 2010 should be week 53');
<ide> test("weeks year starting friday", function (assert) {
<ide> assert.equal(moment([2010, 0, 11]).week(), 2, 'Jan 11 2010 should be week 2');
<ide> });
<ide>
<del>test("weeks year starting saturday", function (assert) {
<add>test('weeks year starting saturday', function (assert) {
<ide> assert.equal(moment([2010, 11, 27]).week(), 52, 'Dec 27 2010 should be week 52');
<ide> assert.equal(moment([2011, 0, 1]).week(), 52, 'Jan 1 2011 should be week 52');
<ide> assert.equal(moment([2011, 0, 2]).week(), 52, 'Jan 2 2011 should be week 52');
<ide> test("weeks year starting saturday", function (assert) {
<ide> assert.equal(moment([2011, 0, 10]).week(), 2, 'Jan 10 2011 should be week 2');
<ide> });
<ide>
<del>test("weeks year starting sunday formatted", function (assert) {
<add>test('weeks year starting sunday formatted', function (assert) {
<ide> assert.equal(moment([2012, 0, 1]).format('w ww wo'), '52 52 52.', 'Jan 1 2012 should be week 52');
<ide> assert.equal(moment([2012, 0, 2]).format('w ww wo'), '1 01 1.', 'Jan 2 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 8]).format('w ww wo'), '1 01 1.', 'Jan 8 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 9]).format('w ww wo'), '2 02 2.', 'Jan 9 2012 should be week 2');
<ide> assert.equal(moment([2012, 0, 15]).format('w ww wo'), '2 02 2.', 'Jan 15 2012 should be week 2');
<ide> });
<ide>
<del>test("lenient ordinal parsing", function (assert) {
<add>test('lenient ordinal parsing', function (assert) {
<ide> var i, ordinalStr, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> ordinalStr = moment([2014, 0, i]).format('YYYY MM Do');
<ide> test("lenient ordinal parsing", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("lenient ordinal parsing of number", function (assert) {
<add>test('lenient ordinal parsing of number', function (assert) {
<ide> var i, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> testMoment = moment('2014 01 ' + i, 'YYYY MM Do');
<ide> test("lenient ordinal parsing of number", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("strict ordinal parsing", function (assert) {
<add>test('strict ordinal parsing', function (assert) {
<ide> var i, ordinalStr, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> ordinalStr = moment([2014, 0, i]).format('YYYY MM Do');
<ide><path>src/test/locale/fr-ca.js
<del>import {localeModule, test} from "../qunit";
<del>import {moment} from "../../moment";
<del>localeModule("fr-ca");
<add>import {localeModule, test} from '../qunit';
<add>import {moment} from '../../moment';
<add>localeModule('fr-ca');
<ide>
<del>test("parse", function (assert) {
<add>test('parse', function (assert) {
<ide> var i,
<ide> tests = 'janvier janv._février févr._mars mars_avril avr._mai mai_juin juin_juillet juil._août août_septembre sept._octobre oct._novembre nov._décembre déc.'.split('_');
<ide>
<ide> test("parse", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("format", function (assert) {
<add>test('format', function (assert) {
<ide> var a = [
<ide> ['dddd, MMMM Do YYYY, h:mm:ss a', 'dimanche, février 14 2010, 3:25:50 pm'],
<ide> ['ddd, hA', 'dim., 3PM'],
<ide> test("format", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("format ordinal", function (assert) {
<add>test('format ordinal', function (assert) {
<ide> assert.equal(moment([2011, 0, 1]).format('DDDo'), '1er', '1er');
<ide> assert.equal(moment([2011, 0, 2]).format('DDDo'), '2', '2');
<ide> assert.equal(moment([2011, 0, 3]).format('DDDo'), '3', '3');
<ide> test("format ordinal", function (assert) {
<ide> assert.equal(moment([2011, 0, 31]).format('DDDo'), '31', '31');
<ide> });
<ide>
<del>test("format month", function (assert) {
<add>test('format month', function (assert) {
<ide> var i,
<ide> expected = 'janvier janv._février févr._mars mars_avril avr._mai mai_juin juin_juillet juil._août août_septembre sept._octobre oct._novembre nov._décembre déc.'.split('_');
<ide>
<ide> test("format month", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("format week", function (assert) {
<add>test('format week', function (assert) {
<ide> var i,
<ide> expected = 'dimanche dim. Di_lundi lun. Lu_mardi mar. Ma_mercredi mer. Me_jeudi jeu. Je_vendredi ven. Ve_samedi sam. Sa'.split('_');
<ide>
<ide> test("format week", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("from", function (assert) {
<add>test('from', function (assert) {
<ide> var start = moment([2007, 1, 28]);
<ide>
<ide> assert.equal(start.from(moment([2007, 1, 28]).add({s: 44}), true), 'quelques secondes', '44 seconds = a few seconds');
<ide> test("from", function (assert) {
<ide> assert.equal(start.from(moment([2007, 1, 28]).add({y: 5}), true), '5 ans', '5 years = 5 years');
<ide> });
<ide>
<del>test("suffix", function (assert) {
<add>test('suffix', function (assert) {
<ide> assert.equal(moment(30000).from(0), 'dans quelques secondes', 'prefix');
<ide> assert.equal(moment(0).from(30000), 'il y a quelques secondes', 'suffix');
<ide> });
<ide>
<del>test("fromNow", function (assert) {
<add>test('fromNow', function (assert) {
<ide> assert.equal(moment().add({s: 30}).fromNow(), 'dans quelques secondes', 'in a few seconds');
<ide> assert.equal(moment().add({d: 5}).fromNow(), 'dans 5 jours', 'in 5 days');
<ide> });
<ide>
<del>test("same day", function (assert) {
<add>test('same day', function (assert) {
<ide> var a = moment().hours(2).minutes(0).seconds(0);
<ide>
<ide> assert.equal(moment(a).calendar(), 'Aujourd\'hui à 02:00', 'today at the same time');
<ide> test("same day", function (assert) {
<ide> assert.equal(moment(a).subtract({d: 1}).calendar(), 'Hier à 02:00', 'yesterday at the same time');
<ide> });
<ide>
<del>test("same next week", function (assert) {
<add>test('same next week', function (assert) {
<ide> var i, m;
<ide>
<ide> for (i = 2; i < 7; i++) {
<ide> test("same next week", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("same last week", function (assert) {
<add>test('same last week', function (assert) {
<ide> var i, m;
<ide>
<ide> for (i = 2; i < 7; i++) {
<ide> test("same last week", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("same all else", function (assert) {
<add>test('same all else', function (assert) {
<ide> var weeksAgo = moment().subtract({w: 1}),
<ide> weeksFromNow = moment().add({w: 1});
<ide>
<ide> test("same all else", function (assert) {
<ide> assert.equal(weeksFromNow.calendar(), weeksFromNow.format('L'), 'in 2 weeks');
<ide> });
<ide>
<del>test("weeks year starting sunday", function (assert) {
<add>test('weeks year starting sunday', function (assert) {
<ide> assert.equal(moment([2012, 0, 1]).week(), 1, 'Jan 1 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 7]).week(), 1, 'Jan 7 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 8]).week(), 2, 'Jan 8 2012 should be week 2');
<ide> assert.equal(moment([2012, 0, 14]).week(), 2, 'Jan 14 2012 should be week 2');
<ide> assert.equal(moment([2012, 0, 15]).week(), 3, 'Jan 15 2012 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting monday", function (assert) {
<add>test('weeks year starting monday', function (assert) {
<ide> assert.equal(moment([2006, 11, 31]).week(), 1, 'Dec 31 2006 should be week 1');
<ide> assert.equal(moment([2007, 0, 1]).week(), 1, 'Jan 1 2007 should be week 1');
<ide> assert.equal(moment([2007, 0, 6]).week(), 1, 'Jan 6 2007 should be week 1');
<ide> test("weeks year starting monday", function (assert) {
<ide> assert.equal(moment([2007, 0, 14]).week(), 3, 'Jan 14 2007 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting tuesday", function (assert) {
<add>test('weeks year starting tuesday', function (assert) {
<ide> assert.equal(moment([2007, 11, 29]).week(), 52, 'Dec 29 2007 should be week 52');
<ide> assert.equal(moment([2008, 0, 1]).week(), 1, 'Jan 1 2008 should be week 1');
<ide> assert.equal(moment([2008, 0, 5]).week(), 1, 'Jan 5 2008 should be week 1');
<ide> test("weeks year starting tuesday", function (assert) {
<ide> assert.equal(moment([2008, 0, 13]).week(), 3, 'Jan 13 2008 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting wednesday", function (assert) {
<add>test('weeks year starting wednesday', function (assert) {
<ide> assert.equal(moment([2002, 11, 29]).week(), 1, 'Dec 29 2002 should be week 1');
<ide> assert.equal(moment([2003, 0, 1]).week(), 1, 'Jan 1 2003 should be week 1');
<ide> assert.equal(moment([2003, 0, 4]).week(), 1, 'Jan 4 2003 should be week 1');
<ide> test("weeks year starting wednesday", function (assert) {
<ide> assert.equal(moment([2003, 0, 12]).week(), 3, 'Jan 12 2003 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting thursday", function (assert) {
<add>test('weeks year starting thursday', function (assert) {
<ide> assert.equal(moment([2008, 11, 28]).week(), 1, 'Dec 28 2008 should be week 1');
<ide> assert.equal(moment([2009, 0, 1]).week(), 1, 'Jan 1 2009 should be week 1');
<ide> assert.equal(moment([2009, 0, 3]).week(), 1, 'Jan 3 2009 should be week 1');
<ide> test("weeks year starting thursday", function (assert) {
<ide> assert.equal(moment([2009, 0, 11]).week(), 3, 'Jan 11 2009 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting friday", function (assert) {
<add>test('weeks year starting friday', function (assert) {
<ide> assert.equal(moment([2009, 11, 27]).week(), 1, 'Dec 27 2009 should be week 1');
<ide> assert.equal(moment([2010, 0, 1]).week(), 1, 'Jan 1 2010 should be week 1');
<ide> assert.equal(moment([2010, 0, 2]).week(), 1, 'Jan 2 2010 should be week 1');
<ide> test("weeks year starting friday", function (assert) {
<ide> assert.equal(moment([2010, 0, 10]).week(), 3, 'Jan 10 2010 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting saturday", function (assert) {
<add>test('weeks year starting saturday', function (assert) {
<ide> assert.equal(moment([2010, 11, 26]).week(), 1, 'Dec 26 2010 should be week 1');
<ide> assert.equal(moment([2011, 0, 1]).week(), 1, 'Jan 1 2011 should be week 1');
<ide> assert.equal(moment([2011, 0, 2]).week(), 2, 'Jan 2 2011 should be week 2');
<ide> assert.equal(moment([2011, 0, 8]).week(), 2, 'Jan 8 2011 should be week 2');
<ide> assert.equal(moment([2011, 0, 9]).week(), 3, 'Jan 9 2011 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting sunday format", function (assert) {
<add>test('weeks year starting sunday format', function (assert) {
<ide> assert.equal(moment([2012, 0, 1]).format('w ww wo'), '1 01 1er', 'Jan 1 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 7]).format('w ww wo'), '1 01 1er', 'Jan 7 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 8]).format('w ww wo'), '2 02 2', 'Jan 8 2012 should be week 2');
<ide> assert.equal(moment([2012, 0, 14]).format('w ww wo'), '2 02 2', 'Jan 14 2012 should be week 2');
<ide> assert.equal(moment([2012, 0, 15]).format('w ww wo'), '3 03 3', 'Jan 15 2012 should be week 3');
<ide> });
<ide>
<del>test("lenient ordinal parsing", function (assert) {
<add>test('lenient ordinal parsing', function (assert) {
<ide> var i, ordinalStr, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> ordinalStr = moment([2014, 0, i]).format('YYYY MM Do');
<ide> test("lenient ordinal parsing", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("lenient ordinal parsing of number", function (assert) {
<add>test('lenient ordinal parsing of number', function (assert) {
<ide> var i, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> testMoment = moment('2014 01 ' + i, 'YYYY MM Do');
<ide> test("lenient ordinal parsing of number", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("strict ordinal parsing", function (assert) {
<add>test('strict ordinal parsing', function (assert) {
<ide> var i, ordinalStr, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> ordinalStr = moment([2014, 0, i]).format('YYYY MM Do');
<ide><path>src/test/locale/fr.js
<del>import {localeModule, test} from "../qunit";
<del>import {moment} from "../../moment";
<del>localeModule("fr");
<add>import {localeModule, test} from '../qunit';
<add>import {moment} from '../../moment';
<add>localeModule('fr');
<ide>
<del>test("parse", function (assert) {
<add>test('parse', function (assert) {
<ide> var tests = 'janvier janv._février févr._mars mars_avril avr._mai mai_juin juin_juillet juil._août août_septembre sept._octobre oct._novembre nov._décembre déc.'.split('_'),
<ide> i;
<ide> function equalTest(input, mmm, i) {
<ide> test("parse", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("format", function (assert) {
<add>test('format', function (assert) {
<ide> var a = [
<ide> ['dddd, MMMM Do YYYY, h:mm:ss a', 'dimanche, février 14 2010, 3:25:50 pm'],
<ide> ['ddd, hA', 'dim., 3PM'],
<ide> test("format", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("format ordinal", function (assert) {
<add>test('format ordinal', function (assert) {
<ide> assert.equal(moment([2011, 0, 1]).format('DDDo'), '1er', '1er');
<ide> assert.equal(moment([2011, 0, 2]).format('DDDo'), '2', '2');
<ide> assert.equal(moment([2011, 0, 3]).format('DDDo'), '3', '3');
<ide> test("format ordinal", function (assert) {
<ide> assert.equal(moment([2011, 0, 31]).format('DDDo'), '31', '31');
<ide> });
<ide>
<del>test("format month", function (assert) {
<add>test('format month', function (assert) {
<ide> var expected = 'janvier janv._février févr._mars mars_avril avr._mai mai_juin juin_juillet juil._août août_septembre sept._octobre oct._novembre nov._décembre déc.'.split('_'), i;
<ide> for (i = 0; i < expected.length; i++) {
<ide> assert.equal(moment([2011, i, 1]).format('MMMM MMM'), expected[i], expected[i]);
<ide> }
<ide> });
<ide>
<del>test("format week", function (assert) {
<add>test('format week', function (assert) {
<ide> var expected = 'dimanche dim. Di_lundi lun. Lu_mardi mar. Ma_mercredi mer. Me_jeudi jeu. Je_vendredi ven. Ve_samedi sam. Sa'.split('_'), i;
<ide> for (i = 0; i < expected.length; i++) {
<ide> assert.equal(moment([2011, 0, 2 + i]).format('dddd ddd dd'), expected[i], expected[i]);
<ide> }
<ide> });
<ide>
<del>test("from", function (assert) {
<add>test('from', function (assert) {
<ide> var start = moment([2007, 1, 28]);
<ide> assert.equal(start.from(moment([2007, 1, 28]).add({s: 44}), true), 'quelques secondes', '44 seconds = a few seconds');
<ide> assert.equal(start.from(moment([2007, 1, 28]).add({s: 45}), true), 'une minute', '45 seconds = a minute');
<ide> test("from", function (assert) {
<ide> assert.equal(start.from(moment([2007, 1, 28]).add({y: 5}), true), '5 ans', '5 years = 5 years');
<ide> });
<ide>
<del>test("suffix", function (assert) {
<add>test('suffix', function (assert) {
<ide> assert.equal(moment(30000).from(0), 'dans quelques secondes', 'prefix');
<ide> assert.equal(moment(0).from(30000), 'il y a quelques secondes', 'suffix');
<ide> });
<ide>
<del>test("fromNow", function (assert) {
<add>test('fromNow', function (assert) {
<ide> assert.equal(moment().add({s: 30}).fromNow(), 'dans quelques secondes', 'in a few seconds');
<ide> assert.equal(moment().add({d: 5}).fromNow(), 'dans 5 jours', 'in 5 days');
<ide> });
<ide>
<del>test("same day", function (assert) {
<add>test('same day', function (assert) {
<ide> var a = moment().hours(2).minutes(0).seconds(0);
<ide>
<ide> assert.equal(moment(a).calendar(), 'Aujourd\'hui à 02:00', 'today at the same time');
<ide> test("same day", function (assert) {
<ide> assert.equal(moment(a).subtract({d: 1}).calendar(), 'Hier à 02:00', 'yesterday at the same time');
<ide> });
<ide>
<del>test("same next week", function (assert) {
<add>test('same next week', function (assert) {
<ide> var i, m;
<ide>
<ide> for (i = 2; i < 7; i++) {
<ide> test("same next week", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("same last week", function (assert) {
<add>test('same last week', function (assert) {
<ide> var i, m;
<ide>
<ide> for (i = 2; i < 7; i++) {
<ide> test("same last week", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("same all else", function (assert) {
<add>test('same all else', function (assert) {
<ide> var weeksAgo = moment().subtract({w: 1}),
<ide> weeksFromNow = moment().add({w: 1});
<ide>
<ide> test("same all else", function (assert) {
<ide> assert.equal(weeksFromNow.calendar(), weeksFromNow.format('L'), 'in 2 weeks');
<ide> });
<ide>
<del>test("weeks year starting sunday", function (assert) {
<add>test('weeks year starting sunday', function (assert) {
<ide> assert.equal(moment([2012, 0, 1]).week(), 52, 'Jan 1 2012 should be week 52');
<ide> assert.equal(moment([2012, 0, 2]).week(), 1, 'Jan 2 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 8]).week(), 1, 'Jan 8 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 9]).week(), 2, 'Jan 9 2012 should be week 2');
<ide> assert.equal(moment([2012, 0, 15]).week(), 2, 'Jan 15 2012 should be week 2');
<ide> });
<ide>
<del>test("weeks year starting monday", function (assert) {
<add>test('weeks year starting monday', function (assert) {
<ide> assert.equal(moment([2007, 0, 1]).week(), 1, 'Jan 1 2007 should be week 1');
<ide> assert.equal(moment([2007, 0, 7]).week(), 1, 'Jan 7 2007 should be week 1');
<ide> assert.equal(moment([2007, 0, 8]).week(), 2, 'Jan 8 2007 should be week 2');
<ide> assert.equal(moment([2007, 0, 14]).week(), 2, 'Jan 14 2007 should be week 2');
<ide> assert.equal(moment([2007, 0, 15]).week(), 3, 'Jan 15 2007 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting tuesday", function (assert) {
<add>test('weeks year starting tuesday', function (assert) {
<ide> assert.equal(moment([2007, 11, 31]).week(), 1, 'Dec 31 2007 should be week 1');
<ide> assert.equal(moment([2008, 0, 1]).week(), 1, 'Jan 1 2008 should be week 1');
<ide> assert.equal(moment([2008, 0, 6]).week(), 1, 'Jan 6 2008 should be week 1');
<ide> test("weeks year starting tuesday", function (assert) {
<ide> assert.equal(moment([2008, 0, 14]).week(), 3, 'Jan 14 2008 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting wednesday", function (assert) {
<add>test('weeks year starting wednesday', function (assert) {
<ide> assert.equal(moment([2002, 11, 30]).week(), 1, 'Dec 30 2002 should be week 1');
<ide> assert.equal(moment([2003, 0, 1]).week(), 1, 'Jan 1 2003 should be week 1');
<ide> assert.equal(moment([2003, 0, 5]).week(), 1, 'Jan 5 2003 should be week 1');
<ide> test("weeks year starting wednesday", function (assert) {
<ide> assert.equal(moment([2003, 0, 13]).week(), 3, 'Jan 13 2003 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting thursday", function (assert) {
<add>test('weeks year starting thursday', function (assert) {
<ide> assert.equal(moment([2008, 11, 29]).week(), 1, 'Dec 29 2008 should be week 1');
<ide> assert.equal(moment([2009, 0, 1]).week(), 1, 'Jan 1 2009 should be week 1');
<ide> assert.equal(moment([2009, 0, 4]).week(), 1, 'Jan 4 2009 should be week 1');
<ide> test("weeks year starting thursday", function (assert) {
<ide> assert.equal(moment([2009, 0, 13]).week(), 3, 'Jan 12 2009 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting friday", function (assert) {
<add>test('weeks year starting friday', function (assert) {
<ide> assert.equal(moment([2009, 11, 28]).week(), 53, 'Dec 28 2009 should be week 53');
<ide> assert.equal(moment([2010, 0, 1]).week(), 53, 'Jan 1 2010 should be week 53');
<ide> assert.equal(moment([2010, 0, 3]).week(), 53, 'Jan 3 2010 should be week 53');
<ide> test("weeks year starting friday", function (assert) {
<ide> assert.equal(moment([2010, 0, 11]).week(), 2, 'Jan 11 2010 should be week 2');
<ide> });
<ide>
<del>test("weeks year starting saturday", function (assert) {
<add>test('weeks year starting saturday', function (assert) {
<ide> assert.equal(moment([2010, 11, 27]).week(), 52, 'Dec 27 2010 should be week 52');
<ide> assert.equal(moment([2011, 0, 1]).week(), 52, 'Jan 1 2011 should be week 52');
<ide> assert.equal(moment([2011, 0, 2]).week(), 52, 'Jan 2 2011 should be week 52');
<ide> test("weeks year starting saturday", function (assert) {
<ide> assert.equal(moment([2011, 0, 10]).week(), 2, 'Jan 10 2011 should be week 2');
<ide> });
<ide>
<del>test("weeks year starting sunday formatted", function (assert) {
<add>test('weeks year starting sunday formatted', function (assert) {
<ide> assert.equal(moment([2012, 0, 1]).format('w ww wo'), '52 52 52', 'Jan 1 2012 should be week 52');
<ide> assert.equal(moment([2012, 0, 2]).format('w ww wo'), '1 01 1er', 'Jan 2 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 8]).format('w ww wo'), '1 01 1er', 'Jan 8 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 9]).format('w ww wo'), '2 02 2', 'Jan 9 2012 should be week 2');
<ide> assert.equal(moment([2012, 0, 15]).format('w ww wo'), '2 02 2', 'Jan 15 2012 should be week 2');
<ide> });
<ide>
<del>test("lenient ordinal parsing", function (assert) {
<add>test('lenient ordinal parsing', function (assert) {
<ide> var i, ordinalStr, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> ordinalStr = moment([2014, 0, i]).format('YYYY MM Do');
<ide> test("lenient ordinal parsing", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("lenient ordinal parsing of number", function (assert) {
<add>test('lenient ordinal parsing of number', function (assert) {
<ide> var i, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> testMoment = moment('2014 01 ' + i, 'YYYY MM Do');
<ide> test("lenient ordinal parsing of number", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("strict ordinal parsing", function (assert) {
<add>test('strict ordinal parsing', function (assert) {
<ide> var i, ordinalStr, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> ordinalStr = moment([2014, 0, i]).format('YYYY MM Do');
<ide><path>src/test/locale/fy.js
<del>import {localeModule, test} from "../qunit";
<del>import {moment} from "../../moment";
<del>localeModule("fy");
<add>import {localeModule, test} from '../qunit';
<add>import {moment} from '../../moment';
<add>localeModule('fy');
<ide>
<del>test("parse", function (assert) {
<add>test('parse', function (assert) {
<ide> var tests = 'jannewaris jan._febrewaris feb._maart mrt._april apr._maaie mai._juny jun._july jul._augustus aug._septimber sep._oktober okt._novimber nov._desimber des.'.split('_'), i;
<ide> function equalTest(input, mmm, i) {
<ide> assert.equal(moment(input, mmm).month(), i, input + ' should be month ' + (i + 1));
<ide> test("parse", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("format", function (assert) {
<add>test('format', function (assert) {
<ide> var a = [
<ide> ['dddd, MMMM Do YYYY, HH:mm:ss', 'snein, febrewaris 14de 2010, 15:25:50'],
<ide> ['ddd, HH', 'si., 15'],
<ide> test("format", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("format ordinal", function (assert) {
<add>test('format ordinal', function (assert) {
<ide> assert.equal(moment([2011, 0, 1]).format('DDDo'), '1ste', '1ste');
<ide> assert.equal(moment([2011, 0, 2]).format('DDDo'), '2de', '2de');
<ide> assert.equal(moment([2011, 0, 3]).format('DDDo'), '3de', '3de');
<ide> test("format ordinal", function (assert) {
<ide> assert.equal(moment([2011, 0, 31]).format('DDDo'), '31ste', '31ste');
<ide> });
<ide>
<del>test("format month", function (assert) {
<add>test('format month', function (assert) {
<ide> var expected = 'jannewaris jan._febrewaris feb._maart mrt._april apr._maaie mai_juny jun._july jul._augustus aug._septimber sep._oktober okt._novimber nov._desimber des.'.split('_'), i;
<ide> for (i = 0; i < expected.length; i++) {
<ide> assert.equal(moment([2011, i, 1]).format('MMMM MMM'), expected[i], expected[i]);
<ide> }
<ide> });
<ide>
<del>test("format week", function (assert) {
<add>test('format week', function (assert) {
<ide> var expected = 'snein si. Si_moandei mo. Mo_tiisdei ti. Ti_woansdei wo. Wo_tongersdei to. To_freed fr. Fr_sneon so. So'.split('_'), i;
<ide> for (i = 0; i < expected.length; i++) {
<ide> assert.equal(moment([2011, 0, 2 + i]).format('dddd ddd dd'), expected[i], expected[i]);
<ide> }
<ide> });
<ide>
<del>test("from", function (assert) {
<add>test('from', function (assert) {
<ide> var start = moment([2007, 1, 28]);
<ide> assert.equal(start.from(moment([2007, 1, 28]).add({s: 44}), true), 'in pear sekonden', '44 seconds = a few seconds');
<ide> assert.equal(start.from(moment([2007, 1, 28]).add({s: 45}), true), 'ien minút', '45 seconds = a minute');
<ide> test("from", function (assert) {
<ide> assert.equal(start.from(moment([2007, 1, 28]).add({y: 5}), true), '5 jierren', '5 years = 5 years');
<ide> });
<ide>
<del>test("suffix", function (assert) {
<add>test('suffix', function (assert) {
<ide> assert.equal(moment(30000).from(0), 'oer in pear sekonden', 'prefix');
<ide> assert.equal(moment(0).from(30000), 'in pear sekonden lyn', 'suffix');
<ide> });
<ide>
<del>test("now from now", function (assert) {
<add>test('now from now', function (assert) {
<ide> assert.equal(moment().fromNow(), 'in pear sekonden lyn', 'now from now should display as in the past');
<ide> });
<ide>
<del>test("fromNow", function (assert) {
<add>test('fromNow', function (assert) {
<ide> assert.equal(moment().add({s: 30}).fromNow(), 'oer in pear sekonden', 'in a few seconds');
<ide> assert.equal(moment().add({d: 5}).fromNow(), 'oer 5 dagen', 'in 5 days');
<ide> });
<ide>
<del>test("calendar day", function (assert) {
<add>test('calendar day', function (assert) {
<ide> var a = moment().hours(2).minutes(0).seconds(0);
<ide>
<ide> assert.equal(moment(a).calendar(), 'hjoed om 02:00', 'today at the same time');
<ide> test("calendar day", function (assert) {
<ide> assert.equal(moment(a).subtract({d: 1}).calendar(), 'juster om 02:00', 'yesterday at the same time');
<ide> });
<ide>
<del>test("calendar next week", function (assert) {
<add>test('calendar next week', function (assert) {
<ide> var i, m;
<ide> for (i = 2; i < 7; i++) {
<ide> m = moment().add({d: i});
<ide> test("calendar next week", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("calendar last week", function (assert) {
<add>test('calendar last week', function (assert) {
<ide> var i, m;
<ide> for (i = 2; i < 7; i++) {
<ide> m = moment().subtract({d: i});
<ide> test("calendar last week", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("calendar all else", function (assert) {
<add>test('calendar all else', function (assert) {
<ide> var weeksAgo = moment().subtract({w: 1}),
<ide> weeksFromNow = moment().add({w: 1});
<ide>
<ide> test("calendar all else", function (assert) {
<ide> assert.equal(weeksFromNow.calendar(), weeksFromNow.format('L'), 'in 2 weeks');
<ide> });
<ide>
<del>test("month abbreviation", function (assert) {
<add>test('month abbreviation', function (assert) {
<ide> assert.equal(moment([2012, 5, 23]).format('D-MMM-YYYY'), '23-jun-2012', 'format month abbreviation surrounded by dashes should not include a dot');
<ide> assert.equal(moment([2012, 5, 23]).format('D MMM YYYY'), '23 jun. 2012', 'format month abbreviation not surrounded by dashes should include a dot');
<ide> });
<ide>
<del>test("weeks year starting sunday", function (assert) {
<add>test('weeks year starting sunday', function (assert) {
<ide> assert.equal(moment([2012, 0, 1]).week(), 52, 'Jan 1 2012 should be week 52');
<ide> assert.equal(moment([2012, 0, 2]).week(), 1, 'Jan 2 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 8]).week(), 1, 'Jan 8 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 9]).week(), 2, 'Jan 9 2012 should be week 2');
<ide> assert.equal(moment([2012, 0, 15]).week(), 2, 'Jan 15 2012 should be week 2');
<ide> });
<ide>
<del>test("weeks year starting monday", function (assert) {
<add>test('weeks year starting monday', function (assert) {
<ide> assert.equal(moment([2007, 0, 1]).week(), 1, 'Jan 1 2007 should be week 1');
<ide> assert.equal(moment([2007, 0, 7]).week(), 1, 'Jan 7 2007 should be week 1');
<ide> assert.equal(moment([2007, 0, 8]).week(), 2, 'Jan 8 2007 should be week 2');
<ide> assert.equal(moment([2007, 0, 14]).week(), 2, 'Jan 14 2007 should be week 2');
<ide> assert.equal(moment([2007, 0, 15]).week(), 3, 'Jan 15 2007 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting tuesday", function (assert) {
<add>test('weeks year starting tuesday', function (assert) {
<ide> assert.equal(moment([2007, 11, 31]).week(), 1, 'Dec 31 2007 should be week 1');
<ide> assert.equal(moment([2008, 0, 1]).week(), 1, 'Jan 1 2008 should be week 1');
<ide> assert.equal(moment([2008, 0, 6]).week(), 1, 'Jan 6 2008 should be week 1');
<ide> test("weeks year starting tuesday", function (assert) {
<ide> assert.equal(moment([2008, 0, 14]).week(), 3, 'Jan 14 2008 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting wednesday", function (assert) {
<add>test('weeks year starting wednesday', function (assert) {
<ide> assert.equal(moment([2002, 11, 30]).week(), 1, 'Dec 30 2002 should be week 1');
<ide> assert.equal(moment([2003, 0, 1]).week(), 1, 'Jan 1 2003 should be week 1');
<ide> assert.equal(moment([2003, 0, 5]).week(), 1, 'Jan 5 2003 should be week 1');
<ide> test("weeks year starting wednesday", function (assert) {
<ide> assert.equal(moment([2003, 0, 13]).week(), 3, 'Jan 13 2003 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting thursday", function (assert) {
<add>test('weeks year starting thursday', function (assert) {
<ide> assert.equal(moment([2008, 11, 29]).week(), 1, 'Dec 29 2008 should be week 1');
<ide> assert.equal(moment([2009, 0, 1]).week(), 1, 'Jan 1 2009 should be week 1');
<ide> assert.equal(moment([2009, 0, 4]).week(), 1, 'Jan 4 2009 should be week 1');
<ide> test("weeks year starting thursday", function (assert) {
<ide> assert.equal(moment([2009, 0, 13]).week(), 3, 'Jan 12 2009 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting friday", function (assert) {
<add>test('weeks year starting friday', function (assert) {
<ide> assert.equal(moment([2009, 11, 28]).week(), 53, 'Dec 28 2009 should be week 53');
<ide> assert.equal(moment([2010, 0, 1]).week(), 53, 'Jan 1 2010 should be week 53');
<ide> assert.equal(moment([2010, 0, 3]).week(), 53, 'Jan 3 2010 should be week 53');
<ide> test("weeks year starting friday", function (assert) {
<ide> assert.equal(moment([2010, 0, 11]).week(), 2, 'Jan 11 2010 should be week 2');
<ide> });
<ide>
<del>test("weeks year starting saturday", function (assert) {
<add>test('weeks year starting saturday', function (assert) {
<ide> assert.equal(moment([2010, 11, 27]).week(), 52, 'Dec 27 2010 should be week 52');
<ide> assert.equal(moment([2011, 0, 1]).week(), 52, 'Jan 1 2011 should be week 52');
<ide> assert.equal(moment([2011, 0, 2]).week(), 52, 'Jan 2 2011 should be week 52');
<ide> test("weeks year starting saturday", function (assert) {
<ide> assert.equal(moment([2011, 0, 10]).week(), 2, 'Jan 10 2011 should be week 2');
<ide> });
<ide>
<del>test("weeks year starting sunday formatted", function (assert) {
<add>test('weeks year starting sunday formatted', function (assert) {
<ide> assert.equal(moment([2012, 0, 1]).format('w ww wo'), '52 52 52ste', 'Jan 1 2012 should be week 52');
<ide> assert.equal(moment([2012, 0, 2]).format('w ww wo'), '1 01 1ste', 'Jan 2 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 8]).format('w ww wo'), '1 01 1ste', 'Jan 8 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 9]).format('w ww wo'), '2 02 2de', 'Jan 9 2012 should be week 2');
<ide> assert.equal(moment([2012, 0, 15]).format('w ww wo'), '2 02 2de', 'Jan 15 2012 should be week 2');
<ide> });
<ide>
<del>test("lenient ordinal parsing", function (assert) {
<add>test('lenient ordinal parsing', function (assert) {
<ide> var i, ordinalStr, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> ordinalStr = moment([2014, 0, i]).format('YYYY MM Do');
<ide> test("lenient ordinal parsing", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("lenient ordinal parsing of number", function (assert) {
<add>test('lenient ordinal parsing of number', function (assert) {
<ide> var i, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> testMoment = moment('2014 01 ' + i, 'YYYY MM Do');
<ide> test("lenient ordinal parsing of number", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("strict ordinal parsing", function (assert) {
<add>test('strict ordinal parsing', function (assert) {
<ide> var i, ordinalStr, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> ordinalStr = moment([2014, 0, i]).format('YYYY MM Do');
<ide><path>src/test/locale/gl.js
<del>import {localeModule, test} from "../qunit";
<del>import {moment} from "../../moment";
<del>localeModule("gl");
<add>import {localeModule, test} from '../qunit';
<add>import {moment} from '../../moment';
<add>localeModule('gl');
<ide>
<del>test("parse", function (assert) {
<add>test('parse', function (assert) {
<ide> var tests = 'Xaneiro Xan._Febreiro Feb._Marzo Mar._Abril Abr._Maio Mai._Xuño Xuñ._Xullo Xul._Agosto Ago._Setembro Set._Outubro Out._Novembro Nov._Decembro Dec.'.split('_'), i;
<ide> function equalTest(input, mmm, i) {
<ide> assert.equal(moment(input, mmm).month(), i, input + ' should be month ' + (i + 1));
<ide> test("parse", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("format", function (assert) {
<add>test('format', function (assert) {
<ide> var a = [
<ide> ['dddd, MMMM Do YYYY, h:mm:ss a', 'Domingo, Febreiro 14º 2010, 3:25:50 pm'],
<ide> ['ddd, hA', 'Dom., 3PM'],
<ide> test("format", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("format ordinal", function (assert) {
<add>test('format ordinal', function (assert) {
<ide> assert.equal(moment([2011, 0, 1]).format('DDDo'), '1º', '1º');
<ide> assert.equal(moment([2011, 0, 2]).format('DDDo'), '2º', '2º');
<ide> assert.equal(moment([2011, 0, 3]).format('DDDo'), '3º', '3º');
<ide> test("format ordinal", function (assert) {
<ide> assert.equal(moment([2011, 0, 31]).format('DDDo'), '31º', '31º');
<ide> });
<ide>
<del>test("format month", function (assert) {
<add>test('format month', function (assert) {
<ide> var expected = 'Xaneiro Xan._Febreiro Feb._Marzo Mar._Abril Abr._Maio Mai._Xuño Xuñ._Xullo Xul._Agosto Ago._Setembro Set._Outubro Out._Novembro Nov._Decembro Dec.'.split('_'), i;
<ide> for (i = 0; i < expected.length; i++) {
<ide> assert.equal(moment([2011, i, 1]).format('MMMM MMM'), expected[i], expected[i]);
<ide> }
<ide> });
<ide>
<del>test("format week", function (assert) {
<add>test('format week', function (assert) {
<ide> var expected = 'Domingo Dom. Do_Luns Lun. Lu_Martes Mar. Ma_Mércores Mér. Mé_Xoves Xov. Xo_Venres Ven. Ve_Sábado Sáb. Sá'.split('_'),
<ide> i;
<ide> for (i = 0; i < expected.length; i++) {
<ide> assert.equal(moment([2011, 0, 2 + i]).format('dddd ddd dd'), expected[i], expected[i]);
<ide> }
<ide> });
<ide>
<del>test("from", function (assert) {
<add>test('from', function (assert) {
<ide> var start = moment([2007, 1, 28]);
<ide>
<ide> assert.equal(start.from(moment([2007, 1, 28]).add({s: 44}), true), 'uns segundos', '44 seconds = a few seconds');
<ide> test("from", function (assert) {
<ide> assert.equal(start.from(moment([2007, 1, 28]).add({y: 5}), true), '5 anos', '5 years = 5 years');
<ide> });
<ide>
<del>test("suffix", function (assert) {
<add>test('suffix', function (assert) {
<ide> assert.equal(moment(30000).from(0), 'nuns segundos', 'prefix');
<ide> assert.equal(moment(0).from(30000), 'hai uns segundos', 'suffix');
<ide> });
<ide>
<del>test("now from now", function (assert) {
<add>test('now from now', function (assert) {
<ide> assert.equal(moment().fromNow(), 'hai uns segundos', 'now from now should display as in the past');
<ide> });
<ide>
<del>test("fromNow", function (assert) {
<add>test('fromNow', function (assert) {
<ide> assert.equal(moment().add({s: 30}).fromNow(), 'nuns segundos', 'en unos segundos');
<ide> assert.equal(moment().add({d: 5}).fromNow(), 'en 5 días', 'en 5 días');
<ide> });
<ide>
<del>test("calendar day", function (assert) {
<add>test('calendar day', function (assert) {
<ide> var a = moment().hours(2).minutes(0).seconds(0);
<ide>
<ide> assert.equal(moment(a).calendar(), 'hoxe ás 2:00', 'today at the same time');
<ide> test("calendar day", function (assert) {
<ide> assert.equal(moment(a).subtract({d: 1}).calendar(), 'onte á 2:00', 'yesterday at the same time');
<ide> });
<ide>
<del>test("calendar next week", function (assert) {
<add>test('calendar next week', function (assert) {
<ide> var i, m;
<ide>
<ide> for (i = 2; i < 7; i++) {
<ide> test("calendar next week", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("calendar last week", function (assert) {
<add>test('calendar last week', function (assert) {
<ide> var i, m;
<ide> for (i = 2; i < 7; i++) {
<ide> m = moment().subtract({d: i});
<ide> test("calendar last week", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("calendar all else", function (assert) {
<add>test('calendar all else', function (assert) {
<ide> var weeksAgo = moment().subtract({w: 1}),
<ide> weeksFromNow = moment().add({w: 1});
<ide>
<ide> test("calendar all else", function (assert) {
<ide> assert.equal(weeksFromNow.calendar(), weeksFromNow.format('L'), 'in 2 weeks');
<ide> });
<ide>
<del>test("regression tests", function (assert) {
<add>test('regression tests', function (assert) {
<ide> var lastWeek = moment().subtract({d: 4}).hours(1);
<ide> assert.equal(lastWeek.calendar(), lastWeek.format('[o] dddd [pasado a] LT'), '1 o\'clock bug');
<ide> });
<ide>
<del>test("weeks year starting sunday", function (assert) {
<add>test('weeks year starting sunday', function (assert) {
<ide> assert.equal(moment([2011, 11, 26]).week(), 1, 'Dec 26 2011 should be week 1');
<ide> assert.equal(moment([2012, 0, 1]).week(), 1, 'Jan 1 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 2]).week(), 2, 'Jan 2 2012 should be week 2');
<ide> assert.equal(moment([2012, 0, 8]).week(), 2, 'Jan 8 2012 should be week 2');
<ide> assert.equal(moment([2012, 0, 9]).week(), 3, 'Jan 9 2012 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting monday", function (assert) {
<add>test('weeks year starting monday', function (assert) {
<ide> assert.equal(moment([2007, 0, 1]).week(), 1, 'Jan 1 2007 should be week 1');
<ide> assert.equal(moment([2007, 0, 7]).week(), 1, 'Jan 7 2007 should be week 1');
<ide> assert.equal(moment([2007, 0, 8]).week(), 2, 'Jan 8 2007 should be week 2');
<ide> assert.equal(moment([2007, 0, 14]).week(), 2, 'Jan 14 2007 should be week 2');
<ide> assert.equal(moment([2007, 0, 15]).week(), 3, 'Jan 15 2007 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting tuesday", function (assert) {
<add>test('weeks year starting tuesday', function (assert) {
<ide> assert.equal(moment([2007, 11, 31]).week(), 1, 'Dec 31 2007 should be week 1');
<ide> assert.equal(moment([2008, 0, 1]).week(), 1, 'Jan 1 2008 should be week 1');
<ide> assert.equal(moment([2008, 0, 6]).week(), 1, 'Jan 6 2008 should be week 1');
<ide> test("weeks year starting tuesday", function (assert) {
<ide> assert.equal(moment([2008, 0, 14]).week(), 3, 'Jan 14 2008 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting wednesday", function (assert) {
<add>test('weeks year starting wednesday', function (assert) {
<ide> assert.equal(moment([2002, 11, 30]).week(), 1, 'Dec 30 2002 should be week 1');
<ide> assert.equal(moment([2003, 0, 1]).week(), 1, 'Jan 1 2003 should be week 1');
<ide> assert.equal(moment([2003, 0, 5]).week(), 1, 'Jan 5 2003 should be week 1');
<ide> test("weeks year starting wednesday", function (assert) {
<ide> assert.equal(moment([2003, 0, 13]).week(), 3, 'Jan 13 2003 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting thursday", function (assert) {
<add>test('weeks year starting thursday', function (assert) {
<ide> assert.equal(moment([2008, 11, 29]).week(), 1, 'Dec 29 2008 should be week 1');
<ide> assert.equal(moment([2009, 0, 1]).week(), 1, 'Jan 1 2009 should be week 1');
<ide> assert.equal(moment([2009, 0, 4]).week(), 1, 'Jan 4 2009 should be week 1');
<ide> test("weeks year starting thursday", function (assert) {
<ide> assert.equal(moment([2009, 0, 12]).week(), 3, 'Jan 12 2009 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting friday", function (assert) {
<add>test('weeks year starting friday', function (assert) {
<ide> assert.equal(moment([2009, 11, 28]).week(), 1, 'Dec 28 2009 should be week 1');
<ide> assert.equal(moment([2010, 0, 1]).week(), 1, 'Jan 1 2010 should be week 1');
<ide> assert.equal(moment([2010, 0, 3]).week(), 1, 'Jan 3 2010 should be week 1');
<ide> test("weeks year starting friday", function (assert) {
<ide> assert.equal(moment([2010, 0, 11]).week(), 3, 'Jan 11 2010 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting saturday", function (assert) {
<add>test('weeks year starting saturday', function (assert) {
<ide> assert.equal(moment([2010, 11, 27]).week(), 1, 'Dec 27 2010 should be week 1');
<ide> assert.equal(moment([2011, 0, 1]).week(), 1, 'Jan 1 2011 should be week 1');
<ide> assert.equal(moment([2011, 0, 2]).week(), 1, 'Jan 2 2011 should be week 1');
<ide> test("weeks year starting saturday", function (assert) {
<ide> assert.equal(moment([2011, 0, 10]).week(), 3, 'Jan 10 2011 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting sunday formatted", function (assert) {
<add>test('weeks year starting sunday formatted', function (assert) {
<ide> assert.equal(moment([2011, 11, 26]).format('w ww wo'), '1 01 1º', 'Dec 26 2011 should be week 1');
<ide> assert.equal(moment([2012, 0, 1]).format('w ww wo'), '1 01 1º', 'Jan 1 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 2]).format('w ww wo'), '2 02 2º', 'Jan 2 2012 should be week 2');
<ide> assert.equal(moment([2012, 0, 8]).format('w ww wo'), '2 02 2º', 'Jan 8 2012 should be week 2');
<ide> assert.equal(moment([2012, 0, 9]).format('w ww wo'), '3 03 3º', 'Jan 9 2012 should be week 3');
<ide> });
<ide>
<del>test("lenient ordinal parsing", function (assert) {
<add>test('lenient ordinal parsing', function (assert) {
<ide> var i, ordinalStr, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> ordinalStr = moment([2014, 0, i]).format('YYYY MM Do');
<ide> test("lenient ordinal parsing", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("lenient ordinal parsing of number", function (assert) {
<add>test('lenient ordinal parsing of number', function (assert) {
<ide> var i, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> testMoment = moment('2014 01 ' + i, 'YYYY MM Do');
<ide> test("lenient ordinal parsing of number", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("strict ordinal parsing", function (assert) {
<add>test('strict ordinal parsing', function (assert) {
<ide> var i, ordinalStr, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> ordinalStr = moment([2014, 0, i]).format('YYYY MM Do');
<ide><path>src/test/locale/he.js
<del>import {localeModule, test} from "../qunit";
<del>import {moment} from "../../moment";
<del>localeModule("he");
<add>import {localeModule, test} from '../qunit';
<add>import {moment} from '../../moment';
<add>localeModule('he');
<ide>
<del>test("parse", function (assert) {
<add>test('parse', function (assert) {
<ide> var tests = 'ינואר ינו׳_פברואר פבר׳_מרץ מרץ_אפריל אפר׳_מאי מאי_יוני יוני_יולי יולי_אוגוסט אוג׳_ספטמבר ספט׳_אוקטובר אוק׳_נובמבר נוב׳_דצמבר דצמ׳'.split('_'), i;
<ide> function equalTest(input, mmm, i) {
<ide> assert.equal(moment(input, mmm).month(), i, input + ' should be month ' + (i + 1));
<ide> test("parse", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("format", function (assert) {
<add>test('format', function (assert) {
<ide> var a = [
<ide> ['dddd, MMMM Do YYYY, h:mm:ss a', 'ראשון, פברואר 14 2010, 3:25:50 pm'],
<ide> ['ddd, hA', 'א׳, 3PM'],
<ide> test("format", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("format month", function (assert) {
<add>test('format month', function (assert) {
<ide> var expected = 'ינואר ינו׳_פברואר פבר׳_מרץ מרץ_אפריל אפר׳_מאי מאי_יוני יוני_יולי יולי_אוגוסט אוג׳_ספטמבר ספט׳_אוקטובר אוק׳_נובמבר נוב׳_דצמבר דצמ׳'.split('_'), i;
<ide> for (i = 0; i < expected.length; i++) {
<ide> assert.equal(moment([2011, i, 1]).format('MMMM MMM'), expected[i], expected[i]);
<ide> }
<ide> });
<ide>
<del>test("format week", function (assert) {
<add>test('format week', function (assert) {
<ide> var expected = 'ראשון א׳ א|שני ב׳ ב|שלישי ג׳ ג|רביעי ד׳ ד|חמישי ה׳ ה|שישי ו׳ ו|שבת ש׳ ש'.split('|'), i;
<ide> for (i = 0; i < expected.length; i++) {
<ide> assert.equal(moment([2011, 0, 2 + i]).format('dddd ddd dd'), expected[i], expected[i]);
<ide> }
<ide> });
<ide>
<del>test("from", function (assert) {
<add>test('from', function (assert) {
<ide> var start = moment([2007, 1, 28]);
<ide> assert.equal(start.from(moment([2007, 1, 28]).add({s: 44}), true), 'מספר שניות', '44 seconds = a few seconds');
<ide> assert.equal(start.from(moment([2007, 1, 28]).add({s: 45}), true), 'דקה', '45 seconds = a minute');
<ide> test("from", function (assert) {
<ide> assert.equal(start.from(moment([2007, 1, 28]).add({y: 5}), true), '5 שנים', '5 years = 5 years');
<ide> });
<ide>
<del>test("suffix", function (assert) {
<add>test('suffix', function (assert) {
<ide> assert.equal(moment(30000).from(0), 'בעוד מספר שניות', 'prefix');
<ide> assert.equal(moment(0).from(30000), 'לפני מספר שניות', 'suffix');
<ide> });
<ide>
<del>test("now from now", function (assert) {
<add>test('now from now', function (assert) {
<ide> assert.equal(moment().fromNow(), 'לפני מספר שניות', 'now from now should display as in the past');
<ide> });
<ide>
<del>test("fromNow", function (assert) {
<add>test('fromNow', function (assert) {
<ide> assert.equal(moment().add({s: 30}).fromNow(), 'בעוד מספר שניות', 'in a few seconds');
<ide> assert.equal(moment().add({d: 5}).fromNow(), 'בעוד 5 ימים', 'in 5 days');
<ide> });
<ide>
<del>test("calendar day", function (assert) {
<add>test('calendar day', function (assert) {
<ide> var a = moment().hours(2).minutes(0).seconds(0);
<ide>
<ide> assert.equal(moment(a).calendar(), 'היום ב־02:00', 'today at the same time');
<ide> test("calendar day", function (assert) {
<ide> assert.equal(moment(a).subtract({d: 1}).calendar(), 'אתמול ב־02:00', 'yesterday at the same time');
<ide> });
<ide>
<del>test("calendar next week", function (assert) {
<add>test('calendar next week', function (assert) {
<ide> var i, m;
<ide> for (i = 2; i < 7; i++) {
<ide> m = moment().add({d: i});
<ide> test("calendar next week", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("calendar last week", function (assert) {
<add>test('calendar last week', function (assert) {
<ide> var i, m;
<ide> for (i = 2; i < 7; i++) {
<ide> m = moment().subtract({d: i});
<ide> test("calendar last week", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("calendar all else", function (assert) {
<add>test('calendar all else', function (assert) {
<ide> var weeksAgo = moment().subtract({w: 1}),
<ide> weeksFromNow = moment().add({w: 1});
<ide>
<ide> test("calendar all else", function (assert) {
<ide> assert.equal(weeksFromNow.calendar(), weeksFromNow.format('L'), 'in 2 weeks');
<ide> });
<ide>
<del>test("weeks year starting sunday", function (assert) {
<add>test('weeks year starting sunday', function (assert) {
<ide> assert.equal(moment([2012, 0, 1]).week(), 1, 'Jan 1 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 7]).week(), 1, 'Jan 7 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 8]).week(), 2, 'Jan 8 2012 should be week 2');
<ide> assert.equal(moment([2012, 0, 14]).week(), 2, 'Jan 14 2012 should be week 2');
<ide> assert.equal(moment([2012, 0, 15]).week(), 3, 'Jan 15 2012 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting monday", function (assert) {
<add>test('weeks year starting monday', function (assert) {
<ide> assert.equal(moment([2006, 11, 31]).week(), 1, 'Dec 31 2006 should be week 1');
<ide> assert.equal(moment([2007, 0, 1]).week(), 1, 'Jan 1 2007 should be week 1');
<ide> assert.equal(moment([2007, 0, 6]).week(), 1, 'Jan 6 2007 should be week 1');
<ide> test("weeks year starting monday", function (assert) {
<ide> assert.equal(moment([2007, 0, 14]).week(), 3, 'Jan 14 2007 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting tuesday", function (assert) {
<add>test('weeks year starting tuesday', function (assert) {
<ide> assert.equal(moment([2007, 11, 29]).week(), 52, 'Dec 29 2007 should be week 52');
<ide> assert.equal(moment([2008, 0, 1]).week(), 1, 'Jan 1 2008 should be week 1');
<ide> assert.equal(moment([2008, 0, 5]).week(), 1, 'Jan 5 2008 should be week 1');
<ide> test("weeks year starting tuesday", function (assert) {
<ide> assert.equal(moment([2008, 0, 13]).week(), 3, 'Jan 13 2008 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting wednesday", function (assert) {
<add>test('weeks year starting wednesday', function (assert) {
<ide> assert.equal(moment([2002, 11, 29]).week(), 1, 'Dec 29 2002 should be week 1');
<ide> assert.equal(moment([2003, 0, 1]).week(), 1, 'Jan 1 2003 should be week 1');
<ide> assert.equal(moment([2003, 0, 4]).week(), 1, 'Jan 4 2003 should be week 1');
<ide> test("weeks year starting wednesday", function (assert) {
<ide> assert.equal(moment([2003, 0, 12]).week(), 3, 'Jan 12 2003 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting thursday", function (assert) {
<add>test('weeks year starting thursday', function (assert) {
<ide> assert.equal(moment([2008, 11, 28]).week(), 1, 'Dec 28 2008 should be week 1');
<ide> assert.equal(moment([2009, 0, 1]).week(), 1, 'Jan 1 2009 should be week 1');
<ide> assert.equal(moment([2009, 0, 3]).week(), 1, 'Jan 3 2009 should be week 1');
<ide> test("weeks year starting thursday", function (assert) {
<ide> assert.equal(moment([2009, 0, 11]).week(), 3, 'Jan 11 2009 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting friday", function (assert) {
<add>test('weeks year starting friday', function (assert) {
<ide> assert.equal(moment([2009, 11, 27]).week(), 1, 'Dec 27 2009 should be week 1');
<ide> assert.equal(moment([2010, 0, 1]).week(), 1, 'Jan 1 2010 should be week 1');
<ide> assert.equal(moment([2010, 0, 2]).week(), 1, 'Jan 2 2010 should be week 1');
<ide> test("weeks year starting friday", function (assert) {
<ide> assert.equal(moment([2010, 0, 10]).week(), 3, 'Jan 10 2010 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting saturday", function (assert) {
<add>test('weeks year starting saturday', function (assert) {
<ide> assert.equal(moment([2010, 11, 26]).week(), 1, 'Dec 26 2010 should be week 1');
<ide> assert.equal(moment([2011, 0, 1]).week(), 1, 'Jan 1 2011 should be week 1');
<ide> assert.equal(moment([2011, 0, 2]).week(), 2, 'Jan 2 2011 should be week 2');
<ide> assert.equal(moment([2011, 0, 8]).week(), 2, 'Jan 8 2011 should be week 2');
<ide> assert.equal(moment([2011, 0, 9]).week(), 3, 'Jan 9 2011 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting sunday format", function (assert) {
<add>test('weeks year starting sunday format', function (assert) {
<ide> assert.equal(moment([2012, 0, 1]).format('w ww wo'), '1 01 1', 'Jan 1 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 7]).format('w ww wo'), '1 01 1', 'Jan 7 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 8]).format('w ww wo'), '2 02 2', 'Jan 8 2012 should be week 2');
<ide> assert.equal(moment([2012, 0, 14]).format('w ww wo'), '2 02 2', 'Jan 14 2012 should be week 2');
<ide> assert.equal(moment([2012, 0, 15]).format('w ww wo'), '3 03 3', 'Jan 15 2012 should be week 3');
<ide> });
<ide>
<del>test("lenient ordinal parsing", function (assert) {
<add>test('lenient ordinal parsing', function (assert) {
<ide> var i, ordinalStr, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> ordinalStr = moment([2014, 0, i]).format('YYYY MM Do');
<ide> test("lenient ordinal parsing", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("lenient ordinal parsing of number", function (assert) {
<add>test('lenient ordinal parsing of number', function (assert) {
<ide> var i, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> testMoment = moment('2014 01 ' + i, 'YYYY MM Do');
<ide> test("lenient ordinal parsing of number", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("strict ordinal parsing", function (assert) {
<add>test('strict ordinal parsing', function (assert) {
<ide> var i, ordinalStr, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> ordinalStr = moment([2014, 0, i]).format('YYYY MM Do');
<ide><path>src/test/locale/hi.js
<del>import {localeModule, test} from "../qunit";
<del>import {moment} from "../../moment";
<del>localeModule("hi");
<add>import {localeModule, test} from '../qunit';
<add>import {moment} from '../../moment';
<add>localeModule('hi');
<ide>
<del>test("parse", function (assert) {
<add>test('parse', function (assert) {
<ide> var tests = 'जनवरी जन._फ़रवरी फ़र._मार्च मार्च_अप्रैल अप्रै._मई मई_जून जून_जुलाई जुल._अगस्त अग._सितम्बर सित._अक्टूबर अक्टू._नवम्बर नव._दिसम्बर दिस.'.split('_'), i;
<ide> function equalTest(input, mmm, i) {
<ide> assert.equal(moment(input, mmm).month(), i, input + ' should be month ' + (i + 1));
<ide> test("parse", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("format", function (assert) {
<add>test('format', function (assert) {
<ide> var a = [
<ide> ['dddd, Do MMMM YYYY, a h:mm:ss बजे', 'रविवार, १४ फ़रवरी २०१०, दोपहर ३:२५:५० बजे'],
<ide> ['ddd, a h बजे', 'रवि, दोपहर ३ बजे'],
<ide> test("format", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("format ordinal", function (assert) {
<add>test('format ordinal', function (assert) {
<ide> assert.equal(moment([2011, 0, 1]).format('DDDo'), '१', '१');
<ide> assert.equal(moment([2011, 0, 2]).format('DDDo'), '२', '२');
<ide> assert.equal(moment([2011, 0, 3]).format('DDDo'), '३', '३');
<ide> test("format ordinal", function (assert) {
<ide> assert.equal(moment([2011, 0, 31]).format('DDDo'), '३१', '३१');
<ide> });
<ide>
<del>test("format month", function (assert) {
<add>test('format month', function (assert) {
<ide> var expected = 'जनवरी जन._फ़रवरी फ़र._मार्च मार्च_अप्रैल अप्रै._मई मई_जून जून_जुलाई जुल._अगस्त अग._सितम्बर सित._अक्टूबर अक्टू._नवम्बर नव._दिसम्बर दिस.'.split('_'), i;
<ide> for (i = 0; i < expected.length; i++) {
<ide> assert.equal(moment([2011, i, 1]).format('MMMM MMM'), expected[i], expected[i]);
<ide> }
<ide> });
<ide>
<del>test("format week", function (assert) {
<add>test('format week', function (assert) {
<ide> var expected = 'रविवार रवि र_सोमवार सोम सो_मंगलवार मंगल मं_बुधवार बुध बु_गुरूवार गुरू गु_शुक्रवार शुक्र शु_शनिवार शनि श'.split('_'), i;
<ide> for (i = 0; i < expected.length; i++) {
<ide> assert.equal(moment([2011, 0, 2 + i]).format('dddd ddd dd'), expected[i], expected[i]);
<ide> }
<ide> });
<ide>
<del>test("from", function (assert) {
<add>test('from', function (assert) {
<ide> var start = moment([2007, 1, 28]);
<ide> assert.equal(start.from(moment([2007, 1, 28]).add({s: 44}), true), 'कुछ ही क्षण', '44 seconds = a few seconds');
<ide> assert.equal(start.from(moment([2007, 1, 28]).add({s: 45}), true), 'एक मिनट', '45 seconds = a minute');
<ide> test("from", function (assert) {
<ide> assert.equal(start.from(moment([2007, 1, 28]).add({y: 5}), true), '५ वर्ष', '5 years = 5 years');
<ide> });
<ide>
<del>test("suffix", function (assert) {
<add>test('suffix', function (assert) {
<ide> assert.equal(moment(30000).from(0), 'कुछ ही क्षण में', 'prefix');
<ide> assert.equal(moment(0).from(30000), 'कुछ ही क्षण पहले', 'suffix');
<ide> });
<ide>
<del>test("now from now", function (assert) {
<add>test('now from now', function (assert) {
<ide> assert.equal(moment().fromNow(), 'कुछ ही क्षण पहले', 'now from now should display as in the past');
<ide> });
<ide>
<del>test("fromNow", function (assert) {
<add>test('fromNow', function (assert) {
<ide> assert.equal(moment().add({s: 30}).fromNow(), 'कुछ ही क्षण में', 'कुछ ही क्षण में');
<ide> assert.equal(moment().add({d: 5}).fromNow(), '५ दिन में', '५ दिन में');
<ide> });
<ide>
<del>test("calendar day", function (assert) {
<add>test('calendar day', function (assert) {
<ide> var a = moment().hours(2).minutes(0).seconds(0);
<ide>
<ide> assert.equal(moment(a).calendar(), 'आज रात २:०० बजे', 'today at the same time');
<ide> test("calendar day", function (assert) {
<ide> assert.equal(moment(a).subtract({d: 1}).calendar(), 'कल रात २:०० बजे', 'yesterday at the same time');
<ide> });
<ide>
<del>test("calendar next week", function (assert) {
<add>test('calendar next week', function (assert) {
<ide> var i, m;
<ide> for (i = 2; i < 7; i++) {
<ide> m = moment().add({d: i});
<ide> test("calendar next week", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("calendar last week", function (assert) {
<add>test('calendar last week', function (assert) {
<ide> var i, m;
<ide>
<ide> for (i = 2; i < 7; i++) {
<ide> test("calendar last week", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("calendar all else", function (assert) {
<add>test('calendar all else', function (assert) {
<ide> var weeksAgo = moment().subtract({w: 1}),
<ide> weeksFromNow = moment().add({w: 1});
<ide>
<ide> test("calendar all else", function (assert) {
<ide> assert.equal(weeksFromNow.calendar(), weeksFromNow.format('L'), 'in 2 weeks');
<ide> });
<ide>
<del>test("meridiem invariant", function (assert) {
<add>test('meridiem invariant', function (assert) {
<ide> assert.equal(moment([2011, 2, 23, 2, 30]).format('a'), 'रात', 'before dawn');
<ide> assert.equal(moment([2011, 2, 23, 9, 30]).format('a'), 'सुबह', 'morning');
<ide> assert.equal(moment([2011, 2, 23, 14, 30]).format('a'), 'दोपहर', 'during day');
<ide> test("meridiem invariant", function (assert) {
<ide> assert.equal(moment([2011, 2, 23, 21, 20]).format('A'), 'रात', 'night');
<ide> });
<ide>
<del>test("weeks year starting sunday", function (assert) {
<add>test('weeks year starting sunday', function (assert) {
<ide> assert.equal(moment([2012, 0, 1]).week(), 1, 'Jan 1 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 7]).week(), 1, 'Jan 7 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 8]).week(), 2, 'Jan 8 2012 should be week 2');
<ide> assert.equal(moment([2012, 0, 14]).week(), 2, 'Jan 14 2012 should be week 2');
<ide> assert.equal(moment([2012, 0, 15]).week(), 3, 'Jan 15 2012 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting monday", function (assert) {
<add>test('weeks year starting monday', function (assert) {
<ide> assert.equal(moment([2006, 11, 31]).week(), 1, 'Dec 31 2006 should be week 1');
<ide> assert.equal(moment([2007, 0, 1]).week(), 1, 'Jan 1 2007 should be week 1');
<ide> assert.equal(moment([2007, 0, 6]).week(), 1, 'Jan 6 2007 should be week 1');
<ide> test("weeks year starting monday", function (assert) {
<ide> assert.equal(moment([2007, 0, 14]).week(), 3, 'Jan 14 2007 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting tuesday", function (assert) {
<add>test('weeks year starting tuesday', function (assert) {
<ide> assert.equal(moment([2007, 11, 29]).week(), 52, 'Dec 29 2007 should be week 52');
<ide> assert.equal(moment([2008, 0, 1]).week(), 1, 'Jan 1 2008 should be week 1');
<ide> assert.equal(moment([2008, 0, 5]).week(), 1, 'Jan 5 2008 should be week 1');
<ide> test("weeks year starting tuesday", function (assert) {
<ide> assert.equal(moment([2008, 0, 13]).week(), 3, 'Jan 13 2008 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting wednesday", function (assert) {
<add>test('weeks year starting wednesday', function (assert) {
<ide> assert.equal(moment([2002, 11, 29]).week(), 1, 'Dec 29 2002 should be week 1');
<ide> assert.equal(moment([2003, 0, 1]).week(), 1, 'Jan 1 2003 should be week 1');
<ide> assert.equal(moment([2003, 0, 4]).week(), 1, 'Jan 4 2003 should be week 1');
<ide> test("weeks year starting wednesday", function (assert) {
<ide> assert.equal(moment([2003, 0, 12]).week(), 3, 'Jan 12 2003 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting thursday", function (assert) {
<add>test('weeks year starting thursday', function (assert) {
<ide> assert.equal(moment([2008, 11, 28]).week(), 1, 'Dec 28 2008 should be week 1');
<ide> assert.equal(moment([2009, 0, 1]).week(), 1, 'Jan 1 2009 should be week 1');
<ide> assert.equal(moment([2009, 0, 3]).week(), 1, 'Jan 3 2009 should be week 1');
<ide> test("weeks year starting thursday", function (assert) {
<ide> assert.equal(moment([2009, 0, 11]).week(), 3, 'Jan 11 2009 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting friday", function (assert) {
<add>test('weeks year starting friday', function (assert) {
<ide> assert.equal(moment([2009, 11, 27]).week(), 1, 'Dec 27 2009 should be week 1');
<ide> assert.equal(moment([2010, 0, 1]).week(), 1, 'Jan 1 2010 should be week 1');
<ide> assert.equal(moment([2010, 0, 2]).week(), 1, 'Jan 2 2010 should be week 1');
<ide> test("weeks year starting friday", function (assert) {
<ide> assert.equal(moment([2010, 0, 10]).week(), 3, 'Jan 10 2010 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting saturday", function (assert) {
<add>test('weeks year starting saturday', function (assert) {
<ide> assert.equal(moment([2010, 11, 26]).week(), 1, 'Dec 26 2010 should be week 1');
<ide> assert.equal(moment([2011, 0, 1]).week(), 1, 'Jan 1 2011 should be week 1');
<ide> assert.equal(moment([2011, 0, 2]).week(), 2, 'Jan 2 2011 should be week 2');
<ide> assert.equal(moment([2011, 0, 8]).week(), 2, 'Jan 8 2011 should be week 2');
<ide> assert.equal(moment([2011, 0, 9]).week(), 3, 'Jan 9 2011 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting sunday formatted", function (assert) {
<add>test('weeks year starting sunday formatted', function (assert) {
<ide> assert.equal(moment([2012, 0, 1]).format('w ww wo'), '१ ०१ १', 'Jan 1 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 7]).format('w ww wo'), '१ ०१ १', 'Jan 7 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 8]).format('w ww wo'), '२ ०२ २', 'Jan 8 2012 should be week 2');
<ide> assert.equal(moment([2012, 0, 14]).format('w ww wo'), '२ ०२ २', 'Jan 14 2012 should be week 2');
<ide> assert.equal(moment([2012, 0, 15]).format('w ww wo'), '३ ०३ ३', 'Jan 15 2012 should be week 3');
<ide> });
<ide>
<del>test("lenient ordinal parsing", function (assert) {
<add>test('lenient ordinal parsing', function (assert) {
<ide> var i, ordinalStr, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> ordinalStr = moment([2014, 0, i]).format('YYYY MM Do');
<ide> test("lenient ordinal parsing", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("lenient ordinal parsing of number", function (assert) {
<add>test('lenient ordinal parsing of number', function (assert) {
<ide> var i, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> testMoment = moment('2014 01 ' + i, 'YYYY MM Do');
<ide> test("lenient ordinal parsing of number", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("meridiem", function (assert) {
<add>test('meridiem', function (assert) {
<ide> var h, m, t1, t2;
<ide> for (h = 0; h < 24; ++h) {
<ide> for (m = 0; m < 60; m += 15) {
<ide> test("meridiem", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("strict ordinal parsing", function (assert) {
<add>test('strict ordinal parsing', function (assert) {
<ide> var i, ordinalStr, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> ordinalStr = moment([2014, 0, i]).format('YYYY MM Do');
<ide><path>src/test/locale/hr.js
<del>import {localeModule, test} from "../qunit";
<del>import {moment} from "../../moment";
<del>localeModule("hr");
<add>import {localeModule, test} from '../qunit';
<add>import {moment} from '../../moment';
<add>localeModule('hr');
<ide>
<del>test("parse", function (assert) {
<add>test('parse', function (assert) {
<ide> var tests = 'sječanj sje._veljača vel._ožujak ožu._travanj tra._svibanj svi._lipanj lip._srpanj srp._kolovoz kol._rujan ruj._listopad lis._studeni stu._prosinac pro.'.split('_'), i;
<ide> function equalTest(input, mmm, i) {
<ide> assert.equal(moment(input, mmm).month(), i, input + ' should be month ' + (i + 1));
<ide> test("parse", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("format", function (assert) {
<add>test('format', function (assert) {
<ide> var a = [
<ide> ['dddd, Do MMMM YYYY, h:mm:ss a', 'nedjelja, 14. veljača 2010, 3:25:50 pm'],
<ide> ['ddd, hA', 'ned., 3PM'],
<ide> test("format", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("format ordinal", function (assert) {
<add>test('format ordinal', function (assert) {
<ide> assert.equal(moment([2011, 0, 1]).format('DDDo'), '1.', '1.');
<ide> assert.equal(moment([2011, 0, 2]).format('DDDo'), '2.', '2.');
<ide> assert.equal(moment([2011, 0, 3]).format('DDDo'), '3.', '3.');
<ide> test("format ordinal", function (assert) {
<ide> assert.equal(moment([2011, 0, 31]).format('DDDo'), '31.', '31.');
<ide> });
<ide>
<del>test("format month", function (assert) {
<add>test('format month', function (assert) {
<ide> var expected = 'sječanj sje._veljača vel._ožujak ožu._travanj tra._svibanj svi._lipanj lip._srpanj srp._kolovoz kol._rujan ruj._listopad lis._studeni stu._prosinac pro.'.split('_'), i;
<ide> for (i = 0; i < expected.length; i++) {
<ide> assert.equal(moment([2011, i, 1]).format('MMMM MMM'), expected[i], expected[i]);
<ide> }
<ide> });
<ide>
<del>test("format week", function (assert) {
<add>test('format week', function (assert) {
<ide> var expected = 'nedjelja ned. ne_ponedjeljak pon. po_utorak uto. ut_srijeda sri. sr_četvrtak čet. če_petak pet. pe_subota sub. su'.split('_'), i;
<ide> for (i = 0; i < expected.length; i++) {
<ide> assert.equal(moment([2011, 0, 2 + i]).format('dddd ddd dd'), expected[i], expected[i]);
<ide> }
<ide> });
<ide>
<del>test("from", function (assert) {
<add>test('from', function (assert) {
<ide> var start = moment([2007, 1, 28]);
<ide> assert.equal(start.from(moment([2007, 1, 28]).add({s: 44}), true), 'par sekundi', '44 seconds = a few seconds');
<ide> assert.equal(start.from(moment([2007, 1, 28]).add({s: 45}), true), 'jedna minuta', '45 seconds = a minute');
<ide> test("from", function (assert) {
<ide> assert.equal(start.from(moment([2007, 1, 28]).add({y: 5}), true), '5 godina', '5 years = 5 years');
<ide> });
<ide>
<del>test("suffix", function (assert) {
<add>test('suffix', function (assert) {
<ide> assert.equal(moment(30000).from(0), 'za par sekundi', 'prefix');
<ide> assert.equal(moment(0).from(30000), 'prije par sekundi', 'prefix');
<ide> });
<ide>
<del>test("now from now", function (assert) {
<add>test('now from now', function (assert) {
<ide> assert.equal(moment().fromNow(), 'prije par sekundi', 'now from now should display as in the past');
<ide> });
<ide>
<del>test("fromNow", function (assert) {
<add>test('fromNow', function (assert) {
<ide> assert.equal(moment().add({s: 30}).fromNow(), 'za par sekundi', 'in a few seconds');
<ide> assert.equal(moment().add({d: 5}).fromNow(), 'za 5 dana', 'in 5 days');
<ide> });
<ide>
<del>test("calendar day", function (assert) {
<add>test('calendar day', function (assert) {
<ide> var a = moment().hours(2).minutes(0).seconds(0);
<ide>
<ide> assert.equal(moment(a).calendar(), 'danas u 2:00', 'today at the same time');
<ide> test("calendar day", function (assert) {
<ide> assert.equal(moment(a).subtract({d: 1}).calendar(), 'jučer u 2:00', 'yesterday at the same time');
<ide> });
<ide>
<del>test("calendar next week", function (assert) {
<add>test('calendar next week', function (assert) {
<ide> var i, m;
<ide>
<ide> function makeFormat(d) {
<ide> test("calendar next week", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("calendar last week", function (assert) {
<add>test('calendar last week', function (assert) {
<ide> var i, m;
<ide>
<ide> function makeFormat(d) {
<ide> test("calendar last week", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("calendar all else", function (assert) {
<add>test('calendar all else', function (assert) {
<ide> var weeksAgo = moment().subtract({w: 1}),
<ide> weeksFromNow = moment().add({w: 1});
<ide>
<ide> test("calendar all else", function (assert) {
<ide> assert.equal(weeksFromNow.calendar(), weeksFromNow.format('L'), 'in 2 weeks');
<ide> });
<ide>
<del>test("weeks year starting sunday", function (assert) {
<add>test('weeks year starting sunday', function (assert) {
<ide> assert.equal(moment([2011, 11, 26]).week(), 1, 'Dec 26 2011 should be week 1');
<ide> assert.equal(moment([2012, 0, 1]).week(), 1, 'Jan 1 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 2]).week(), 2, 'Jan 2 2012 should be week 2');
<ide> assert.equal(moment([2012, 0, 8]).week(), 2, 'Jan 8 2012 should be week 2');
<ide> assert.equal(moment([2012, 0, 9]).week(), 3, 'Jan 9 2012 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting monday", function (assert) {
<add>test('weeks year starting monday', function (assert) {
<ide> assert.equal(moment([2007, 0, 1]).week(), 1, 'Jan 1 2007 should be week 1');
<ide> assert.equal(moment([2007, 0, 7]).week(), 1, 'Jan 7 2007 should be week 1');
<ide> assert.equal(moment([2007, 0, 8]).week(), 2, 'Jan 8 2007 should be week 2');
<ide> assert.equal(moment([2007, 0, 14]).week(), 2, 'Jan 14 2007 should be week 2');
<ide> assert.equal(moment([2007, 0, 15]).week(), 3, 'Jan 15 2007 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting tuesday", function (assert) {
<add>test('weeks year starting tuesday', function (assert) {
<ide> assert.equal(moment([2007, 11, 31]).week(), 1, 'Dec 31 2007 should be week 1');
<ide> assert.equal(moment([2008, 0, 1]).week(), 1, 'Jan 1 2008 should be week 1');
<ide> assert.equal(moment([2008, 0, 6]).week(), 1, 'Jan 6 2008 should be week 1');
<ide> test("weeks year starting tuesday", function (assert) {
<ide> assert.equal(moment([2008, 0, 14]).week(), 3, 'Jan 14 2008 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting wednesday", function (assert) {
<add>test('weeks year starting wednesday', function (assert) {
<ide> assert.equal(moment([2002, 11, 30]).week(), 1, 'Dec 30 2002 should be week 1');
<ide> assert.equal(moment([2003, 0, 1]).week(), 1, 'Jan 1 2003 should be week 1');
<ide> assert.equal(moment([2003, 0, 5]).week(), 1, 'Jan 5 2003 should be week 1');
<ide> test("weeks year starting wednesday", function (assert) {
<ide> assert.equal(moment([2003, 0, 13]).week(), 3, 'Jan 13 2003 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting thursday", function (assert) {
<add>test('weeks year starting thursday', function (assert) {
<ide> assert.equal(moment([2008, 11, 29]).week(), 1, 'Dec 29 2008 should be week 1');
<ide> assert.equal(moment([2009, 0, 1]).week(), 1, 'Jan 1 2009 should be week 1');
<ide> assert.equal(moment([2009, 0, 4]).week(), 1, 'Jan 4 2009 should be week 1');
<ide> test("weeks year starting thursday", function (assert) {
<ide> assert.equal(moment([2009, 0, 12]).week(), 3, 'Jan 12 2009 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting friday", function (assert) {
<add>test('weeks year starting friday', function (assert) {
<ide> assert.equal(moment([2009, 11, 28]).week(), 1, 'Dec 28 2009 should be week 1');
<ide> assert.equal(moment([2010, 0, 1]).week(), 1, 'Jan 1 2010 should be week 1');
<ide> assert.equal(moment([2010, 0, 3]).week(), 1, 'Jan 3 2010 should be week 1');
<ide> test("weeks year starting friday", function (assert) {
<ide> assert.equal(moment([2010, 0, 11]).week(), 3, 'Jan 11 2010 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting saturday", function (assert) {
<add>test('weeks year starting saturday', function (assert) {
<ide> assert.equal(moment([2010, 11, 27]).week(), 1, 'Dec 27 2010 should be week 1');
<ide> assert.equal(moment([2011, 0, 1]).week(), 1, 'Jan 1 2011 should be week 1');
<ide> assert.equal(moment([2011, 0, 2]).week(), 1, 'Jan 2 2011 should be week 1');
<ide> test("weeks year starting saturday", function (assert) {
<ide> assert.equal(moment([2011, 0, 10]).week(), 3, 'Jan 10 2011 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting sunday formatted", function (assert) {
<add>test('weeks year starting sunday formatted', function (assert) {
<ide> assert.equal(moment([2011, 11, 26]).format('w ww wo'), '1 01 1.', 'Dec 26 2011 should be week 1');
<ide> assert.equal(moment([2012, 0, 1]).format('w ww wo'), '1 01 1.', 'Jan 1 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 2]).format('w ww wo'), '2 02 2.', 'Jan 2 2012 should be week 2');
<ide> assert.equal(moment([2012, 0, 8]).format('w ww wo'), '2 02 2.', 'Jan 8 2012 should be week 2');
<ide> assert.equal(moment([2012, 0, 9]).format('w ww wo'), '3 03 3.', 'Jan 9 2012 should be week 3');
<ide> });
<ide>
<del>test("lenient ordinal parsing", function (assert) {
<add>test('lenient ordinal parsing', function (assert) {
<ide> var i, ordinalStr, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> ordinalStr = moment([2014, 0, i]).format('YYYY MM Do');
<ide> test("lenient ordinal parsing", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("lenient ordinal parsing of number", function (assert) {
<add>test('lenient ordinal parsing of number', function (assert) {
<ide> var i, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> testMoment = moment('2014 01 ' + i, 'YYYY MM Do');
<ide> test("lenient ordinal parsing of number", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("strict ordinal parsing", function (assert) {
<add>test('strict ordinal parsing', function (assert) {
<ide> var i, ordinalStr, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> ordinalStr = moment([2014, 0, i]).format('YYYY MM Do');
<ide><path>src/test/locale/hu.js
<del>import {localeModule, test} from "../qunit";
<del>import {moment} from "../../moment";
<del>localeModule("hu");
<add>import {localeModule, test} from '../qunit';
<add>import {moment} from '../../moment';
<add>localeModule('hu');
<ide>
<del>test("parse", function (assert) {
<add>test('parse', function (assert) {
<ide> var tests = 'január jan_február feb_március márc_április ápr_május máj_június jún_július júl_augusztus aug_szeptember szept_október okt_november nov_december dec'.split('_'),
<ide> i;
<ide> function equalTest(input, mmm, i) {
<ide> test("parse", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("format", function (assert) {
<add>test('format', function (assert) {
<ide> var a = [
<ide> ['dddd, MMMM Do YYYY, HH:mm:ss', 'vasárnap, február 14. 2010, 15:25:50'],
<ide> ['ddd, HH', 'vas, 15'],
<ide> test("format", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("meridiem", function (assert) {
<add>test('meridiem', function (assert) {
<ide> assert.equal(moment([2011, 2, 23, 0, 0]).format('a'), 'de', 'am');
<ide> assert.equal(moment([2011, 2, 23, 11, 59]).format('a'), 'de', 'am');
<ide> assert.equal(moment([2011, 2, 23, 12, 0]).format('a'), 'du', 'pm');
<ide> test("meridiem", function (assert) {
<ide> assert.equal(moment([2011, 2, 23, 23, 59]).format('A'), 'DU', 'PM');
<ide> });
<ide>
<del>test("format ordinal", function (assert) {
<add>test('format ordinal', function (assert) {
<ide> assert.equal(moment([2011, 0, 1]).format('DDDo'), '1.', '1.');
<ide> assert.equal(moment([2011, 0, 2]).format('DDDo'), '2.', '2.');
<ide> assert.equal(moment([2011, 0, 3]).format('DDDo'), '3.', '3.');
<ide> test("format ordinal", function (assert) {
<ide> assert.equal(moment([2011, 0, 31]).format('DDDo'), '31.', '31.');
<ide> });
<ide>
<del>test("format month", function (assert) {
<add>test('format month', function (assert) {
<ide> var expected = 'január jan_február feb_március márc_április ápr_május máj_június jún_július júl_augusztus aug_szeptember szept_október okt_november nov_december dec'.split('_'),
<ide> i;
<ide> for (i = 0; i < expected.length; i++) {
<ide> assert.equal(moment([2011, i, 1]).format('MMMM MMM'), expected[i], expected[i]);
<ide> }
<ide> });
<ide>
<del>test("format week", function (assert) {
<add>test('format week', function (assert) {
<ide> var expected = 'vasárnap vas_hétfő hét_kedd kedd_szerda sze_csütörtök csüt_péntek pén_szombat szo'.split('_'),
<ide> i;
<ide> for (i = 0; i < expected.length; i++) {
<ide> assert.equal(moment([2011, 0, 2 + i]).format('dddd ddd'), expected[i], expected[i]);
<ide> }
<ide> });
<ide>
<del>test("from", function (assert) {
<add>test('from', function (assert) {
<ide> var start = moment([2007, 1, 28]);
<ide> assert.equal(start.from(moment([2007, 1, 28]).add({s: 44}), true), 'néhány másodperc', '44 másodperc = néhány másodperc');
<ide> assert.equal(start.from(moment([2007, 1, 28]).add({s: 45}), true), 'egy perc', '45 másodperc = egy perc');
<ide> test("from", function (assert) {
<ide> assert.equal(start.from(moment([2007, 1, 28]).add({y: 5}), true), '5 év', '5 év = 5 év');
<ide> });
<ide>
<del>test("suffix", function (assert) {
<add>test('suffix', function (assert) {
<ide> assert.equal(moment(30000).from(0), 'néhány másodperc múlva', 'prefix');
<ide> assert.equal(moment(0).from(30000), 'néhány másodperce', 'suffix');
<ide> });
<ide>
<del>test("now from now", function (assert) {
<add>test('now from now', function (assert) {
<ide> assert.equal(moment().fromNow(), 'néhány másodperce', 'now from now should display as in the past');
<ide> });
<ide>
<del>test("fromNow", function (assert) {
<add>test('fromNow', function (assert) {
<ide> assert.equal(moment().add({s: 30}).fromNow(), 'néhány másodperc múlva', 'néhány másodperc múlva');
<ide> assert.equal(moment().add({d: 5}).fromNow(), '5 nap múlva', '5 nap múlva');
<ide> });
<ide>
<del>test("calendar day", function (assert) {
<add>test('calendar day', function (assert) {
<ide> var a = moment().hours(2).minutes(0).seconds(0);
<ide>
<ide> assert.equal(moment(a).calendar(), 'ma 2:00-kor', 'today at the same time');
<ide> test("calendar day", function (assert) {
<ide> assert.equal(moment(a).subtract({d: 1}).calendar(), 'tegnap 2:00-kor', 'yesterday at the same time');
<ide> });
<ide>
<del>test("calendar next week", function (assert) {
<add>test('calendar next week', function (assert) {
<ide> var i, m, days = 'vasárnap_hétfőn_kedden_szerdán_csütörtökön_pénteken_szombaton'.split('_');
<ide> for (i = 2; i < 7; i++) {
<ide> m = moment().add({d: i});
<ide> test("calendar next week", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("calendar last week", function (assert) {
<add>test('calendar last week', function (assert) {
<ide> var i, m, days = 'vasárnap_hétfőn_kedden_szerdán_csütörtökön_pénteken_szombaton'.split('_');
<ide>
<ide> for (i = 2; i < 7; i++) {
<ide> test("calendar last week", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("calendar all else", function (assert) {
<add>test('calendar all else', function (assert) {
<ide> var weeksAgo = moment().subtract({w: 1}),
<ide> weeksFromNow = moment().add({w: 1});
<ide>
<ide> test("calendar all else", function (assert) {
<ide> assert.equal(weeksFromNow.calendar(), weeksFromNow.format('L'), '2 hét múlva');
<ide> });
<ide>
<del>test("weeks year starting sunday", function (assert) {
<add>test('weeks year starting sunday', function (assert) {
<ide> assert.equal(moment([2011, 11, 26]).week(), 1, 'Dec 26 2011 should be week 1');
<ide> assert.equal(moment([2012, 0, 1]).week(), 1, 'Jan 1 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 2]).week(), 2, 'Jan 2 2012 should be week 2');
<ide> assert.equal(moment([2012, 0, 8]).week(), 2, 'Jan 8 2012 should be week 2');
<ide> assert.equal(moment([2012, 0, 9]).week(), 3, 'Jan 9 2012 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting monday", function (assert) {
<add>test('weeks year starting monday', function (assert) {
<ide> assert.equal(moment([2007, 0, 1]).week(), 1, 'Jan 1 2007 should be week 1');
<ide> assert.equal(moment([2007, 0, 7]).week(), 1, 'Jan 7 2007 should be week 1');
<ide> assert.equal(moment([2007, 0, 8]).week(), 2, 'Jan 8 2007 should be week 2');
<ide> assert.equal(moment([2007, 0, 14]).week(), 2, 'Jan 14 2007 should be week 2');
<ide> assert.equal(moment([2007, 0, 15]).week(), 3, 'Jan 15 2007 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting tuesday", function (assert) {
<add>test('weeks year starting tuesday', function (assert) {
<ide> assert.equal(moment([2007, 11, 31]).week(), 1, 'Dec 31 2007 should be week 1');
<ide> assert.equal(moment([2008, 0, 1]).week(), 1, 'Jan 1 2008 should be week 1');
<ide> assert.equal(moment([2008, 0, 6]).week(), 1, 'Jan 6 2008 should be week 1');
<ide> test("weeks year starting tuesday", function (assert) {
<ide> assert.equal(moment([2008, 0, 14]).week(), 3, 'Jan 14 2008 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting wednesday", function (assert) {
<add>test('weeks year starting wednesday', function (assert) {
<ide> assert.equal(moment([2002, 11, 30]).week(), 1, 'Dec 30 2002 should be week 1');
<ide> assert.equal(moment([2003, 0, 1]).week(), 1, 'Jan 1 2003 should be week 1');
<ide> assert.equal(moment([2003, 0, 5]).week(), 1, 'Jan 5 2003 should be week 1');
<ide> test("weeks year starting wednesday", function (assert) {
<ide> assert.equal(moment([2003, 0, 13]).week(), 3, 'Jan 13 2003 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting thursday", function (assert) {
<add>test('weeks year starting thursday', function (assert) {
<ide> assert.equal(moment([2008, 11, 29]).week(), 1, 'Dec 29 2008 should be week 1');
<ide> assert.equal(moment([2009, 0, 1]).week(), 1, 'Jan 1 2009 should be week 1');
<ide> assert.equal(moment([2009, 0, 4]).week(), 1, 'Jan 4 2009 should be week 1');
<ide> test("weeks year starting thursday", function (assert) {
<ide> assert.equal(moment([2009, 0, 12]).week(), 3, 'Jan 12 2009 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting friday", function (assert) {
<add>test('weeks year starting friday', function (assert) {
<ide> assert.equal(moment([2009, 11, 28]).week(), 1, 'Dec 28 2009 should be week 1');
<ide> assert.equal(moment([2010, 0, 1]).week(), 1, 'Jan 1 2010 should be week 1');
<ide> assert.equal(moment([2010, 0, 3]).week(), 1, 'Jan 3 2010 should be week 1');
<ide> test("weeks year starting friday", function (assert) {
<ide> assert.equal(moment([2010, 0, 11]).week(), 3, 'Jan 11 2010 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting saturday", function (assert) {
<add>test('weeks year starting saturday', function (assert) {
<ide> assert.equal(moment([2010, 11, 27]).week(), 1, 'Dec 27 2010 should be week 1');
<ide> assert.equal(moment([2011, 0, 1]).week(), 1, 'Jan 1 2011 should be week 1');
<ide> assert.equal(moment([2011, 0, 2]).week(), 1, 'Jan 2 2011 should be week 1');
<ide> test("weeks year starting saturday", function (assert) {
<ide> assert.equal(moment([2011, 0, 10]).week(), 3, 'Jan 10 2011 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting sunday formatted", function (assert) {
<add>test('weeks year starting sunday formatted', function (assert) {
<ide> assert.equal(moment([2011, 11, 26]).format('w ww wo'), '1 01 1.', 'Dec 26 2011 should be week 1');
<ide> assert.equal(moment([2012, 0, 1]).format('w ww wo'), '1 01 1.', 'Jan 1 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 2]).format('w ww wo'), '2 02 2.', 'Jan 2 2012 should be week 2');
<ide> assert.equal(moment([2012, 0, 8]).format('w ww wo'), '2 02 2.', 'Jan 8 2012 should be week 2');
<ide> assert.equal(moment([2012, 0, 9]).format('w ww wo'), '3 03 3.', 'Jan 9 2012 should be week 3');
<ide> });
<ide>
<del>test("lenient ordinal parsing", function (assert) {
<add>test('lenient ordinal parsing', function (assert) {
<ide> var i, ordinalStr, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> ordinalStr = moment([2014, 0, i]).format('YYYY MM Do');
<ide> test("lenient ordinal parsing", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("lenient ordinal parsing of number", function (assert) {
<add>test('lenient ordinal parsing of number', function (assert) {
<ide> var i, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> testMoment = moment('2014 01 ' + i, 'YYYY MM Do');
<ide> test("lenient ordinal parsing of number", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("strict ordinal parsing", function (assert) {
<add>test('strict ordinal parsing', function (assert) {
<ide> var i, ordinalStr, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> ordinalStr = moment([2014, 0, i]).format('YYYY MM Do');
<ide><path>src/test/locale/hy-am.js
<del>import {localeModule, test} from "../qunit";
<del>import {moment} from "../../moment";
<del>localeModule("hy-am");
<add>import {localeModule, test} from '../qunit';
<add>import {moment} from '../../moment';
<add>localeModule('hy-am');
<ide>
<del>test("parse", function (assert) {
<add>test('parse', function (assert) {
<ide> var tests = 'հունվար հնվ_փետրվար փտր_մարտ մրտ_ապրիլ ապր_մայիս մյս_հունիս հնս_հուլիս հլս_օգոստոս օգս_սեպտեմբեր սպտ_հոկտեմբեր հկտ_նոյեմբեր նմբ_դեկտեմբեր դկտ'.split('_'), i;
<ide> function equalTest(input, mmm, i) {
<ide> assert.equal(moment(input, mmm).month(), i, input + ' should be month ' + (i + 1));
<ide> test("parse", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("parse exceptional case", function (assert) {
<add>test('parse exceptional case', function (assert) {
<ide> assert.equal(moment('11 մայիսի 1989', ['DD MMMM YYYY']).format('DD-MM-YYYY'), '11-05-1989');
<ide> });
<ide>
<del>test("format", function (assert) {
<add>test('format', function (assert) {
<ide> var a = [
<ide> ['dddd, Do MMMM YYYY, HH:mm:ss', 'կիրակի, 14 փետրվարի 2010, 15:25:50'],
<ide> ['ddd, h A', 'կրկ, 3 ցերեկվա'],
<ide> test("format", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("format meridiem", function (assert) {
<add>test('format meridiem', function (assert) {
<ide> assert.equal(moment([2012, 11, 28, 0, 0]).format('A'), 'գիշերվա', 'night');
<ide> assert.equal(moment([2012, 11, 28, 3, 59]).format('A'), 'գիշերվա', 'night');
<ide> assert.equal(moment([2012, 11, 28, 4, 0]).format('A'), 'առավոտվա', 'morning');
<ide> test("format meridiem", function (assert) {
<ide> assert.equal(moment([2012, 11, 28, 23, 59]).format('A'), 'երեկոյան', 'evening');
<ide> });
<ide>
<del>test("format ordinal", function (assert) {
<add>test('format ordinal', function (assert) {
<ide> assert.equal(moment([2011, 0, 1]).format('DDDo'), '1-ին', '1-ին');
<ide> assert.equal(moment([2011, 0, 2]).format('DDDo'), '2-րդ', '2-րդ');
<ide> assert.equal(moment([2011, 0, 3]).format('DDDo'), '3-րդ', '3-րդ');
<ide> test("format ordinal", function (assert) {
<ide> assert.equal(moment([2011, 0, 31]).format('DDDo'), '31-րդ', '31-րդ');
<ide> });
<ide>
<del>test("format month", function (assert) {
<add>test('format month', function (assert) {
<ide> var expected = 'հունվար հնվ_փետրվար փտր_մարտ մրտ_ապրիլ ապր_մայիս մյս_հունիս հնս_հուլիս հլս_օգոստոս օգս_սեպտեմբեր սպտ_հոկտեմբեր հկտ_նոյեմբեր նմբ_դեկտեմբեր դկտ'.split('_'), i;
<ide> for (i = 0; i < expected.length; i++) {
<ide> assert.equal(moment([2011, i, 1]).format('MMMM MMM'), expected[i], expected[i]);
<ide> }
<ide> });
<ide>
<del>test("format month case", function (assert) {
<add>test('format month case', function (assert) {
<ide> var months = {
<ide> 'nominative': 'հունվար_փետրվար_մարտ_ապրիլ_մայիս_հունիս_հուլիս_օգոստոս_սեպտեմբեր_հոկտեմբեր_նոյեմբեր_դեկտեմբեր'.split('_'),
<ide> 'accusative': 'հունվարի_փետրվարի_մարտի_ապրիլի_մայիսի_հունիսի_հուլիսի_օգոստոսի_սեպտեմբերի_հոկտեմբերի_նոյեմբերի_դեկտեմբերի'.split('_')
<ide> test("format month case", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("format month short case", function (assert) {
<add>test('format month short case', function (assert) {
<ide> var monthsShort = {
<ide> 'nominative': 'հնվ_փտր_մրտ_ապր_մյս_հնս_հլս_օգս_սպտ_հկտ_նմբ_դկտ'.split('_'),
<ide> 'accusative': 'հնվ_փտր_մրտ_ապր_մյս_հնս_հլս_օգս_սպտ_հկտ_նմբ_դկտ'.split('_')
<ide> test("format month short case", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("format month case with escaped symbols", function (assert) {
<add>test('format month case with escaped symbols', function (assert) {
<ide> var months = {
<ide> 'nominative': 'հունվար_փետրվար_մարտ_ապրիլ_մայիս_հունիս_հուլիս_օգոստոս_սեպտեմբեր_հոկտեմբեր_նոյեմբեր_դեկտեմբեր'.split('_'),
<ide> 'accusative': 'հունվարի_փետրվարի_մարտի_ապրիլի_մայիսի_հունիսի_հուլիսի_օգոստոսի_սեպտեմբերի_հոկտեմբերի_նոյեմբերի_դեկտեմբերի'.split('_')
<ide> test("format month case with escaped symbols", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("format month short case with escaped symbols", function (assert) {
<add>test('format month short case with escaped symbols', function (assert) {
<ide> var monthsShort = {
<ide> 'nominative': 'հնվ_փտր_մրտ_ապր_մյս_հնս_հլս_օգս_սպտ_հկտ_նմբ_դկտ'.split('_'),
<ide> 'accusative': 'հնվ_փտր_մրտ_ապր_մյս_հնս_հլս_օգս_սպտ_հկտ_նմբ_դկտ'.split('_')
<ide> test("format month short case with escaped symbols", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("format week", function (assert) {
<add>test('format week', function (assert) {
<ide> var expected = 'կիրակի կրկ կրկ_երկուշաբթի երկ երկ_երեքշաբթի երք երք_չորեքշաբթի չրք չրք_հինգշաբթի հնգ հնգ_ուրբաթ ուրբ ուրբ_շաբաթ շբթ շբթ'.split('_'), i;
<ide> for (i = 0; i < expected.length; i++) {
<ide> assert.equal(moment([2011, 0, 2 + i]).format('dddd ddd dd'), expected[i], expected[i]);
<ide> }
<ide> });
<ide>
<del>test("from", function (assert) {
<add>test('from', function (assert) {
<ide> var start = moment([2007, 1, 28]);
<ide> assert.equal(start.from(moment([2007, 1, 28]).add({s: 44}), true), 'մի քանի վայրկյան', '44 seconds = seconds');
<ide> assert.equal(start.from(moment([2007, 1, 28]).add({s: 45}), true), 'րոպե', '45 seconds = a minute');
<ide> test("from", function (assert) {
<ide> assert.equal(start.from(moment([2007, 1, 28]).add({y: 5}), true), '5 տարի', '5 years = 5 years');
<ide> });
<ide>
<del>test("suffix", function (assert) {
<add>test('suffix', function (assert) {
<ide> assert.equal(moment(30000).from(0), 'մի քանի վայրկյան հետո', 'prefix');
<ide> assert.equal(moment(0).from(30000), 'մի քանի վայրկյան առաջ', 'suffix');
<ide> });
<ide>
<del>test("fromNow", function (assert) {
<add>test('fromNow', function (assert) {
<ide> assert.equal(moment().add({s: 30}).fromNow(), 'մի քանի վայրկյան հետո', 'in seconds');
<ide> assert.equal(moment().add({d: 5}).fromNow(), '5 օր հետո', 'in 5 days');
<ide> });
<ide>
<del>test("calendar day", function (assert) {
<add>test('calendar day', function (assert) {
<ide> var a = moment().hours(2).minutes(0).seconds(0);
<ide>
<ide> assert.equal(moment(a).calendar(), 'այսօր 02:00', 'today at the same time');
<ide> test("calendar day", function (assert) {
<ide> assert.equal(moment(a).subtract({d: 1}).calendar(), 'երեկ 02:00', 'yesterday at the same time');
<ide> });
<ide>
<del>test("calendar next week", function (assert) {
<add>test('calendar next week', function (assert) {
<ide> var i, m;
<ide> function makeFormat(d) {
<ide> return 'dddd [օրը ժամը] LT';
<ide> test("calendar next week", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("calendar last week", function (assert) {
<add>test('calendar last week', function (assert) {
<ide> var i, m;
<ide>
<ide> function makeFormat(d) {
<ide> test("calendar last week", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("calendar all else", function (assert) {
<add>test('calendar all else', function (assert) {
<ide> var weeksAgo = moment().subtract({w: 1}),
<ide> weeksFromNow = moment().add({w: 1});
<ide>
<ide> test("calendar all else", function (assert) {
<ide> assert.equal(weeksFromNow.calendar(), weeksFromNow.format('L'), 'in 2 weeks');
<ide> });
<ide>
<del>test("weeks year starting sunday", function (assert) {
<add>test('weeks year starting sunday', function (assert) {
<ide> assert.equal(moment([2011, 11, 26]).week(), 1, 'Dec 26 2011 should be week 1');
<ide> assert.equal(moment([2012, 0, 1]).week(), 1, 'Jan 1 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 2]).week(), 2, 'Jan 2 2012 should be week 2');
<ide> assert.equal(moment([2012, 0, 8]).week(), 2, 'Jan 8 2012 should be week 2');
<ide> assert.equal(moment([2012, 0, 9]).week(), 3, 'Jan 9 2012 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting monday", function (assert) {
<add>test('weeks year starting monday', function (assert) {
<ide> assert.equal(moment([2007, 0, 1]).week(), 1, 'Jan 1 2007 should be week 1');
<ide> assert.equal(moment([2007, 0, 7]).week(), 1, 'Jan 7 2007 should be week 1');
<ide> assert.equal(moment([2007, 0, 8]).week(), 2, 'Jan 8 2007 should be week 2');
<ide> assert.equal(moment([2007, 0, 14]).week(), 2, 'Jan 14 2007 should be week 2');
<ide> assert.equal(moment([2007, 0, 15]).week(), 3, 'Jan 15 2007 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting tuesday", function (assert) {
<add>test('weeks year starting tuesday', function (assert) {
<ide> assert.equal(moment([2007, 11, 31]).week(), 1, 'Dec 31 2007 should be week 1');
<ide> assert.equal(moment([2008, 0, 1]).week(), 1, 'Jan 1 2008 should be week 1');
<ide> assert.equal(moment([2008, 0, 6]).week(), 1, 'Jan 6 2008 should be week 1');
<ide> test("weeks year starting tuesday", function (assert) {
<ide> assert.equal(moment([2008, 0, 14]).week(), 3, 'Jan 14 2008 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting wednesday", function (assert) {
<add>test('weeks year starting wednesday', function (assert) {
<ide> assert.equal(moment([2002, 11, 30]).week(), 1, 'Dec 30 2002 should be week 1');
<ide> assert.equal(moment([2003, 0, 1]).week(), 1, 'Jan 1 2003 should be week 1');
<ide> assert.equal(moment([2003, 0, 5]).week(), 1, 'Jan 5 2003 should be week 1');
<ide> test("weeks year starting wednesday", function (assert) {
<ide> assert.equal(moment([2003, 0, 13]).week(), 3, 'Jan 13 2003 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting thursday", function (assert) {
<add>test('weeks year starting thursday', function (assert) {
<ide> assert.equal(moment([2008, 11, 29]).week(), 1, 'Dec 29 2008 should be week 1');
<ide> assert.equal(moment([2009, 0, 1]).week(), 1, 'Jan 1 2009 should be week 1');
<ide> assert.equal(moment([2009, 0, 4]).week(), 1, 'Jan 4 2009 should be week 1');
<ide> test("weeks year starting thursday", function (assert) {
<ide> assert.equal(moment([2009, 0, 12]).week(), 3, 'Jan 12 2009 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting friday", function (assert) {
<add>test('weeks year starting friday', function (assert) {
<ide> assert.equal(moment([2009, 11, 28]).week(), 1, 'Dec 28 2009 should be week 1');
<ide> assert.equal(moment([2010, 0, 1]).week(), 1, 'Jan 1 2010 should be week 1');
<ide> assert.equal(moment([2010, 0, 3]).week(), 1, 'Jan 3 2010 should be week 1');
<ide> test("weeks year starting friday", function (assert) {
<ide> assert.equal(moment([2010, 0, 11]).week(), 3, 'Jan 11 2010 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting saturday", function (assert) {
<add>test('weeks year starting saturday', function (assert) {
<ide> assert.equal(moment([2010, 11, 27]).week(), 1, 'Dec 27 2010 should be week 1');
<ide> assert.equal(moment([2011, 0, 1]).week(), 1, 'Jan 1 2011 should be week 1');
<ide> assert.equal(moment([2011, 0, 2]).week(), 1, 'Jan 2 2011 should be week 1');
<ide> test("weeks year starting saturday", function (assert) {
<ide> assert.equal(moment([2011, 0, 10]).week(), 3, 'Jan 10 2011 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting sunday formatted", function (assert) {
<add>test('weeks year starting sunday formatted', function (assert) {
<ide> assert.equal(moment([2011, 11, 26]).format('w ww wo'), '1 01 1-ին', 'Dec 26 2011 should be week 1');
<ide> assert.equal(moment([2012, 0, 1]).format('w ww wo'), '1 01 1-ին', 'Jan 1 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 2]).format('w ww wo'), '2 02 2-րդ', 'Jan 2 2012 should be week 2');
<ide> assert.equal(moment([2012, 0, 8]).format('w ww wo'), '2 02 2-րդ', 'Jan 8 2012 should be week 2');
<ide> assert.equal(moment([2012, 0, 9]).format('w ww wo'), '3 03 3-րդ', 'Jan 9 2012 should be week 3');
<ide> });
<ide>
<del>test("lenient ordinal parsing", function (assert) {
<add>test('lenient ordinal parsing', function (assert) {
<ide> var i, ordinalStr, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> ordinalStr = moment([2014, 0, i]).format('YYYY MM Do');
<ide> test("lenient ordinal parsing", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("lenient ordinal parsing of number", function (assert) {
<add>test('lenient ordinal parsing of number', function (assert) {
<ide> var i, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> testMoment = moment('2014 01 ' + i, 'YYYY MM Do');
<ide> test("lenient ordinal parsing of number", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("strict ordinal parsing", function (assert) {
<add>test('strict ordinal parsing', function (assert) {
<ide> var i, ordinalStr, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> ordinalStr = moment([2014, 0, i]).format('YYYY MM Do');
<ide><path>src/test/locale/id.js
<del>import {localeModule, test} from "../qunit";
<del>import {moment} from "../../moment";
<del>localeModule("id");
<add>import {localeModule, test} from '../qunit';
<add>import {moment} from '../../moment';
<add>localeModule('id');
<ide>
<del>test("parse", function (assert) {
<add>test('parse', function (assert) {
<ide> var tests = 'Januari Jan_Februari Feb_Maret Mar_April Apr_Mei Mei_Juni Jun_Juli Jul_Agustus Ags_September Sep_Oktober Okt_November Nov_Desember Des'.split('_'), i;
<ide> function equalTest(input, mmm, i) {
<ide> assert.equal(moment(input, mmm).month(), i, input + ' should be month ' + (i + 1));
<ide> test("parse", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("format", function (assert) {
<add>test('format', function (assert) {
<ide> var a = [
<ide> ['dddd, MMMM Do YYYY, h:mm:ss a', 'Minggu, Februari 14 2010, 3:25:50 sore'],
<ide> ['ddd, hA', 'Min, 3sore'],
<ide> test("format", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("format month", function (assert) {
<add>test('format month', function (assert) {
<ide> var expected = 'Januari Jan_Februari Feb_Maret Mar_April Apr_Mei Mei_Juni Jun_Juli Jul_Agustus Ags_September Sep_Oktober Okt_November Nov_Desember Des'.split('_'), i;
<ide> for (i = 0; i < expected.length; i++) {
<ide> assert.equal(moment([2011, i, 1]).format('MMMM MMM'), expected[i], expected[i]);
<ide> }
<ide> });
<ide>
<del>test("format week", function (assert) {
<add>test('format week', function (assert) {
<ide> var expected = 'Minggu Min Mg_Senin Sen Sn_Selasa Sel Sl_Rabu Rab Rb_Kamis Kam Km_Jumat Jum Jm_Sabtu Sab Sb'.split('_'), i;
<ide> for (i = 0; i < expected.length; i++) {
<ide> assert.equal(moment([2011, 0, 2 + i]).format('dddd ddd dd'), expected[i], expected[i]);
<ide> }
<ide> });
<ide>
<del>test("from", function (assert) {
<add>test('from', function (assert) {
<ide> var start = moment([2007, 1, 28]);
<ide> assert.equal(start.from(moment([2007, 1, 28]).add({s: 44}), true), 'beberapa detik', '44 seconds = a few seconds');
<ide> assert.equal(start.from(moment([2007, 1, 28]).add({s: 45}), true), 'semenit', '45 seconds = a minute');
<ide> test("from", function (assert) {
<ide> assert.equal(start.from(moment([2007, 1, 28]).add({y: 5}), true), '5 tahun', '5 years = 5 years');
<ide> });
<ide>
<del>test("suffix", function (assert) {
<add>test('suffix', function (assert) {
<ide> assert.equal(moment(30000).from(0), 'dalam beberapa detik', 'prefix');
<ide> assert.equal(moment(0).from(30000), 'beberapa detik yang lalu', 'suffix');
<ide> });
<ide>
<del>test("now from now", function (assert) {
<add>test('now from now', function (assert) {
<ide> assert.equal(moment().fromNow(), 'beberapa detik yang lalu', 'now from now should display as in the past');
<ide> });
<ide>
<del>test("fromNow", function (assert) {
<add>test('fromNow', function (assert) {
<ide> assert.equal(moment().add({s: 30}).fromNow(), 'dalam beberapa detik', 'in a few seconds');
<ide> assert.equal(moment().add({d: 5}).fromNow(), 'dalam 5 hari', 'in 5 days');
<ide> });
<ide>
<del>test("calendar day", function (assert) {
<add>test('calendar day', function (assert) {
<ide> var a = moment().hours(2).minutes(0).seconds(0);
<ide>
<ide> assert.equal(moment(a).calendar(), 'Hari ini pukul 02.00', 'today at the same time');
<ide> test("calendar day", function (assert) {
<ide> assert.equal(moment(a).subtract({d: 1}).calendar(), 'Kemarin pukul 02.00', 'yesterday at the same time');
<ide> });
<ide>
<del>test("calendar next week", function (assert) {
<add>test('calendar next week', function (assert) {
<ide> var i, m;
<ide> for (i = 2; i < 7; i++) {
<ide> m = moment().add({d: i});
<ide> test("calendar next week", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("calendar last week", function (assert) {
<add>test('calendar last week', function (assert) {
<ide> var i, m;
<ide> for (i = 2; i < 7; i++) {
<ide> m = moment().subtract({d: i});
<ide> test("calendar last week", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("calendar all else", function (assert) {
<add>test('calendar all else', function (assert) {
<ide> var weeksAgo = moment().subtract({w: 1}),
<ide> weeksFromNow = moment().add({w: 1});
<ide>
<ide> test("calendar all else", function (assert) {
<ide> assert.equal(weeksFromNow.calendar(), weeksFromNow.format('L'), 'in 2 weeks');
<ide> });
<ide>
<del>test("weeks year starting sunday", function (assert) {
<add>test('weeks year starting sunday', function (assert) {
<ide> assert.equal(moment([2011, 11, 26]).week(), 1, 'Dec 26 2011 should be week 1');
<ide> assert.equal(moment([2012, 0, 1]).week(), 1, 'Jan 1 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 2]).week(), 2, 'Jan 2 2012 should be week 2');
<ide> assert.equal(moment([2012, 0, 8]).week(), 2, 'Jan 8 2012 should be week 2');
<ide> assert.equal(moment([2012, 0, 9]).week(), 3, 'Jan 9 2012 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting monday", function (assert) {
<add>test('weeks year starting monday', function (assert) {
<ide> assert.equal(moment([2007, 0, 1]).week(), 1, 'Jan 1 2007 should be week 1');
<ide> assert.equal(moment([2007, 0, 7]).week(), 1, 'Jan 7 2007 should be week 1');
<ide> assert.equal(moment([2007, 0, 8]).week(), 2, 'Jan 8 2007 should be week 2');
<ide> assert.equal(moment([2007, 0, 14]).week(), 2, 'Jan 14 2007 should be week 2');
<ide> assert.equal(moment([2007, 0, 15]).week(), 3, 'Jan 15 2007 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting tuesday", function (assert) {
<add>test('weeks year starting tuesday', function (assert) {
<ide> assert.equal(moment([2007, 11, 31]).week(), 1, 'Dec 31 2007 should be week 1');
<ide> assert.equal(moment([2008, 0, 1]).week(), 1, 'Jan 1 2008 should be week 1');
<ide> assert.equal(moment([2008, 0, 6]).week(), 1, 'Jan 6 2008 should be week 1');
<ide> test("weeks year starting tuesday", function (assert) {
<ide> assert.equal(moment([2008, 0, 14]).week(), 3, 'Jan 14 2008 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting wednesday", function (assert) {
<add>test('weeks year starting wednesday', function (assert) {
<ide> assert.equal(moment([2002, 11, 30]).week(), 1, 'Dec 30 2002 should be week 1');
<ide> assert.equal(moment([2003, 0, 1]).week(), 1, 'Jan 1 2003 should be week 1');
<ide> assert.equal(moment([2003, 0, 5]).week(), 1, 'Jan 5 2003 should be week 1');
<ide> test("weeks year starting wednesday", function (assert) {
<ide> assert.equal(moment([2003, 0, 13]).week(), 3, 'Jan 13 2003 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting thursday", function (assert) {
<add>test('weeks year starting thursday', function (assert) {
<ide> assert.equal(moment([2008, 11, 29]).week(), 1, 'Dec 29 2008 should be week 1');
<ide> assert.equal(moment([2009, 0, 1]).week(), 1, 'Jan 1 2009 should be week 1');
<ide> assert.equal(moment([2009, 0, 4]).week(), 1, 'Jan 4 2009 should be week 1');
<ide> test("weeks year starting thursday", function (assert) {
<ide> assert.equal(moment([2009, 0, 12]).week(), 3, 'Jan 12 2009 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting friday", function (assert) {
<add>test('weeks year starting friday', function (assert) {
<ide> assert.equal(moment([2009, 11, 28]).week(), 1, 'Dec 28 2009 should be week 1');
<ide> assert.equal(moment([2010, 0, 1]).week(), 1, 'Jan 1 2010 should be week 1');
<ide> assert.equal(moment([2010, 0, 3]).week(), 1, 'Jan 3 2010 should be week 1');
<ide> test("weeks year starting friday", function (assert) {
<ide> assert.equal(moment([2010, 0, 11]).week(), 3, 'Jan 11 2010 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting saturday", function (assert) {
<add>test('weeks year starting saturday', function (assert) {
<ide> assert.equal(moment([2010, 11, 27]).week(), 1, 'Dec 27 2010 should be week 1');
<ide> assert.equal(moment([2011, 0, 1]).week(), 1, 'Jan 1 2011 should be week 1');
<ide> assert.equal(moment([2011, 0, 2]).week(), 1, 'Jan 2 2011 should be week 1');
<ide> test("weeks year starting saturday", function (assert) {
<ide> assert.equal(moment([2011, 0, 10]).week(), 3, 'Jan 10 2011 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting sunday formatted", function (assert) {
<add>test('weeks year starting sunday formatted', function (assert) {
<ide> assert.equal(moment([2011, 11, 26]).format('w ww wo'), '1 01 1', 'Dec 26 2011 should be week 1');
<ide> assert.equal(moment([2012, 0, 1]).format('w ww wo'), '1 01 1', 'Jan 1 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 2]).format('w ww wo'), '2 02 2', 'Jan 2 2012 should be week 2');
<ide> assert.equal(moment([2012, 0, 8]).format('w ww wo'), '2 02 2', 'Jan 8 2012 should be week 2');
<ide> assert.equal(moment([2012, 0, 9]).format('w ww wo'), '3 03 3', 'Jan 9 2012 should be week 3');
<ide> });
<ide>
<del>test("lenient ordinal parsing", function (assert) {
<add>test('lenient ordinal parsing', function (assert) {
<ide> var i, ordinalStr, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> ordinalStr = moment([2014, 0, i]).format('YYYY MM Do');
<ide> test("lenient ordinal parsing", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("lenient ordinal parsing of number", function (assert) {
<add>test('lenient ordinal parsing of number', function (assert) {
<ide> var i, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> testMoment = moment('2014 01 ' + i, 'YYYY MM Do');
<ide> test("lenient ordinal parsing of number", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("meridiem invariant", function (assert) {
<add>test('meridiem invariant', function (assert) {
<ide> var h, m, t1, t2;
<ide> for (h = 0; h < 24; ++h) {
<ide> for (m = 0; m < 60; m += 15) {
<ide> test("meridiem invariant", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("strict ordinal parsing", function (assert) {
<add>test('strict ordinal parsing', function (assert) {
<ide> var i, ordinalStr, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> ordinalStr = moment([2014, 0, i]).format('YYYY MM Do');
<ide><path>src/test/locale/is.js
<del>import {localeModule, test} from "../qunit";
<del>import {moment} from "../../moment";
<del>localeModule("is");
<add>import {localeModule, test} from '../qunit';
<add>import {moment} from '../../moment';
<add>localeModule('is');
<ide>
<del>test("parse", function (assert) {
<add>test('parse', function (assert) {
<ide> var tests = 'janúar jan_febrúar feb_mars mar_apríl apr_maí maí_júní jún_júlí júl_ágúst ágú_september sep_október okt_nóvember nóv_desember des'.split('_'), i;
<ide> function equalTest(input, mmm, i) {
<ide> assert.equal(moment(input, mmm).month(), i, input + ' should be month ' + (i + 1));
<ide> test("parse", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("format", function (assert) {
<add>test('format', function (assert) {
<ide> var a = [
<ide> ['dddd, Do MMMM YYYY, h:mm:ss a', 'sunnudagur, 14. febrúar 2010, 3:25:50 pm'],
<ide> ['ddd, hA', 'sun, 3PM'],
<ide> test("format", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("format ordinal", function (assert) {
<add>test('format ordinal', function (assert) {
<ide> assert.equal(moment([2011, 0, 1]).format('DDDo'), '1.', '1.');
<ide> assert.equal(moment([2011, 0, 2]).format('DDDo'), '2.', '2.');
<ide> assert.equal(moment([2011, 0, 3]).format('DDDo'), '3.', '3.');
<ide> test("format ordinal", function (assert) {
<ide> assert.equal(moment([2011, 0, 31]).format('DDDo'), '31.', '31.');
<ide> });
<ide>
<del>test("format month", function (assert) {
<add>test('format month', function (assert) {
<ide> var expected = 'janúar jan_febrúar feb_mars mar_apríl apr_maí maí_júní jún_júlí júl_ágúst ágú_september sep_október okt_nóvember nóv_desember des'.split('_'), i;
<ide> for (i = 0; i < expected.length; i++) {
<ide> assert.equal(moment([2011, i, 1]).format('MMMM MMM'), expected[i], expected[i]);
<ide> }
<ide> });
<ide>
<del>test("format week", function (assert) {
<add>test('format week', function (assert) {
<ide> var expected = 'sunnudagur sun Su_mánudagur mán Má_þriðjudagur þri Þr_miðvikudagur mið Mi_fimmtudagur fim Fi_föstudagur fös Fö_laugardagur lau La'.split('_'), i;
<ide> for (i = 0; i < expected.length; i++) {
<ide> assert.equal(moment([2011, 0, 2 + i]).format('dddd ddd dd'), expected[i], expected[i]);
<ide> }
<ide> });
<ide>
<del>test("from", function (assert) {
<add>test('from', function (assert) {
<ide> var start = moment([2007, 1, 28]);
<ide> assert.equal(start.from(moment([2007, 1, 28]).add({s: 44}), true), 'nokkrar sekúndur', '44 seconds = a few seconds');
<ide> assert.equal(start.from(moment([2007, 1, 28]).add({s: 45}), true), 'mínúta', '45 seconds = a minute');
<ide> test("from", function (assert) {
<ide> assert.equal(start.from(moment([2007, 1, 28]).add({y: 21}), true), '21 ár', '21 years = 21 years');
<ide> });
<ide>
<del>test("suffix", function (assert) {
<add>test('suffix', function (assert) {
<ide> assert.equal(moment(30000).from(0), 'eftir nokkrar sekúndur', 'prefix');
<ide> assert.equal(moment(0).from(30000), 'fyrir nokkrum sekúndum síðan', 'suffix');
<ide> assert.equal(moment().subtract({m: 1}).fromNow(), 'fyrir mínútu síðan', 'a minute ago');
<ide> });
<ide>
<del>test("now from now", function (assert) {
<add>test('now from now', function (assert) {
<ide> assert.equal(moment().fromNow(), 'fyrir nokkrum sekúndum síðan', 'now from now should display as in the past');
<ide> });
<ide>
<del>test("fromNow", function (assert) {
<add>test('fromNow', function (assert) {
<ide> assert.equal(moment().add({s: 30}).fromNow(), 'eftir nokkrar sekúndur', 'in a few seconds');
<ide> assert.equal(moment().add({m: 1}).fromNow(), 'eftir mínútu', 'in a minute');
<ide> assert.equal(moment().add({d: 5}).fromNow(), 'eftir 5 daga', 'in 5 days');
<ide> });
<ide>
<del>test("calendar day", function (assert) {
<add>test('calendar day', function (assert) {
<ide> var a = moment().hours(2).minutes(0).seconds(0);
<ide>
<ide> assert.equal(moment(a).calendar(), 'í dag kl. 2:00', 'today at the same time');
<ide> test("calendar day", function (assert) {
<ide> assert.equal(moment(a).subtract({d: 1}).calendar(), 'í gær kl. 2:00', 'yesterday at the same time');
<ide> });
<ide>
<del>test("calendar next week", function (assert) {
<add>test('calendar next week', function (assert) {
<ide> var i, m;
<ide> for (i = 2; i < 7; i++) {
<ide> m = moment().add({d: i});
<ide> test("calendar next week", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("calendar last week", function (assert) {
<add>test('calendar last week', function (assert) {
<ide> var i, m;
<ide>
<ide> for (i = 2; i < 7; i++) {
<ide> test("calendar last week", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("calendar all else", function (assert) {
<add>test('calendar all else', function (assert) {
<ide> var weeksAgo = moment().subtract({w: 1}),
<ide> weeksFromNow = moment().add({w: 1});
<ide>
<ide> test("calendar all else", function (assert) {
<ide> assert.equal(weeksFromNow.calendar(), weeksFromNow.format('L'), 'in 2 weeks');
<ide> });
<ide>
<del>test("weeks year starting sunday", function (assert) {
<add>test('weeks year starting sunday', function (assert) {
<ide> assert.equal(moment([2012, 0, 1]).week(), 52, 'Jan 1 2012 should be week 52');
<ide> assert.equal(moment([2012, 0, 2]).week(), 1, 'Jan 2 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 8]).week(), 1, 'Jan 8 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 9]).week(), 2, 'Jan 9 2012 should be week 2');
<ide> assert.equal(moment([2012, 0, 15]).week(), 2, 'Jan 15 2012 should be week 2');
<ide> });
<ide>
<del>test("weeks year starting monday", function (assert) {
<add>test('weeks year starting monday', function (assert) {
<ide> assert.equal(moment([2007, 0, 1]).week(), 1, 'Jan 1 2007 should be week 1');
<ide> assert.equal(moment([2007, 0, 7]).week(), 1, 'Jan 7 2007 should be week 1');
<ide> assert.equal(moment([2007, 0, 8]).week(), 2, 'Jan 8 2007 should be week 2');
<ide> assert.equal(moment([2007, 0, 14]).week(), 2, 'Jan 14 2007 should be week 2');
<ide> assert.equal(moment([2007, 0, 15]).week(), 3, 'Jan 15 2007 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting tuesday", function (assert) {
<add>test('weeks year starting tuesday', function (assert) {
<ide> assert.equal(moment([2007, 11, 31]).week(), 1, 'Dec 31 2007 should be week 1');
<ide> assert.equal(moment([2008, 0, 1]).week(), 1, 'Jan 1 2008 should be week 1');
<ide> assert.equal(moment([2008, 0, 6]).week(), 1, 'Jan 6 2008 should be week 1');
<ide> test("weeks year starting tuesday", function (assert) {
<ide> assert.equal(moment([2008, 0, 14]).week(), 3, 'Jan 14 2008 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting wednesday", function (assert) {
<add>test('weeks year starting wednesday', function (assert) {
<ide> assert.equal(moment([2002, 11, 30]).week(), 1, 'Dec 30 2002 should be week 1');
<ide> assert.equal(moment([2003, 0, 1]).week(), 1, 'Jan 1 2003 should be week 1');
<ide> assert.equal(moment([2003, 0, 5]).week(), 1, 'Jan 5 2003 should be week 1');
<ide> test("weeks year starting wednesday", function (assert) {
<ide> assert.equal(moment([2003, 0, 13]).week(), 3, 'Jan 13 2003 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting thursday", function (assert) {
<add>test('weeks year starting thursday', function (assert) {
<ide> assert.equal(moment([2008, 11, 29]).week(), 1, 'Dec 29 2008 should be week 1');
<ide> assert.equal(moment([2009, 0, 1]).week(), 1, 'Jan 1 2009 should be week 1');
<ide> assert.equal(moment([2009, 0, 4]).week(), 1, 'Jan 4 2009 should be week 1');
<ide> test("weeks year starting thursday", function (assert) {
<ide> assert.equal(moment([2009, 0, 13]).week(), 3, 'Jan 12 2009 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting friday", function (assert) {
<add>test('weeks year starting friday', function (assert) {
<ide> assert.equal(moment([2009, 11, 28]).week(), 53, 'Dec 28 2009 should be week 53');
<ide> assert.equal(moment([2010, 0, 1]).week(), 53, 'Jan 1 2010 should be week 53');
<ide> assert.equal(moment([2010, 0, 3]).week(), 53, 'Jan 3 2010 should be week 53');
<ide> test("weeks year starting friday", function (assert) {
<ide> assert.equal(moment([2010, 0, 11]).week(), 2, 'Jan 11 2010 should be week 2');
<ide> });
<ide>
<del>test("weeks year starting saturday", function (assert) {
<add>test('weeks year starting saturday', function (assert) {
<ide> assert.equal(moment([2010, 11, 27]).week(), 52, 'Dec 27 2010 should be week 52');
<ide> assert.equal(moment([2011, 0, 1]).week(), 52, 'Jan 1 2011 should be week 52');
<ide> assert.equal(moment([2011, 0, 2]).week(), 52, 'Jan 2 2011 should be week 52');
<ide> test("weeks year starting saturday", function (assert) {
<ide> assert.equal(moment([2011, 0, 10]).week(), 2, 'Jan 10 2011 should be week 2');
<ide> });
<ide>
<del>test("weeks year starting sunday formatted", function (assert) {
<add>test('weeks year starting sunday formatted', function (assert) {
<ide> assert.equal(moment([2012, 0, 1]).format('w ww wo'), '52 52 52.', 'Jan 1 2012 should be week 52');
<ide> assert.equal(moment([2012, 0, 2]).format('w ww wo'), '1 01 1.', 'Jan 2 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 8]).format('w ww wo'), '1 01 1.', 'Jan 8 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 9]).format('w ww wo'), '2 02 2.', 'Jan 9 2012 should be week 2');
<ide> assert.equal(moment([2012, 0, 15]).format('w ww wo'), '2 02 2.', 'Jan 15 2012 should be week 2');
<ide> });
<ide>
<del>test("lenient ordinal parsing", function (assert) {
<add>test('lenient ordinal parsing', function (assert) {
<ide> var i, ordinalStr, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> ordinalStr = moment([2014, 0, i]).format('YYYY MM Do');
<ide> test("lenient ordinal parsing", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("lenient ordinal parsing of number", function (assert) {
<add>test('lenient ordinal parsing of number', function (assert) {
<ide> var i, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> testMoment = moment('2014 01 ' + i, 'YYYY MM Do');
<ide> test("lenient ordinal parsing of number", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("strict ordinal parsing", function (assert) {
<add>test('strict ordinal parsing', function (assert) {
<ide> var i, ordinalStr, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> ordinalStr = moment([2014, 0, i]).format('YYYY MM Do');
<ide><path>src/test/locale/it.js
<del>import {localeModule, test} from "../qunit";
<del>import {moment} from "../../moment";
<del>localeModule("it");
<add>import {localeModule, test} from '../qunit';
<add>import {moment} from '../../moment';
<add>localeModule('it');
<ide>
<del>test("parse", function (assert) {
<add>test('parse', function (assert) {
<ide> var tests = 'gennaio gen_febbraio feb_marzo mar_aprile apr_maggio mag_giugno giu_luglio lug_agosto ago_settembre set_ottobre ott_novembre nov_dicembre dic'.split('_'), i;
<ide> function equalTest(input, mmm, i) {
<ide> assert.equal(moment(input, mmm).month(), i, input + ' should be month ' + (i + 1));
<ide> test("parse", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("format", function (assert) {
<add>test('format', function (assert) {
<ide> var a = [
<ide> ['dddd, MMMM Do YYYY, h:mm:ss a', 'Domenica, febbraio 14º 2010, 3:25:50 pm'],
<ide> ['ddd, hA', 'Dom, 3PM'],
<ide> test("format", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("format ordinal", function (assert) {
<add>test('format ordinal', function (assert) {
<ide> assert.equal(moment([2011, 0, 1]).format('DDDo'), '1º', '1º');
<ide> assert.equal(moment([2011, 0, 2]).format('DDDo'), '2º', '2º');
<ide> assert.equal(moment([2011, 0, 3]).format('DDDo'), '3º', '3º');
<ide> test("format ordinal", function (assert) {
<ide> assert.equal(moment([2011, 0, 31]).format('DDDo'), '31º', '31º');
<ide> });
<ide>
<del>test("format month", function (assert) {
<add>test('format month', function (assert) {
<ide> var expected = 'gennaio gen_febbraio feb_marzo mar_aprile apr_maggio mag_giugno giu_luglio lug_agosto ago_settembre set_ottobre ott_novembre nov_dicembre dic'.split('_'), i;
<ide> for (i = 0; i < expected.length; i++) {
<ide> assert.equal(moment([2011, i, 1]).format('MMMM MMM'), expected[i], expected[i]);
<ide> }
<ide> });
<ide>
<del>test("format week", function (assert) {
<add>test('format week', function (assert) {
<ide> var expected = 'Domenica Dom D_Lunedì Lun L_Martedì Mar Ma_Mercoledì Mer Me_Giovedì Gio G_Venerdì Ven V_Sabato Sab S'.split('_'), i;
<ide> for (i = 0; i < expected.length; i++) {
<ide> assert.equal(moment([2011, 0, 2 + i]).format('dddd ddd dd'), expected[i], expected[i]);
<ide> }
<ide> });
<ide>
<del>test("from", function (assert) {
<add>test('from', function (assert) {
<ide> var start = moment([2007, 1, 28]);
<ide> assert.equal(start.from(moment([2007, 1, 28]).add({s: 44}), true), 'alcuni secondi', '44 seconds = seconds');
<ide> assert.equal(start.from(moment([2007, 1, 28]).add({s: 45}), true), 'un minuto', '45 seconds = a minute');
<ide> test("from", function (assert) {
<ide> assert.equal(start.from(moment([2007, 1, 28]).add({y: 5}), true), '5 anni', '5 years = 5 years');
<ide> });
<ide>
<del>test("suffix", function (assert) {
<add>test('suffix', function (assert) {
<ide> assert.equal(moment(30000).from(0), 'in alcuni secondi', 'prefix');
<ide> assert.equal(moment(0).from(30000), 'alcuni secondi fa', 'suffix');
<ide> });
<ide>
<del>test("fromNow", function (assert) {
<add>test('fromNow', function (assert) {
<ide> assert.equal(moment().add({s: 30}).fromNow(), 'in alcuni secondi', 'in seconds');
<ide> assert.equal(moment().add({d: 5}).fromNow(), 'tra 5 giorni', 'in 5 days');
<ide> });
<ide>
<del>test("calendar day", function (assert) {
<add>test('calendar day', function (assert) {
<ide> var a = moment().hours(2).minutes(0).seconds(0);
<ide>
<ide> assert.equal(moment(a).calendar(), 'Oggi alle 02:00', 'today at the same time');
<ide> test("calendar day", function (assert) {
<ide> assert.equal(moment(a).subtract({d: 1}).calendar(), 'Ieri alle 02:00', 'yesterday at the same time');
<ide> });
<ide>
<del>test("calendar next week", function (assert) {
<add>test('calendar next week', function (assert) {
<ide> var i, m;
<ide> for (i = 2; i < 7; i++) {
<ide> m = moment().add({d: i});
<ide> test("calendar next week", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("calendar last week", function (assert) {
<add>test('calendar last week', function (assert) {
<ide> var i, m, weekday, datestring;
<ide> for (i = 2; i < 7; i++) {
<ide> m = moment().subtract({d: i});
<ide> test("calendar last week", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("calendar all else", function (assert) {
<add>test('calendar all else', function (assert) {
<ide> var weeksAgo = moment().subtract({w: 1}),
<ide> weeksFromNow = moment().add({w: 1});
<ide>
<ide> test("calendar all else", function (assert) {
<ide> assert.equal(weeksFromNow.calendar(), weeksFromNow.format('L'), 'in 2 weeks');
<ide> });
<ide>
<del>test("weeks year starting sunday", function (assert) {
<add>test('weeks year starting sunday', function (assert) {
<ide> assert.equal(moment([2012, 0, 1]).week(), 52, 'Jan 1 2012 should be week 52');
<ide> assert.equal(moment([2012, 0, 2]).week(), 1, 'Jan 2 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 8]).week(), 1, 'Jan 8 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 9]).week(), 2, 'Jan 9 2012 should be week 2');
<ide> assert.equal(moment([2012, 0, 15]).week(), 2, 'Jan 15 2012 should be week 2');
<ide> });
<ide>
<del>test("weeks year starting monday", function (assert) {
<add>test('weeks year starting monday', function (assert) {
<ide> assert.equal(moment([2007, 0, 1]).week(), 1, 'Jan 1 2007 should be week 1');
<ide> assert.equal(moment([2007, 0, 7]).week(), 1, 'Jan 7 2007 should be week 1');
<ide> assert.equal(moment([2007, 0, 8]).week(), 2, 'Jan 8 2007 should be week 2');
<ide> assert.equal(moment([2007, 0, 14]).week(), 2, 'Jan 14 2007 should be week 2');
<ide> assert.equal(moment([2007, 0, 15]).week(), 3, 'Jan 15 2007 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting tuesday", function (assert) {
<add>test('weeks year starting tuesday', function (assert) {
<ide> assert.equal(moment([2007, 11, 31]).week(), 1, 'Dec 31 2007 should be week 1');
<ide> assert.equal(moment([2008, 0, 1]).week(), 1, 'Jan 1 2008 should be week 1');
<ide> assert.equal(moment([2008, 0, 6]).week(), 1, 'Jan 6 2008 should be week 1');
<ide> test("weeks year starting tuesday", function (assert) {
<ide> assert.equal(moment([2008, 0, 14]).week(), 3, 'Jan 14 2008 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting wednesday", function (assert) {
<add>test('weeks year starting wednesday', function (assert) {
<ide> assert.equal(moment([2002, 11, 30]).week(), 1, 'Dec 30 2002 should be week 1');
<ide> assert.equal(moment([2003, 0, 1]).week(), 1, 'Jan 1 2003 should be week 1');
<ide> assert.equal(moment([2003, 0, 5]).week(), 1, 'Jan 5 2003 should be week 1');
<ide> test("weeks year starting wednesday", function (assert) {
<ide> assert.equal(moment([2003, 0, 13]).week(), 3, 'Jan 13 2003 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting thursday", function (assert) {
<add>test('weeks year starting thursday', function (assert) {
<ide> assert.equal(moment([2008, 11, 29]).week(), 1, 'Dec 29 2008 should be week 1');
<ide> assert.equal(moment([2009, 0, 1]).week(), 1, 'Jan 1 2009 should be week 1');
<ide> assert.equal(moment([2009, 0, 4]).week(), 1, 'Jan 4 2009 should be week 1');
<ide> test("weeks year starting thursday", function (assert) {
<ide> assert.equal(moment([2009, 0, 13]).week(), 3, 'Jan 12 2009 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting friday", function (assert) {
<add>test('weeks year starting friday', function (assert) {
<ide> assert.equal(moment([2009, 11, 28]).week(), 53, 'Dec 28 2009 should be week 53');
<ide> assert.equal(moment([2010, 0, 1]).week(), 53, 'Jan 1 2010 should be week 53');
<ide> assert.equal(moment([2010, 0, 3]).week(), 53, 'Jan 3 2010 should be week 53');
<ide> test("weeks year starting friday", function (assert) {
<ide> assert.equal(moment([2010, 0, 11]).week(), 2, 'Jan 11 2010 should be week 2');
<ide> });
<ide>
<del>test("weeks year starting saturday", function (assert) {
<add>test('weeks year starting saturday', function (assert) {
<ide> assert.equal(moment([2010, 11, 27]).week(), 52, 'Dec 27 2010 should be week 52');
<ide> assert.equal(moment([2011, 0, 1]).week(), 52, 'Jan 1 2011 should be week 52');
<ide> assert.equal(moment([2011, 0, 2]).week(), 52, 'Jan 2 2011 should be week 52');
<ide> test("weeks year starting saturday", function (assert) {
<ide> assert.equal(moment([2011, 0, 10]).week(), 2, 'Jan 10 2011 should be week 2');
<ide> });
<ide>
<del>test("weeks year starting sunday formatted", function (assert) {
<add>test('weeks year starting sunday formatted', function (assert) {
<ide> assert.equal(moment([2012, 0, 1]).format('w ww wo'), '52 52 52º', 'Jan 1 2012 should be week 52');
<ide> assert.equal(moment([2012, 0, 2]).format('w ww wo'), '1 01 1º', 'Jan 2 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 8]).format('w ww wo'), '1 01 1º', 'Jan 8 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 9]).format('w ww wo'), '2 02 2º', 'Jan 9 2012 should be week 2');
<ide> assert.equal(moment([2012, 0, 15]).format('w ww wo'), '2 02 2º', 'Jan 15 2012 should be week 2');
<ide> });
<ide>
<del>test("lenient ordinal parsing", function (assert) {
<add>test('lenient ordinal parsing', function (assert) {
<ide> var i, ordinalStr, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> ordinalStr = moment([2014, 0, i]).format('YYYY MM Do');
<ide> test("lenient ordinal parsing", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("lenient ordinal parsing of number", function (assert) {
<add>test('lenient ordinal parsing of number', function (assert) {
<ide> var i, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> testMoment = moment('2014 01 ' + i, 'YYYY MM Do');
<ide> test("lenient ordinal parsing of number", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("strict ordinal parsing", function (assert) {
<add>test('strict ordinal parsing', function (assert) {
<ide> var i, ordinalStr, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> ordinalStr = moment([2014, 0, i]).format('YYYY MM Do');
<ide><path>src/test/locale/ja.js
<del>import {localeModule, test} from "../qunit";
<del>import {moment} from "../../moment";
<del>localeModule("ja");
<add>import {localeModule, test} from '../qunit';
<add>import {moment} from '../../moment';
<add>localeModule('ja');
<ide>
<del>test("parse", function (assert) {
<add>test('parse', function (assert) {
<ide> var tests = '1月 1月_2月 2月_3月 3月_4月 4月_5月 5月_6月 6月_7月 7月_8月 8月_9月 9月_10月 10月_11月 11月_12月 12月'.split('_'), i;
<ide> function equalTest(input, mmm, i) {
<ide> assert.equal(moment(input, mmm).month(), i, input + ' should be month ' + (i + 1));
<ide> test("parse", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("format", function (assert) {
<add>test('format', function (assert) {
<ide> var a = [
<ide> ['dddd, MMMM Do YYYY, a h:mm:ss', '日曜日, 2月 14 2010, 午後 3:25:50'],
<ide> ['ddd, Ah', '日, 午後3'],
<ide> test("format", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("format month", function (assert) {
<add>test('format month', function (assert) {
<ide> var expected = '1月 1月_2月 2月_3月 3月_4月 4月_5月 5月_6月 6月_7月 7月_8月 8月_9月 9月_10月 10月_11月 11月_12月 12月'.split('_'), i;
<ide> for (i = 0; i < expected.length; i++) {
<ide> assert.equal(moment([2011, i, 1]).format('MMMM MMM'), expected[i], expected[i]);
<ide> }
<ide> });
<ide>
<del>test("format week", function (assert) {
<add>test('format week', function (assert) {
<ide> var expected = '日曜日 日 日_月曜日 月 月_火曜日 火 火_水曜日 水 水_木曜日 木 木_金曜日 金 金_土曜日 土 土'.split('_'), i;
<ide> for (i = 0; i < expected.length; i++) {
<ide> assert.equal(moment([2011, 0, 2 + i]).format('dddd ddd dd'), expected[i], expected[i]);
<ide> }
<ide> });
<ide>
<del>test("from", function (assert) {
<add>test('from', function (assert) {
<ide> var start = moment([2007, 1, 28]);
<ide> assert.equal(start.from(moment([2007, 1, 28]).add({s: 44}), true), '数秒', '44 seconds = a few seconds');
<ide> assert.equal(start.from(moment([2007, 1, 28]).add({s: 45}), true), '1分', '45 seconds = a minute');
<ide> test("from", function (assert) {
<ide> assert.equal(start.from(moment([2007, 1, 28]).add({y: 5}), true), '5年', '5 years = 5 years');
<ide> });
<ide>
<del>test("suffix", function (assert) {
<add>test('suffix', function (assert) {
<ide> assert.equal(moment(30000).from(0), '数秒後', 'prefix');
<ide> assert.equal(moment(0).from(30000), '数秒前', 'suffix');
<ide> });
<ide>
<del>test("now from now", function (assert) {
<add>test('now from now', function (assert) {
<ide> assert.equal(moment().fromNow(), '数秒前', 'now from now should display as in the past');
<ide> });
<ide>
<del>test("fromNow", function (assert) {
<add>test('fromNow', function (assert) {
<ide> assert.equal(moment().add({s: 30}).fromNow(), '数秒後', 'in a few seconds');
<ide> assert.equal(moment().add({d: 5}).fromNow(), '5日後', 'in 5 days');
<ide> });
<ide>
<del>test("calendar day", function (assert) {
<add>test('calendar day', function (assert) {
<ide> var a = moment().hours(2).minutes(0).seconds(0);
<ide>
<ide> assert.equal(moment(a).calendar(), '今日 午前2時0分', 'today at the same time');
<ide> test("calendar day", function (assert) {
<ide> assert.equal(moment(a).subtract({d: 1}).calendar(), '昨日 午前2時0分', 'yesterday at the same time');
<ide> });
<ide>
<del>test("calendar next week", function (assert) {
<add>test('calendar next week', function (assert) {
<ide> var i, m;
<ide> for (i = 2; i < 7; i++) {
<ide> m = moment().add({d: i});
<ide> test("calendar next week", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("calendar last week", function (assert) {
<add>test('calendar last week', function (assert) {
<ide> var i, m;
<ide> for (i = 2; i < 7; i++) {
<ide> m = moment().subtract({d: i});
<ide> test("calendar last week", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("calendar all else", function (assert) {
<add>test('calendar all else', function (assert) {
<ide> var weeksAgo = moment().subtract({w: 1}),
<ide> weeksFromNow = moment().add({w: 1});
<ide>
<ide> test("calendar all else", function (assert) {
<ide> assert.equal(weeksFromNow.calendar(), weeksFromNow.format('L'), 'in 2 weeks');
<ide> });
<ide>
<del>test("weeks year starting sunday", function (assert) {
<add>test('weeks year starting sunday', function (assert) {
<ide> assert.equal(moment([2012, 0, 1]).week(), 1, 'Jan 1 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 7]).week(), 1, 'Jan 7 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 8]).week(), 2, 'Jan 8 2012 should be week 2');
<ide> assert.equal(moment([2012, 0, 14]).week(), 2, 'Jan 14 2012 should be week 2');
<ide> assert.equal(moment([2012, 0, 15]).week(), 3, 'Jan 15 2012 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting monday", function (assert) {
<add>test('weeks year starting monday', function (assert) {
<ide> assert.equal(moment([2006, 11, 31]).week(), 1, 'Dec 31 2006 should be week 1');
<ide> assert.equal(moment([2007, 0, 1]).week(), 1, 'Jan 1 2007 should be week 1');
<ide> assert.equal(moment([2007, 0, 6]).week(), 1, 'Jan 6 2007 should be week 1');
<ide> test("weeks year starting monday", function (assert) {
<ide> assert.equal(moment([2007, 0, 14]).week(), 3, 'Jan 14 2007 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting tuesday", function (assert) {
<add>test('weeks year starting tuesday', function (assert) {
<ide> assert.equal(moment([2007, 11, 29]).week(), 52, 'Dec 29 2007 should be week 52');
<ide> assert.equal(moment([2008, 0, 1]).week(), 1, 'Jan 1 2008 should be week 1');
<ide> assert.equal(moment([2008, 0, 5]).week(), 1, 'Jan 5 2008 should be week 1');
<ide> test("weeks year starting tuesday", function (assert) {
<ide> assert.equal(moment([2008, 0, 13]).week(), 3, 'Jan 13 2008 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting wednesday", function (assert) {
<add>test('weeks year starting wednesday', function (assert) {
<ide> assert.equal(moment([2002, 11, 29]).week(), 1, 'Dec 29 2002 should be week 1');
<ide> assert.equal(moment([2003, 0, 1]).week(), 1, 'Jan 1 2003 should be week 1');
<ide> assert.equal(moment([2003, 0, 4]).week(), 1, 'Jan 4 2003 should be week 1');
<ide> test("weeks year starting wednesday", function (assert) {
<ide> assert.equal(moment([2003, 0, 12]).week(), 3, 'Jan 12 2003 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting thursday", function (assert) {
<add>test('weeks year starting thursday', function (assert) {
<ide> assert.equal(moment([2008, 11, 28]).week(), 1, 'Dec 28 2008 should be week 1');
<ide> assert.equal(moment([2009, 0, 1]).week(), 1, 'Jan 1 2009 should be week 1');
<ide> assert.equal(moment([2009, 0, 3]).week(), 1, 'Jan 3 2009 should be week 1');
<ide> test("weeks year starting thursday", function (assert) {
<ide> assert.equal(moment([2009, 0, 11]).week(), 3, 'Jan 11 2009 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting friday", function (assert) {
<add>test('weeks year starting friday', function (assert) {
<ide> assert.equal(moment([2009, 11, 27]).week(), 1, 'Dec 27 2009 should be week 1');
<ide> assert.equal(moment([2010, 0, 1]).week(), 1, 'Jan 1 2010 should be week 1');
<ide> assert.equal(moment([2010, 0, 2]).week(), 1, 'Jan 2 2010 should be week 1');
<ide> test("weeks year starting friday", function (assert) {
<ide> assert.equal(moment([2010, 0, 10]).week(), 3, 'Jan 10 2010 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting saturday", function (assert) {
<add>test('weeks year starting saturday', function (assert) {
<ide> assert.equal(moment([2010, 11, 26]).week(), 1, 'Dec 26 2010 should be week 1');
<ide> assert.equal(moment([2011, 0, 1]).week(), 1, 'Jan 1 2011 should be week 1');
<ide> assert.equal(moment([2011, 0, 2]).week(), 2, 'Jan 2 2011 should be week 2');
<ide> assert.equal(moment([2011, 0, 8]).week(), 2, 'Jan 8 2011 should be week 2');
<ide> assert.equal(moment([2011, 0, 9]).week(), 3, 'Jan 9 2011 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting sunday format", function (assert) {
<add>test('weeks year starting sunday format', function (assert) {
<ide> assert.equal(moment([2012, 0, 1]).format('w ww wo'), '1 01 1', 'Jan 1 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 7]).format('w ww wo'), '1 01 1', 'Jan 7 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 8]).format('w ww wo'), '2 02 2', 'Jan 8 2012 should be week 2');
<ide> assert.equal(moment([2012, 0, 14]).format('w ww wo'), '2 02 2', 'Jan 14 2012 should be week 2');
<ide> assert.equal(moment([2012, 0, 15]).format('w ww wo'), '3 03 3', 'Jan 15 2012 should be week 3');
<ide> });
<ide>
<del>test("lenient ordinal parsing", function (assert) {
<add>test('lenient ordinal parsing', function (assert) {
<ide> var i, ordinalStr, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> ordinalStr = moment([2014, 0, i]).format('YYYY MM Do');
<ide> test("lenient ordinal parsing", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("lenient ordinal parsing of number", function (assert) {
<add>test('lenient ordinal parsing of number', function (assert) {
<ide> var i, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> testMoment = moment('2014 01 ' + i, 'YYYY MM Do');
<ide> test("lenient ordinal parsing of number", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("strict ordinal parsing", function (assert) {
<add>test('strict ordinal parsing', function (assert) {
<ide> var i, ordinalStr, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> ordinalStr = moment([2014, 0, i]).format('YYYY MM Do');
<ide><path>src/test/locale/ka.js
<del>import {localeModule, test} from "../qunit";
<del>import {moment} from "../../moment";
<del>localeModule("ka");
<add>import {localeModule, test} from '../qunit';
<add>import {moment} from '../../moment';
<add>localeModule('ka');
<ide>
<del>test("parse", function (assert) {
<add>test('parse', function (assert) {
<ide> var i,
<ide> tests = 'იანვარი იან_თებერვალი თებ_მარტი მარ_აპრილი აპრ_მაისი მაი_ივნისი ივნ_ივლისი ივლ_აგვისტო აგვ_სექტემბერი სექ_ოქტომბერი ოქტ_ნოემბერი ნოე_დეკემბერი დეკ'.split('_');
<ide>
<ide> test("parse", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("format", function (assert) {
<add>test('format', function (assert) {
<ide> var a = [
<ide> ['dddd, MMMM Do YYYY, h:mm:ss a', 'კვირა, თებერვალი მე-14 2010, 3:25:50 pm'],
<ide> ['ddd, hA', 'კვი, 3PM'],
<ide> test("format", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("format ordinal", function (assert) {
<add>test('format ordinal', function (assert) {
<ide> assert.equal(moment([2011, 0, 1]).format('DDDo'), '1-ლი', '1-ლი');
<ide> assert.equal(moment([2011, 0, 2]).format('DDDo'), 'მე-2', 'მე-2');
<ide> assert.equal(moment([2011, 0, 3]).format('DDDo'), 'მე-3', 'მე-3');
<ide> test("format ordinal", function (assert) {
<ide> assert.equal(moment('2011 101', 'YYYY DDD').format('DDDo'), '101-ე', '101-ე');
<ide> });
<ide>
<del>test("format month", function (assert) {
<add>test('format month', function (assert) {
<ide> var i,
<ide> expected = 'იანვარი იან_თებერვალი თებ_მარტი მარ_აპრილი აპრ_მაისი მაი_ივნისი ივნ_ივლისი ივლ_აგვისტო აგვ_სექტემბერი სექ_ოქტომბერი ოქტ_ნოემბერი ნოე_დეკემბერი დეკ'.split('_');
<ide>
<ide> test("format month", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("format week", function (assert) {
<add>test('format week', function (assert) {
<ide> var i,
<ide> expected = 'კვირა კვი კვ_ორშაბათი ორშ ორ_სამშაბათი სამ სა_ოთხშაბათი ოთხ ოთ_ხუთშაბათი ხუთ ხუ_პარასკევი პარ პა_შაბათი შაბ შა'.split('_');
<ide>
<ide> test("format week", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("from", function (assert) {
<add>test('from', function (assert) {
<ide> var start = moment([2007, 1, 28]);
<ide>
<ide> assert.equal(start.from(moment([2007, 1, 28]).add({s: 44}), true), 'რამდენიმე წამი', '44 წამი = რამდენიმე წამი');
<ide> test("from", function (assert) {
<ide> assert.equal(start.from(moment([2007, 1, 28]).add({y: 5}), true), '5 წელი', '5 წელი = 5 წელი');
<ide> });
<ide>
<del>test("suffix", function (assert) {
<add>test('suffix', function (assert) {
<ide> assert.equal(moment(30000).from(0), 'რამდენიმე წამში', 'ში სუფიქსი');
<ide> assert.equal(moment(0).from(30000), 'რამდენიმე წამის წინ', 'წინ სუფიქსი');
<ide> });
<ide>
<del>test("now from now", function (assert) {
<add>test('now from now', function (assert) {
<ide> assert.equal(moment().fromNow(), 'რამდენიმე წამის წინ', 'უნდა აჩვენოს როგორც წარსული');
<ide> });
<ide>
<del>test("fromNow", function (assert) {
<add>test('fromNow', function (assert) {
<ide> assert.equal(moment().add({s: 30}).fromNow(), 'რამდენიმე წამში', 'რამდენიმე წამში');
<ide> assert.equal(moment().add({d: 5}).fromNow(), '5 დღეში', '5 დღეში');
<ide> });
<ide>
<del>test("calendar day", function (assert) {
<add>test('calendar day', function (assert) {
<ide> var a = moment().hours(2).minutes(0).seconds(0);
<ide>
<ide> assert.equal(moment(a).calendar(), 'დღეს 2:00 AM-ზე', 'დღეს ამავე დროს');
<ide> test("calendar day", function (assert) {
<ide> assert.equal(moment(a).subtract({d: 1}).calendar(), 'გუშინ 2:00 AM-ზე', 'გუშინ ამავე დროს');
<ide> });
<ide>
<del>test("calendar next week", function (assert) {
<add>test('calendar next week', function (assert) {
<ide> var i, m;
<ide> for (i = 2; i < 7; i++) {
<ide> m = moment().add({d: i});
<ide> test("calendar next week", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("calendar last week", function (assert) {
<add>test('calendar last week', function (assert) {
<ide> var i, m;
<ide> for (i = 2; i < 7; i++) {
<ide> m = moment().subtract({d: i});
<ide> test("calendar last week", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("calendar all else", function (assert) {
<add>test('calendar all else', function (assert) {
<ide> var weeksAgo = moment().subtract({w: 1}),
<ide> weeksFromNow = moment().add({w: 1});
<ide>
<ide> test("calendar all else", function (assert) {
<ide> assert.equal(weeksFromNow.calendar(), weeksFromNow.format('L'), '2 კვირაში');
<ide> });
<ide>
<del>test("weeks year starting sunday", function (assert) {
<add>test('weeks year starting sunday', function (assert) {
<ide> assert.equal(moment([2011, 11, 26]).week(), 1, 'დეკ 26 2011 უნდა იყოს კვირა 1');
<ide> assert.equal(moment([2012, 0, 1]).week(), 1, 'იან 1 2012 უნდა იყოს კვირა 1');
<ide> assert.equal(moment([2012, 0, 2]).week(), 2, 'იან 2 2012 უნდა იყოს კვირა 2');
<ide> assert.equal(moment([2012, 0, 8]).week(), 2, 'იან 8 2012 უნდა იყოს კვირა 2');
<ide> assert.equal(moment([2012, 0, 9]).week(), 3, 'იან 9 2012 უნდა იყოს კვირა 3');
<ide> });
<ide>
<del>test("weeks year starting monday", function (assert) {
<add>test('weeks year starting monday', function (assert) {
<ide> assert.equal(moment([2007, 0, 1]).week(), 1, 'იან 1 2007 უნდა იყოს კვირა 1');
<ide> assert.equal(moment([2007, 0, 7]).week(), 1, 'იან 7 2007 უნდა იყოს კვირა 1');
<ide> assert.equal(moment([2007, 0, 8]).week(), 2, 'იან 8 2007 უნდა იყოს კვირა 2');
<ide> assert.equal(moment([2007, 0, 14]).week(), 2, 'იან 14 2007 უნდა იყოს კვირა 2');
<ide> assert.equal(moment([2007, 0, 15]).week(), 3, 'იან 15 2007 უნდა იყოს კვირა 3');
<ide> });
<ide>
<del>test("weeks year starting tuesday", function (assert) {
<add>test('weeks year starting tuesday', function (assert) {
<ide> assert.equal(moment([2007, 11, 31]).week(), 1, 'დეკ 31 2007 უნდა იყოს კვირა 1');
<ide> assert.equal(moment([2008, 0, 1]).week(), 1, 'იან 1 2008 უნდა იყოს კვირა 1');
<ide> assert.equal(moment([2008, 0, 6]).week(), 1, 'იან 6 2008 უნდა იყოს კვირა 1');
<ide> test("weeks year starting tuesday", function (assert) {
<ide> assert.equal(moment([2008, 0, 14]).week(), 3, 'იან 14 2008 უნდა იყოს კვირა 3');
<ide> });
<ide>
<del>test("weeks year starting wednesday", function (assert) {
<add>test('weeks year starting wednesday', function (assert) {
<ide> assert.equal(moment([2002, 11, 30]).week(), 1, 'დეკ 30 2002 უნდა იყოს კვირა 1');
<ide> assert.equal(moment([2003, 0, 1]).week(), 1, 'იან 1 2003 უნდა იყოს კვირა 1');
<ide> assert.equal(moment([2003, 0, 5]).week(), 1, 'იან 5 2003 უნდა იყოს კვირა 1');
<ide> test("weeks year starting wednesday", function (assert) {
<ide> assert.equal(moment([2003, 0, 13]).week(), 3, 'იან 13 2003 უნდა იყოს კვირა 3');
<ide> });
<ide>
<del>test("weeks year starting thursday", function (assert) {
<add>test('weeks year starting thursday', function (assert) {
<ide> assert.equal(moment([2008, 11, 29]).week(), 1, 'დეკ 29 2008 უნდა იყოს კვირა 1');
<ide> assert.equal(moment([2009, 0, 1]).week(), 1, 'იან 1 2009 უნდა იყოს კვირა 1');
<ide> assert.equal(moment([2009, 0, 4]).week(), 1, 'იან 4 2009 უნდა იყოს კვირა 1');
<ide> test("weeks year starting thursday", function (assert) {
<ide> assert.equal(moment([2009, 0, 12]).week(), 3, 'იან 12 2009 უნდა იყოს კვირა 3');
<ide> });
<ide>
<del>test("weeks year starting friday", function (assert) {
<add>test('weeks year starting friday', function (assert) {
<ide> assert.equal(moment([2009, 11, 28]).week(), 1, 'დეკ 28 2009 უნდა იყოს კვირა 1');
<ide> assert.equal(moment([2010, 0, 1]).week(), 1, 'იან 1 2010 უნდა იყოს კვირა 1');
<ide> assert.equal(moment([2010, 0, 3]).week(), 1, 'იან 3 2010 უნდა იყოს კვირა 1');
<ide> test("weeks year starting friday", function (assert) {
<ide> assert.equal(moment([2010, 0, 11]).week(), 3, 'იან 11 2010 უნდა იყოს კვირა 3');
<ide> });
<ide>
<del>test("weeks year starting saturday", function (assert) {
<add>test('weeks year starting saturday', function (assert) {
<ide> assert.equal(moment([2010, 11, 27]).week(), 1, 'დეკ 27 2010 უნდა იყოს კვირა 1');
<ide> assert.equal(moment([2011, 0, 1]).week(), 1, 'იან 1 2011 უნდა იყოს კვირა 1');
<ide> assert.equal(moment([2011, 0, 2]).week(), 1, 'იან 2 2011 უნდა იყოს კვირა 1');
<ide> test("weeks year starting saturday", function (assert) {
<ide> assert.equal(moment([2011, 0, 10]).week(), 3, 'იან 10 2011 უნდა იყოს კვირა 3');
<ide> });
<ide>
<del>test("weeks year starting sunday formatted", function (assert) {
<add>test('weeks year starting sunday formatted', function (assert) {
<ide> assert.equal(moment([2011, 11, 26]).format('w ww wo'), '1 01 1-ლი', 'დეკ 26 2011 უნდა იყოს კვირა 1');
<ide> assert.equal(moment([2012, 0, 1]).format('w ww wo'), '1 01 1-ლი', 'იან 1 2012 უნდა იყოს კვირა 1');
<ide> assert.equal(moment([2012, 0, 2]).format('w ww wo'), '2 02 მე-2', 'იან 2 2012 უნდა იყოს კვირა 2');
<ide> assert.equal(moment([2012, 0, 8]).format('w ww wo'), '2 02 მე-2', 'იან 8 2012 უნდა იყოს კვირა 2');
<ide> assert.equal(moment([2012, 0, 9]).format('w ww wo'), '3 03 მე-3', 'იან 9 2012 უნდა იყოს კვირა 3');
<ide> });
<ide>
<del>test("lenient ordinal parsing", function (assert) {
<add>test('lenient ordinal parsing', function (assert) {
<ide> var i, ordinalStr, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> ordinalStr = moment([2014, 0, i]).format('YYYY MM Do');
<ide> test("lenient ordinal parsing", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("lenient ordinal parsing of number", function (assert) {
<add>test('lenient ordinal parsing of number', function (assert) {
<ide> var i, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> testMoment = moment('2014 01 ' + i, 'YYYY MM Do');
<ide> test("lenient ordinal parsing of number", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("strict ordinal parsing", function (assert) {
<add>test('strict ordinal parsing', function (assert) {
<ide> var i, ordinalStr, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> ordinalStr = moment([2014, 0, i]).format('YYYY MM Do');
<ide><path>src/test/locale/km.js
<del>import {localeModule, test} from "../qunit";
<del>import {moment} from "../../moment";
<del>localeModule("km");
<add>import {localeModule, test} from '../qunit';
<add>import {moment} from '../../moment';
<add>localeModule('km');
<ide>
<del>test("parse", function (assert) {
<add>test('parse', function (assert) {
<ide> var tests = 'មករា មករា_កុម្ភៈ កុម្ភៈ_មិនា មិនា_មេសា មេសា_ឧសភា ឧសភា_មិថុនា មិថុនា_កក្កដា កក្កដា_សីហា សីហា_កញ្ញា កញ្ញា_តុលា តុលា_វិច្ឆិកា វិច្ឆិកា_ធ្នូ ធ្នូ'.split('_'),
<ide> i;
<ide>
<ide> test("parse", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("format", function (assert) {
<add>test('format', function (assert) {
<ide> var a = [
<ide> ['dddd, MMMM Do YYYY, h:mm:ss a', 'អាទិត្យ, កុម្ភៈ 14 2010, 3:25:50 pm'],
<ide> ['ddd, hA', 'អាទិត្យ, 3PM'],
<ide> test("format", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("format ordinal", function (assert) {
<add>test('format ordinal', function (assert) {
<ide> assert.equal(moment([2011, 0, 1]).format('DDDo'), '1', '1st');
<ide> assert.equal(moment([2011, 0, 2]).format('DDDo'), '2', '2nd');
<ide> assert.equal(moment([2011, 0, 3]).format('DDDo'), '3', '3rd');
<ide> test("format ordinal", function (assert) {
<ide> assert.equal(moment([2011, 0, 31]).format('DDDo'), '31', '31st');
<ide> });
<ide>
<del>test("format month", function (assert) {
<add>test('format month', function (assert) {
<ide> var expected = 'មករា មករា_កុម្ភៈ កុម្ភៈ_មិនា មិនា_មេសា មេសា_ឧសភា ឧសភា_មិថុនា មិថុនា_កក្កដា កក្កដា_សីហា សីហា_កញ្ញា កញ្ញា_តុលា តុលា_វិច្ឆិកា វិច្ឆិកា_ធ្នូ ធ្នូ'.split('_'),
<ide> i;
<ide> for (i = 0; i < expected.length; i++) {
<ide> assert.equal(moment([2011, i, 1]).format('MMMM MMM'), expected[i], expected[i]);
<ide> }
<ide> });
<ide>
<del>test("format week", function (assert) {
<add>test('format week', function (assert) {
<ide> var expected = 'អាទិត្យ អាទិត្យ អាទិត្យ_ច័ន្ទ ច័ន្ទ ច័ន្ទ_អង្គារ អង្គារ អង្គារ_ពុធ ពុធ ពុធ_ព្រហស្បតិ៍ ព្រហស្បតិ៍ ព្រហស្បតិ៍_សុក្រ សុក្រ សុក្រ_សៅរ៍ សៅរ៍ សៅរ៍'.split('_'),
<ide> i;
<ide> for (i = 0; i < expected.length; i++) {
<ide> assert.equal(moment([2011, 0, 2 + i]).format('dddd ddd dd'), expected[i], expected[i]);
<ide> }
<ide> });
<ide>
<del>test("from", function (assert) {
<add>test('from', function (assert) {
<ide> var start = moment([2007, 1, 28]);
<ide> assert.equal(start.from(moment([2007, 1, 28]).add({s: 44}), true), 'ប៉ុន្មានវិនាទី', '44 seconds = ប៉ុន្មានវិនាទី');
<ide> assert.equal(start.from(moment([2007, 1, 28]).add({s: 45}), true), 'មួយនាទី', '45 seconds = មួយនាទី');
<ide> test("from", function (assert) {
<ide> assert.equal(start.from(moment([2007, 1, 28]).add({y: 5}), true), '5 ឆ្នាំ', '5 years = 5 ឆ្នាំ');
<ide> });
<ide>
<del>test("suffix", function (assert) {
<add>test('suffix', function (assert) {
<ide> assert.equal(moment(30000).from(0), 'ប៉ុន្មានវិនាទីទៀត', 'prefix');
<ide> assert.equal(moment(0).from(30000), 'ប៉ុន្មានវិនាទីមុន', 'suffix');
<ide> });
<ide>
<del>test("now from now", function (assert) {
<add>test('now from now', function (assert) {
<ide> assert.equal(moment().fromNow(), 'ប៉ុន្មានវិនាទីមុន', 'now from now should display as in the past');
<ide> });
<ide>
<del>test("fromNow", function (assert) {
<add>test('fromNow', function (assert) {
<ide> assert.equal(moment().add({
<ide> s: 30
<ide> }).fromNow(), 'ប៉ុន្មានវិនាទីទៀត', 'in a few seconds');
<ide> test("fromNow", function (assert) {
<ide> }).fromNow(), '5 ថ្ងៃទៀត', 'in 5 days');
<ide> });
<ide>
<del>test("calendar day", function (assert) {
<add>test('calendar day', function (assert) {
<ide> var a = moment().hours(2).minutes(0).seconds(0);
<ide>
<ide> assert.equal(moment(a).calendar(), 'ថ្ងៃនៈ ម៉ោង 02:00', 'today at the same time');
<ide> test("calendar day", function (assert) {
<ide> }).calendar(), 'ម្សិលមិញ ម៉ោង 02:00', 'yesterday at the same time');
<ide> });
<ide>
<del>test("calendar next week", function (assert) {
<add>test('calendar next week', function (assert) {
<ide> var i, m;
<ide> for (i = 2; i < 7; i++) {
<ide> m = moment().add({
<ide> test("calendar next week", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("calendar last week", function (assert) {
<add>test('calendar last week', function (assert) {
<ide> var i, m;
<ide>
<ide> for (i = 2; i < 7; i++) {
<ide> test("calendar last week", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("calendar all else", function (assert) {
<add>test('calendar all else', function (assert) {
<ide> var weeksAgo = moment().subtract({
<ide> w: 1
<ide> }),
<ide> test("calendar all else", function (assert) {
<ide> assert.equal(weeksFromNow.calendar(), weeksFromNow.format('L'), 'in 2 weeks');
<ide> });
<ide>
<del>test("weeks year starting sunday", function (assert) {
<add>test('weeks year starting sunday', function (assert) {
<ide> assert.equal(moment([2012, 0, 1]).week(), 52, 'Jan 1 2012 should be week 52');
<ide> assert.equal(moment([2012, 0, 2]).week(), 1, 'Jan 2 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 8]).week(), 1, 'Jan 8 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 9]).week(), 2, 'Jan 9 2012 should be week 2');
<ide> assert.equal(moment([2012, 0, 15]).week(), 2, 'Jan 15 2012 should be week 2');
<ide> });
<ide>
<del>test("weeks year starting monday", function (assert) {
<add>test('weeks year starting monday', function (assert) {
<ide> assert.equal(moment([2007, 0, 1]).week(), 1, 'Jan 1 2007 should be week 1');
<ide> assert.equal(moment([2007, 0, 7]).week(), 1, 'Jan 7 2007 should be week 1');
<ide> assert.equal(moment([2007, 0, 8]).week(), 2, 'Jan 8 2007 should be week 2');
<ide> assert.equal(moment([2007, 0, 14]).week(), 2, 'Jan 14 2007 should be week 2');
<ide> assert.equal(moment([2007, 0, 15]).week(), 3, 'Jan 15 2007 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting tuesday", function (assert) {
<add>test('weeks year starting tuesday', function (assert) {
<ide> assert.equal(moment([2007, 11, 31]).week(), 1, 'Dec 31 2007 should be week 1');
<ide> assert.equal(moment([2008, 0, 1]).week(), 1, 'Jan 1 2008 should be week 1');
<ide> assert.equal(moment([2008, 0, 6]).week(), 1, 'Jan 6 2008 should be week 1');
<ide> test("weeks year starting tuesday", function (assert) {
<ide> assert.equal(moment([2008, 0, 14]).week(), 3, 'Jan 14 2008 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting wednesday", function (assert) {
<add>test('weeks year starting wednesday', function (assert) {
<ide> assert.equal(moment([2002, 11, 30]).week(), 1, 'Dec 30 2002 should be week 1');
<ide> assert.equal(moment([2003, 0, 1]).week(), 1, 'Jan 1 2003 should be week 1');
<ide> assert.equal(moment([2003, 0, 5]).week(), 1, 'Jan 5 2003 should be week 1');
<ide> test("weeks year starting wednesday", function (assert) {
<ide> assert.equal(moment([2003, 0, 13]).week(), 3, 'Jan 13 2003 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting thursday", function (assert) {
<add>test('weeks year starting thursday', function (assert) {
<ide> assert.equal(moment([2008, 11, 29]).week(), 1, 'Dec 29 2008 should be week 1');
<ide> assert.equal(moment([2009, 0, 1]).week(), 1, 'Jan 1 2009 should be week 1');
<ide> assert.equal(moment([2009, 0, 4]).week(), 1, 'Jan 4 2009 should be week 1');
<ide> test("weeks year starting thursday", function (assert) {
<ide> assert.equal(moment([2009, 0, 13]).week(), 3, 'Jan 12 2009 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting friday", function (assert) {
<add>test('weeks year starting friday', function (assert) {
<ide> assert.equal(moment([2009, 11, 28]).week(), 53, 'Dec 28 2009 should be week 53');
<ide> assert.equal(moment([2010, 0, 1]).week(), 53, 'Jan 1 2010 should be week 53');
<ide> assert.equal(moment([2010, 0, 3]).week(), 53, 'Jan 3 2010 should be week 53');
<ide> test("weeks year starting friday", function (assert) {
<ide> assert.equal(moment([2010, 0, 11]).week(), 2, 'Jan 11 2010 should be week 2');
<ide> });
<ide>
<del>test("weeks year starting saturday", function (assert) {
<add>test('weeks year starting saturday', function (assert) {
<ide> assert.equal(moment([2010, 11, 27]).week(), 52, 'Dec 27 2010 should be week 52');
<ide> assert.equal(moment([2011, 0, 1]).week(), 52, 'Jan 1 2011 should be week 52');
<ide> assert.equal(moment([2011, 0, 2]).week(), 52, 'Jan 2 2011 should be week 52');
<ide> test("weeks year starting saturday", function (assert) {
<ide> assert.equal(moment([2011, 0, 10]).week(), 2, 'Jan 10 2011 should be week 2');
<ide> });
<ide>
<del>test("weeks year starting sunday formatted", function (assert) {
<add>test('weeks year starting sunday formatted', function (assert) {
<ide> assert.equal(moment([2012, 0, 1]).format('w ww wo'), '52 52 52', 'Jan 1 2012 should be week 52');
<ide> assert.equal(moment([2012, 0, 2]).format('w ww wo'), '1 01 1', 'Jan 2 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 8]).format('w ww wo'), '1 01 1', 'Jan 8 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 9]).format('w ww wo'), '2 02 2', 'Jan 9 2012 should be week 2');
<ide> assert.equal(moment([2012, 0, 15]).format('w ww wo'), '2 02 2', 'Jan 15 2012 should be week 2');
<ide> });
<ide>
<del>test("lenient ordinal parsing", function (assert) {
<add>test('lenient ordinal parsing', function (assert) {
<ide> var i, ordinalStr, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> ordinalStr = moment([2014, 0, i]).format('YYYY MM Do');
<ide> test("lenient ordinal parsing", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("lenient ordinal parsing of number", function (assert) {
<add>test('lenient ordinal parsing of number', function (assert) {
<ide> var i, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> testMoment = moment('2014 01 ' + i, 'YYYY MM Do');
<ide> test("lenient ordinal parsing of number", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("strict ordinal parsing", function (assert) {
<add>test('strict ordinal parsing', function (assert) {
<ide> var i, ordinalStr, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> ordinalStr = moment([2014, 0, i]).format('YYYY MM Do');
<ide><path>src/test/locale/ko.js
<del>import {localeModule, test} from "../qunit";
<del>import {moment} from "../../moment";
<del>localeModule("ko");
<add>import {localeModule, test} from '../qunit';
<add>import {moment} from '../../moment';
<add>localeModule('ko');
<ide>
<del>test("parse", function (assert) {
<add>test('parse', function (assert) {
<ide> var tests = '1월 1월_2월 2월_3월 3월_4월 4월_5월 5월_6월 6월_7월 7월_8월 8월_9월 9월_10월 10월_11월 11월_12월 12월'.split('_'), i;
<ide> function equalTest(input, mmm, i) {
<ide> assert.equal(moment(input, mmm).month(), i, input + ' should be month ' + (i + 1));
<ide> test("parse", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("parse meridiem", function (assert) {
<add>test('parse meridiem', function (assert) {
<ide> var elements = [{
<ide> expression : '1981년 9월 8일 오후 2시 30분',
<ide> inputFormat : 'YYYY[년] M[월] D[일] A h[시] m[분]',
<ide> test("parse meridiem", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("format", function (assert) {
<add>test('format', function (assert) {
<ide> var a = [
<ide> ['YYYY년 MMMM Do dddd a h:mm:ss', '2010년 2월 14일 일요일 오후 3:25:50'],
<ide> ['ddd A h', '일 오후 3'],
<ide> test("format", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("format ordinal", function (assert) {
<add>test('format ordinal', function (assert) {
<ide> assert.equal(moment([2011, 0, 1]).format('DDDo'), '1일', '1일');
<ide> assert.equal(moment([2011, 0, 2]).format('DDDo'), '2일', '2일');
<ide> assert.equal(moment([2011, 0, 3]).format('DDDo'), '3일', '3일');
<ide> test("format ordinal", function (assert) {
<ide> assert.equal(moment([2011, 0, 31]).format('DDDo'), '31일', '31일');
<ide> });
<ide>
<del>test("format month", function (assert) {
<add>test('format month', function (assert) {
<ide> var expected = '1월 1월_2월 2월_3월 3월_4월 4월_5월 5월_6월 6월_7월 7월_8월 8월_9월 9월_10월 10월_11월 11월_12월 12월'.split('_'), i;
<ide> for (i = 0; i < expected.length; i++) {
<ide> assert.equal(moment([2011, i, 1]).format('MMMM MMM'), expected[i], expected[i]);
<ide> }
<ide> });
<ide>
<del>test("format week", function (assert) {
<add>test('format week', function (assert) {
<ide> var expected = '일요일 일 일_월요일 월 월_화요일 화 화_수요일 수 수_목요일 목 목_금요일 금 금_토요일 토 토'.split('_'), i;
<ide> for (i = 0; i < expected.length; i++) {
<ide> assert.equal(moment([2011, 0, 2 + i]).format('dddd ddd dd'), expected[i], expected[i]);
<ide> }
<ide> });
<ide>
<del>test("from", function (assert) {
<add>test('from', function (assert) {
<ide> var start = moment([2007, 1, 28]);
<ide> assert.equal(start.from(moment([2007, 1, 28]).add({s: 44}), true), '몇초', '44초 = 몇초');
<ide> assert.equal(start.from(moment([2007, 1, 28]).add({s: 45}), true), '일분', '45초 = 일분');
<ide> test("from", function (assert) {
<ide> assert.equal(start.from(moment([2007, 1, 28]).add({y: 5}), true), '5년', '5년 = 5년');
<ide> });
<ide>
<del>test("suffix", function (assert) {
<add>test('suffix', function (assert) {
<ide> assert.equal(moment(30000).from(0), '몇초 후', 'prefix');
<ide> assert.equal(moment(0).from(30000), '몇초 전', 'suffix');
<ide> });
<ide>
<del>test("now from now", function (assert) {
<add>test('now from now', function (assert) {
<ide> assert.equal(moment().fromNow(), '몇초 전', 'now from now should display as in the past');
<ide> });
<ide>
<del>test("fromNow", function (assert) {
<add>test('fromNow', function (assert) {
<ide> assert.equal(moment().add({s: 30}).fromNow(), '몇초 후', 'in a few seconds');
<ide> assert.equal(moment().add({d: 5}).fromNow(), '5일 후', 'in 5 days');
<ide> });
<ide>
<del>test("calendar day", function (assert) {
<add>test('calendar day', function (assert) {
<ide> var a = moment().hours(2).minutes(0).seconds(0);
<ide>
<ide> assert.equal(moment(a).calendar(), '오늘 오전 2시 0분', 'today at the same time');
<ide> test("calendar day", function (assert) {
<ide> assert.equal(moment(a).subtract({d: 1}).calendar(), '어제 오전 2시 0분', 'yesterday at the same time');
<ide> });
<ide>
<del>test("calendar next week", function (assert) {
<add>test('calendar next week', function (assert) {
<ide> var i, m;
<ide> for (i = 2; i < 7; i++) {
<ide> m = moment().add({d: i});
<ide> test("calendar next week", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("calendar last week", function (assert) {
<add>test('calendar last week', function (assert) {
<ide> var i, m;
<ide> for (i = 2; i < 7; i++) {
<ide> m = moment().subtract({d: i});
<ide> test("calendar last week", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("calendar all else", function (assert) {
<add>test('calendar all else', function (assert) {
<ide> var weeksAgo = moment().subtract({w: 1}),
<ide> weeksFromNow = moment().add({w: 1});
<ide>
<ide> test("calendar all else", function (assert) {
<ide> assert.equal(weeksFromNow.calendar(), weeksFromNow.format('L'), 'in 2 weeks');
<ide> });
<ide>
<del>test("weeks year starting sunday", function (assert) {
<add>test('weeks year starting sunday', function (assert) {
<ide> assert.equal(moment([2012, 0, 1]).week(), 1, 'Jan 1 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 7]).week(), 1, 'Jan 7 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 8]).week(), 2, 'Jan 8 2012 should be week 2');
<ide> assert.equal(moment([2012, 0, 14]).week(), 2, 'Jan 14 2012 should be week 2');
<ide> assert.equal(moment([2012, 0, 15]).week(), 3, 'Jan 15 2012 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting monday", function (assert) {
<add>test('weeks year starting monday', function (assert) {
<ide> assert.equal(moment([2006, 11, 31]).week(), 1, 'Dec 31 2006 should be week 1');
<ide> assert.equal(moment([2007, 0, 1]).week(), 1, 'Jan 1 2007 should be week 1');
<ide> assert.equal(moment([2007, 0, 6]).week(), 1, 'Jan 6 2007 should be week 1');
<ide> test("weeks year starting monday", function (assert) {
<ide> assert.equal(moment([2007, 0, 14]).week(), 3, 'Jan 14 2007 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting tuesday", function (assert) {
<add>test('weeks year starting tuesday', function (assert) {
<ide> assert.equal(moment([2007, 11, 29]).week(), 52, 'Dec 29 2007 should be week 52');
<ide> assert.equal(moment([2008, 0, 1]).week(), 1, 'Jan 1 2008 should be week 1');
<ide> assert.equal(moment([2008, 0, 5]).week(), 1, 'Jan 5 2008 should be week 1');
<ide> test("weeks year starting tuesday", function (assert) {
<ide> assert.equal(moment([2008, 0, 13]).week(), 3, 'Jan 13 2008 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting wednesday", function (assert) {
<add>test('weeks year starting wednesday', function (assert) {
<ide> assert.equal(moment([2002, 11, 29]).week(), 1, 'Dec 29 2002 should be week 1');
<ide> assert.equal(moment([2003, 0, 1]).week(), 1, 'Jan 1 2003 should be week 1');
<ide> assert.equal(moment([2003, 0, 4]).week(), 1, 'Jan 4 2003 should be week 1');
<ide> test("weeks year starting wednesday", function (assert) {
<ide> assert.equal(moment([2003, 0, 12]).week(), 3, 'Jan 12 2003 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting thursday", function (assert) {
<add>test('weeks year starting thursday', function (assert) {
<ide> assert.equal(moment([2008, 11, 28]).week(), 1, 'Dec 28 2008 should be week 1');
<ide> assert.equal(moment([2009, 0, 1]).week(), 1, 'Jan 1 2009 should be week 1');
<ide> assert.equal(moment([2009, 0, 3]).week(), 1, 'Jan 3 2009 should be week 1');
<ide> test("weeks year starting thursday", function (assert) {
<ide> assert.equal(moment([2009, 0, 11]).week(), 3, 'Jan 11 2009 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting friday", function (assert) {
<add>test('weeks year starting friday', function (assert) {
<ide> assert.equal(moment([2009, 11, 27]).week(), 1, 'Dec 27 2009 should be week 1');
<ide> assert.equal(moment([2010, 0, 1]).week(), 1, 'Jan 1 2010 should be week 1');
<ide> assert.equal(moment([2010, 0, 2]).week(), 1, 'Jan 2 2010 should be week 1');
<ide> test("weeks year starting friday", function (assert) {
<ide> assert.equal(moment([2010, 0, 10]).week(), 3, 'Jan 10 2010 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting saturday", function (assert) {
<add>test('weeks year starting saturday', function (assert) {
<ide> assert.equal(moment([2010, 11, 26]).week(), 1, 'Dec 26 2010 should be week 1');
<ide> assert.equal(moment([2011, 0, 1]).week(), 1, 'Jan 1 2011 should be week 1');
<ide> assert.equal(moment([2011, 0, 2]).week(), 2, 'Jan 2 2011 should be week 2');
<ide> assert.equal(moment([2011, 0, 8]).week(), 2, 'Jan 8 2011 should be week 2');
<ide> assert.equal(moment([2011, 0, 9]).week(), 3, 'Jan 9 2011 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting sunday format", function (assert) {
<add>test('weeks year starting sunday format', function (assert) {
<ide> assert.equal(moment([2012, 0, 1]).format('w ww wo'), '1 01 1일', 'Jan 1 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 7]).format('w ww wo'), '1 01 1일', 'Jan 7 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 8]).format('w ww wo'), '2 02 2일', 'Jan 8 2012 should be week 2');
<ide> assert.equal(moment([2012, 0, 14]).format('w ww wo'), '2 02 2일', 'Jan 14 2012 should be week 2');
<ide> assert.equal(moment([2012, 0, 15]).format('w ww wo'), '3 03 3일', 'Jan 15 2012 should be week 3');
<ide> });
<ide>
<del>test("lenient ordinal parsing", function (assert) {
<add>test('lenient ordinal parsing', function (assert) {
<ide> var i, ordinalStr, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> ordinalStr = moment([2014, 0, i]).format('YYYY MM Do');
<ide> test("lenient ordinal parsing", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("lenient ordinal parsing of number", function (assert) {
<add>test('lenient ordinal parsing of number', function (assert) {
<ide> var i, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> testMoment = moment('2014 01 ' + i, 'YYYY MM Do');
<ide> test("lenient ordinal parsing of number", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("strict ordinal parsing", function (assert) {
<add>test('strict ordinal parsing', function (assert) {
<ide> var i, ordinalStr, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> ordinalStr = moment([2014, 0, i]).format('YYYY MM Do');
<ide><path>src/test/locale/lb.js
<del>import {localeModule, test} from "../qunit";
<del>import {moment} from "../../moment";
<del>localeModule("lb");
<add>import {localeModule, test} from '../qunit';
<add>import {moment} from '../../moment';
<add>localeModule('lb');
<ide>
<del>test("parse", function (assert) {
<add>test('parse', function (assert) {
<ide> var tests = 'Januar Jan._Februar Febr._Mäerz Mrz._Abrëll Abr._Mee Mee_Juni Jun._Juli Jul._August Aug._September Sept._Oktober Okt._November Nov._Dezember Dez.'.split('_'), i;
<ide>
<ide> function equalTest(input, mmm, i) {
<ide> test("parse", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("format", function (assert) {
<add>test('format', function (assert) {
<ide> var a = [
<ide> ['dddd, Do MMMM YYYY, HH:mm:ss', 'Sonndeg, 14. Februar 2010, 15:25:50'],
<ide> ['ddd, HH:mm', 'So., 15:25'],
<ide> test("format", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("format month", function (assert) {
<add>test('format month', function (assert) {
<ide> var expected = 'Januar Jan._Februar Febr._Mäerz Mrz._Abrëll Abr._Mee Mee_Juni Jun._Juli Jul._August Aug._September Sept._Oktober Okt._November Nov._Dezember Dez.'.split('_'), i;
<ide> for (i = 0; i < expected.length; i++) {
<ide> assert.equal(moment([2011, i, 1]).format('MMMM MMM'), expected[i], expected[i]);
<ide> }
<ide> });
<ide>
<del>test("format week", function (assert) {
<add>test('format week', function (assert) {
<ide> var expected = 'Sonndeg So. So_Méindeg Mé. Mé_Dënschdeg Dë. Dë_Mëttwoch Më. Më_Donneschdeg Do. Do_Freideg Fr. Fr_Samschdeg Sa. Sa'.split('_'), i;
<ide> for (i = 0; i < expected.length; i++) {
<ide> assert.equal(moment([2011, 0, 2 + i]).format('dddd ddd dd'), expected[i], expected[i]);
<ide> }
<ide> });
<ide>
<del>test("from", function (assert) {
<add>test('from', function (assert) {
<ide> var start = moment([2007, 1, 28]);
<ide> assert.equal(start.from(moment([2007, 1, 28]).add({s: 44}), true), 'e puer Sekonnen', '44 seconds = a few seconds');
<ide> assert.equal(start.from(moment([2007, 1, 28]).add({s: 45}), true), 'eng Minutt', '45 seconds = a minute');
<ide> test("from", function (assert) {
<ide> assert.equal(start.from(moment([2007, 1, 28]).add({y: 5}), true), '5 Joer', '5 years = 5 years');
<ide> });
<ide>
<del>test("suffix", function (assert) {
<add>test('suffix', function (assert) {
<ide> assert.equal(moment(30000).from(0), 'an e puer Sekonnen', 'prefix');
<ide> assert.equal(moment(0).from(30000), 'virun e puer Sekonnen', 'suffix');
<ide> });
<ide>
<del>test("fromNow", function (assert) {
<add>test('fromNow', function (assert) {
<ide> assert.equal(moment().add({s: 30}).fromNow(), 'an e puer Sekonnen', 'in a few seconds');
<ide> assert.equal(moment().add({d: 1}).fromNow(), 'an engem Dag', 'in one day');
<ide> assert.equal(moment().add({d: 2}).fromNow(), 'an 2 Deeg', 'in 2 days');
<ide> test("fromNow", function (assert) {
<ide> assert.equal(moment().add({y: 400}).fromNow(), 'a 400 Joer', 'in 400 years');
<ide> });
<ide>
<del>test("calendar last week", function (assert) {
<add>test('calendar last week', function (assert) {
<ide> var i, m, weekday, datestring;
<ide> for (i = 2; i < 7; i++) {
<ide> m = moment().subtract({d: i});
<ide> test("calendar last week", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("lenient ordinal parsing", function (assert) {
<add>test('lenient ordinal parsing', function (assert) {
<ide> var i, ordinalStr, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> ordinalStr = moment([2014, 0, i]).format('YYYY MM Do');
<ide> test("lenient ordinal parsing", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("lenient ordinal parsing of number", function (assert) {
<add>test('lenient ordinal parsing of number', function (assert) {
<ide> var i, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> testMoment = moment('2014 01 ' + i, 'YYYY MM Do');
<ide> test("lenient ordinal parsing of number", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("strict ordinal parsing", function (assert) {
<add>test('strict ordinal parsing', function (assert) {
<ide> var i, ordinalStr, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> ordinalStr = moment([2014, 0, i]).format('YYYY MM Do');
<ide><path>src/test/locale/lt.js
<del>import {localeModule, test} from "../qunit";
<del>import {moment} from "../../moment";
<del>localeModule("lt");
<add>import {localeModule, test} from '../qunit';
<add>import {moment} from '../../moment';
<add>localeModule('lt');
<ide>
<del>test("parse", function (assert) {
<add>test('parse', function (assert) {
<ide> var tests = 'sausio sau_vasario vas_kovo kov_balandžio bal_gegužės geg_birželio bir_liepos lie_rugpjūčio rgp_rugsėjo rgs_spalio spa_lapkričio lap_gruodžio grd'.split('_'), i;
<ide> function equalTest(input, mmm, i) {
<ide> assert.equal(moment(input, mmm).month(), i, input + ' should be month ' + (i + 1));
<ide> test("parse", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("format", function (assert) {
<add>test('format', function (assert) {
<ide> var a = [
<ide> ['dddd, Do MMMM YYYY, h:mm:ss a', 'sekmadienis, 14-oji vasario 2010, 3:25:50 pm'],
<ide> ['ddd, hA', 'Sek, 3PM'],
<ide> test("format", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("format ordinal", function (assert) {
<add>test('format ordinal', function (assert) {
<ide> assert.equal(moment([2011, 0, 1]).format('DDDo'), '1-oji', '1-oji');
<ide> assert.equal(moment([2011, 0, 2]).format('DDDo'), '2-oji', '2-oji');
<ide> assert.equal(moment([2011, 0, 3]).format('DDDo'), '3-oji', '3-oji');
<ide> test("format ordinal", function (assert) {
<ide> assert.equal(moment([2011, 0, 31]).format('DDDo'), '31-oji', '31-oji');
<ide> });
<ide>
<del>test("format month", function (assert) {
<add>test('format month', function (assert) {
<ide> var expected = 'sausio sau_vasario vas_kovo kov_balandžio bal_gegužės geg_birželio bir_liepos lie_rugpjūčio rgp_rugsėjo rgs_spalio spa_lapkričio lap_gruodžio grd'.split('_'), i;
<ide> for (i = 0; i < expected.length; i++) {
<ide> assert.equal(moment([2011, i, 1]).format('MMMM MMM'), expected[i], expected[i]);
<ide> }
<ide> });
<ide>
<del>test("format week", function (assert) {
<add>test('format week', function (assert) {
<ide> var expected = 'sekmadienis Sek S_pirmadienis Pir P_antradienis Ant A_trečiadienis Tre T_ketvirtadienis Ket K_penktadienis Pen Pn_šeštadienis Šeš Š'.split('_'), i;
<ide> for (i = 0; i < expected.length; i++) {
<ide> assert.equal(moment([2011, 0, 2 + i]).format('dddd ddd dd'), expected[i], expected[i]);
<ide> }
<ide> });
<ide>
<del>test("format week on US calendar", function (assert) {
<add>test('format week on US calendar', function (assert) {
<ide> // Tests, whether the weekday names are correct, even if the week does not start on Monday
<ide> moment.locale('lt', {week: {dow: 0, doy: 6}});
<ide> var expected = 'sekmadienis Sek S_pirmadienis Pir P_antradienis Ant A_trečiadienis Tre T_ketvirtadienis Ket K_penktadienis Pen Pn_šeštadienis Šeš Š'.split('_'), i;
<ide> test("format week on US calendar", function (assert) {
<ide> moment.locale('lt', {week: {dow: 1, doy: 4}});
<ide> });
<ide>
<del>test("from", function (assert) {
<add>test('from', function (assert) {
<ide> var start = moment([2007, 1, 28]);
<ide> assert.equal(start.from(moment([2007, 1, 28]).add({s: 44}), true), 'kelios sekundės', '44 seconds = seconds');
<ide> assert.equal(start.from(moment([2007, 1, 28]).add({s: 45}), true), 'minutė', '45 seconds = a minute');
<ide> test("from", function (assert) {
<ide> assert.equal(start.from(moment([2007, 1, 28]).add({y: 5}), true), '5 metai', '5 years = 5 years');
<ide> });
<ide>
<del>test("suffix", function (assert) {
<add>test('suffix', function (assert) {
<ide> assert.equal(moment(30000).from(0), 'po kelių sekundžių', 'prefix');
<ide> assert.equal(moment(0).from(30000), 'prieš kelias sekundes', 'suffix');
<ide> });
<ide>
<del>test("now from now", function (assert) {
<add>test('now from now', function (assert) {
<ide> assert.equal(moment().fromNow(), 'prieš kelias sekundes', 'now from now should display as in the past');
<ide> });
<ide>
<del>test("fromNow", function (assert) {
<add>test('fromNow', function (assert) {
<ide> assert.equal(moment().add({s: 30}).fromNow(), 'po kelių sekundžių', 'in seconds');
<ide> assert.equal(moment().add({d: 5}).fromNow(), 'po 5 dienų', 'in 5 days');
<ide> });
<ide>
<del>test("calendar day", function (assert) {
<add>test('calendar day', function (assert) {
<ide> var a = moment().hours(2).minutes(0).seconds(0);
<ide>
<ide> assert.equal(moment(a).calendar(), 'Šiandien 02:00', 'today at the same time');
<ide> test("calendar day", function (assert) {
<ide> assert.equal(moment(a).subtract({d: 1}).calendar(), 'Vakar 02:00', 'yesterday at the same time');
<ide> });
<ide>
<del>test("calendar next week", function (assert) {
<add>test('calendar next week', function (assert) {
<ide> var i, m;
<ide> for (i = 2; i < 7; i++) {
<ide> m = moment().add({d: i});
<ide> test("calendar next week", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("calendar last week", function (assert) {
<add>test('calendar last week', function (assert) {
<ide> var i, m;
<ide> for (i = 2; i < 7; i++) {
<ide> m = moment().subtract({d: i});
<ide> test("calendar last week", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("calendar all else", function (assert) {
<add>test('calendar all else', function (assert) {
<ide> var weeksAgo = moment().subtract({w: 1}),
<ide> weeksFromNow = moment().add({w: 1});
<ide>
<ide> test("calendar all else", function (assert) {
<ide> assert.equal(weeksFromNow.calendar(), weeksFromNow.format('L'), 'in 2 weeks');
<ide> });
<ide>
<del>test("weeks year starting sunday", function (assert) {
<add>test('weeks year starting sunday', function (assert) {
<ide> assert.equal(moment([2012, 0, 1]).week(), 52, 'Jan 1 2012 should be week 52');
<ide> assert.equal(moment([2012, 0, 2]).week(), 1, 'Jan 2 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 8]).week(), 1, 'Jan 8 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 9]).week(), 2, 'Jan 9 2012 should be week 2');
<ide> assert.equal(moment([2012, 0, 15]).week(), 2, 'Jan 15 2012 should be week 2');
<ide> });
<ide>
<del>test("weeks year starting monday", function (assert) {
<add>test('weeks year starting monday', function (assert) {
<ide> assert.equal(moment([2007, 0, 1]).week(), 1, 'Jan 1 2007 should be week 1');
<ide> assert.equal(moment([2007, 0, 7]).week(), 1, 'Jan 7 2007 should be week 1');
<ide> assert.equal(moment([2007, 0, 8]).week(), 2, 'Jan 8 2007 should be week 2');
<ide> assert.equal(moment([2007, 0, 14]).week(), 2, 'Jan 14 2007 should be week 2');
<ide> assert.equal(moment([2007, 0, 15]).week(), 3, 'Jan 15 2007 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting tuesday", function (assert) {
<add>test('weeks year starting tuesday', function (assert) {
<ide> assert.equal(moment([2007, 11, 31]).week(), 1, 'Dec 31 2007 should be week 1');
<ide> assert.equal(moment([2008, 0, 1]).week(), 1, 'Jan 1 2008 should be week 1');
<ide> assert.equal(moment([2008, 0, 6]).week(), 1, 'Jan 6 2008 should be week 1');
<ide> test("weeks year starting tuesday", function (assert) {
<ide> assert.equal(moment([2008, 0, 14]).week(), 3, 'Jan 14 2008 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting wednesday", function (assert) {
<add>test('weeks year starting wednesday', function (assert) {
<ide> assert.equal(moment([2002, 11, 30]).week(), 1, 'Dec 30 2002 should be week 1');
<ide> assert.equal(moment([2003, 0, 1]).week(), 1, 'Jan 1 2003 should be week 1');
<ide> assert.equal(moment([2003, 0, 5]).week(), 1, 'Jan 5 2003 should be week 1');
<ide> test("weeks year starting wednesday", function (assert) {
<ide> assert.equal(moment([2003, 0, 13]).week(), 3, 'Jan 13 2003 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting thursday", function (assert) {
<add>test('weeks year starting thursday', function (assert) {
<ide> assert.equal(moment([2008, 11, 29]).week(), 1, 'Dec 29 2008 should be week 1');
<ide> assert.equal(moment([2009, 0, 1]).week(), 1, 'Jan 1 2009 should be week 1');
<ide> assert.equal(moment([2009, 0, 4]).week(), 1, 'Jan 4 2009 should be week 1');
<ide> test("weeks year starting thursday", function (assert) {
<ide> assert.equal(moment([2009, 0, 13]).week(), 3, 'Jan 12 2009 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting friday", function (assert) {
<add>test('weeks year starting friday', function (assert) {
<ide> assert.equal(moment([2009, 11, 28]).week(), 53, 'Dec 28 2009 should be week 53');
<ide> assert.equal(moment([2010, 0, 1]).week(), 53, 'Jan 1 2010 should be week 53');
<ide> assert.equal(moment([2010, 0, 3]).week(), 53, 'Jan 3 2010 should be week 53');
<ide> test("weeks year starting friday", function (assert) {
<ide> assert.equal(moment([2010, 0, 11]).week(), 2, 'Jan 11 2010 should be week 2');
<ide> });
<ide>
<del>test("weeks year starting saturday", function (assert) {
<add>test('weeks year starting saturday', function (assert) {
<ide> assert.equal(moment([2010, 11, 27]).week(), 52, 'Dec 27 2010 should be week 52');
<ide> assert.equal(moment([2011, 0, 1]).week(), 52, 'Jan 1 2011 should be week 52');
<ide> assert.equal(moment([2011, 0, 2]).week(), 52, 'Jan 2 2011 should be week 52');
<ide> test("weeks year starting saturday", function (assert) {
<ide> assert.equal(moment([2011, 0, 10]).week(), 2, 'Jan 10 2011 should be week 2');
<ide> });
<ide>
<del>test("weeks year starting sunday formatted", function (assert) {
<add>test('weeks year starting sunday formatted', function (assert) {
<ide> assert.equal(moment([2012, 0, 1]).format('w ww wo'), '52 52 52-oji', 'Jan 1 2012 should be week 52');
<ide> assert.equal(moment([2012, 0, 2]).format('w ww wo'), '1 01 1-oji', 'Jan 2 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 8]).format('w ww wo'), '1 01 1-oji', 'Jan 8 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 9]).format('w ww wo'), '2 02 2-oji', 'Jan 9 2012 should be week 2');
<ide> assert.equal(moment([2012, 0, 15]).format('w ww wo'), '2 02 2-oji', 'Jan 15 2012 should be week 2');
<ide> });
<ide>
<del>test("lenient ordinal parsing", function (assert) {
<add>test('lenient ordinal parsing', function (assert) {
<ide> var i, ordinalStr, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> ordinalStr = moment([2014, 0, i]).format('YYYY MM Do');
<ide> test("lenient ordinal parsing", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("lenient ordinal parsing of number", function (assert) {
<add>test('lenient ordinal parsing of number', function (assert) {
<ide> var i, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> testMoment = moment('2014 01 ' + i, 'YYYY MM Do');
<ide> test("lenient ordinal parsing of number", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("strict ordinal parsing", function (assert) {
<add>test('strict ordinal parsing', function (assert) {
<ide> var i, ordinalStr, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> ordinalStr = moment([2014, 0, i]).format('YYYY MM Do');
<ide><path>src/test/locale/lv.js
<del>import {localeModule, test} from "../qunit";
<del>import {moment} from "../../moment";
<del>localeModule("lv");
<add>import {localeModule, test} from '../qunit';
<add>import {moment} from '../../moment';
<add>localeModule('lv');
<ide>
<del>test("parse", function (assert) {
<add>test('parse', function (assert) {
<ide> var tests = 'janvāris jan_februāris feb_marts mar_aprīlis apr_maijs mai_jūnijs jūn_jūlijs jūl_augusts aug_septembris sep_oktobris okt_novembris nov_decembris dec'.split('_'), i;
<ide> function equalTest(input, mmm, i) {
<ide> assert.equal(moment(input, mmm).month(), i, input + ' should be month ' + (i + 1));
<ide> test("parse", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("format", function (assert) {
<add>test('format', function (assert) {
<ide> var a = [
<ide> ['dddd, Do MMMM YYYY, h:mm:ss a', 'svētdiena, 14. februāris 2010, 3:25:50 pm'],
<ide> ['ddd, hA', 'Sv, 3PM'],
<ide> test("format", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("format ordinal", function (assert) {
<add>test('format ordinal', function (assert) {
<ide> assert.equal(moment([2011, 0, 1]).format('DDDo'), '1.', '1.');
<ide> assert.equal(moment([2011, 0, 2]).format('DDDo'), '2.', '2.');
<ide> assert.equal(moment([2011, 0, 3]).format('DDDo'), '3.', '3.');
<ide> test("format ordinal", function (assert) {
<ide> assert.equal(moment([2011, 0, 31]).format('DDDo'), '31.', '31.');
<ide> });
<ide>
<del>test("format month", function (assert) {
<add>test('format month', function (assert) {
<ide> var expected = 'janvāris jan_februāris feb_marts mar_aprīlis apr_maijs mai_jūnijs jūn_jūlijs jūl_augusts aug_septembris sep_oktobris okt_novembris nov_decembris dec'.split('_'), i;
<ide> for (i = 0; i < expected.length; i++) {
<ide> assert.equal(moment([2011, i, 1]).format('MMMM MMM'), expected[i], expected[i]);
<ide> }
<ide> });
<ide>
<del>test("format week", function (assert) {
<add>test('format week', function (assert) {
<ide> var expected = 'svētdiena Sv Sv_pirmdiena P P_otrdiena O O_trešdiena T T_ceturtdiena C C_piektdiena Pk Pk_sestdiena S S'.split('_'), i;
<ide> for (i = 0; i < expected.length; i++) {
<ide> assert.equal(moment([2011, 0, 2 + i]).format('dddd ddd dd'), expected[i], expected[i]);
<ide> }
<ide> });
<ide>
<del>test("from", function (assert) {
<add>test('from', function (assert) {
<ide> var start = moment([2007, 1, 28]);
<ide> assert.equal(start.from(moment([2007, 1, 28]).add({s: 44}), true), 'dažas sekundes', '44 seconds = seconds');
<ide> assert.equal(start.from(moment([2007, 1, 28]).add({s: 45}), true), 'minūti', '45 seconds = a minute');
<ide> test("from", function (assert) {
<ide> assert.equal(start.from(moment([2007, 1, 28]).add({y: 5}), true), '5 gadi', '5 years = 5 years');
<ide> });
<ide>
<del>test("suffix", function (assert) {
<add>test('suffix', function (assert) {
<ide> assert.equal(moment(30000).from(0), 'dažas sekundes vēlāk', 'prefix');
<ide> assert.equal(moment(0).from(30000), 'dažas sekundes agrāk', 'suffix');
<ide> });
<ide>
<del>test("now from now", function (assert) {
<add>test('now from now', function (assert) {
<ide> assert.equal(moment().fromNow(), 'dažas sekundes agrāk', 'now from now should display as in the past');
<ide> });
<ide>
<del>test("fromNow", function (assert) {
<add>test('fromNow', function (assert) {
<ide> assert.equal(moment().add({s: 30}).fromNow(), 'dažas sekundes vēlāk', 'in seconds');
<ide> assert.equal(moment().add({d: 5}).fromNow(), '5 dienas vēlāk', 'in 5 days');
<ide> });
<ide>
<del>test("calendar day", function (assert) {
<add>test('calendar day', function (assert) {
<ide> var a = moment().hours(2).minutes(0).seconds(0);
<ide>
<ide> assert.equal(moment(a).calendar(), 'Šodien pulksten 02:00', 'today at the same time');
<ide> test("calendar day", function (assert) {
<ide> assert.equal(moment(a).subtract({d: 1}).calendar(), 'Vakar pulksten 02:00', 'yesterday at the same time');
<ide> });
<ide>
<del>test("calendar next week", function (assert) {
<add>test('calendar next week', function (assert) {
<ide> var i, m;
<ide> for (i = 2; i < 7; i++) {
<ide> m = moment().add({d: i});
<ide> test("calendar next week", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("calendar last week", function (assert) {
<add>test('calendar last week', function (assert) {
<ide> var i, m;
<ide> for (i = 2; i < 7; i++) {
<ide> m = moment().subtract({d: i});
<ide> test("calendar last week", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("calendar all else", function (assert) {
<add>test('calendar all else', function (assert) {
<ide> var weeksAgo = moment().subtract({w: 1}),
<ide> weeksFromNow = moment().add({w: 1});
<ide>
<ide> test("calendar all else", function (assert) {
<ide> assert.equal(weeksFromNow.calendar(), weeksFromNow.format('L'), 'in 2 weeks');
<ide> });
<ide>
<del>test("weeks year starting sunday", function (assert) {
<add>test('weeks year starting sunday', function (assert) {
<ide> assert.equal(moment([2012, 0, 1]).week(), 52, 'Jan 1 2012 should be week 52');
<ide> assert.equal(moment([2012, 0, 2]).week(), 1, 'Jan 2 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 8]).week(), 1, 'Jan 8 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 9]).week(), 2, 'Jan 9 2012 should be week 2');
<ide> assert.equal(moment([2012, 0, 15]).week(), 2, 'Jan 15 2012 should be week 2');
<ide> });
<ide>
<del>test("weeks year starting monday", function (assert) {
<add>test('weeks year starting monday', function (assert) {
<ide> assert.equal(moment([2007, 0, 1]).week(), 1, 'Jan 1 2007 should be week 1');
<ide> assert.equal(moment([2007, 0, 7]).week(), 1, 'Jan 7 2007 should be week 1');
<ide> assert.equal(moment([2007, 0, 8]).week(), 2, 'Jan 8 2007 should be week 2');
<ide> assert.equal(moment([2007, 0, 14]).week(), 2, 'Jan 14 2007 should be week 2');
<ide> assert.equal(moment([2007, 0, 15]).week(), 3, 'Jan 15 2007 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting tuesday", function (assert) {
<add>test('weeks year starting tuesday', function (assert) {
<ide> assert.equal(moment([2007, 11, 31]).week(), 1, 'Dec 31 2007 should be week 1');
<ide> assert.equal(moment([2008, 0, 1]).week(), 1, 'Jan 1 2008 should be week 1');
<ide> assert.equal(moment([2008, 0, 6]).week(), 1, 'Jan 6 2008 should be week 1');
<ide> test("weeks year starting tuesday", function (assert) {
<ide> assert.equal(moment([2008, 0, 14]).week(), 3, 'Jan 14 2008 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting wednesday", function (assert) {
<add>test('weeks year starting wednesday', function (assert) {
<ide> assert.equal(moment([2002, 11, 30]).week(), 1, 'Dec 30 2002 should be week 1');
<ide> assert.equal(moment([2003, 0, 1]).week(), 1, 'Jan 1 2003 should be week 1');
<ide> assert.equal(moment([2003, 0, 5]).week(), 1, 'Jan 5 2003 should be week 1');
<ide> test("weeks year starting wednesday", function (assert) {
<ide> assert.equal(moment([2003, 0, 13]).week(), 3, 'Jan 13 2003 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting thursday", function (assert) {
<add>test('weeks year starting thursday', function (assert) {
<ide> assert.equal(moment([2008, 11, 29]).week(), 1, 'Dec 29 2008 should be week 1');
<ide> assert.equal(moment([2009, 0, 1]).week(), 1, 'Jan 1 2009 should be week 1');
<ide> assert.equal(moment([2009, 0, 4]).week(), 1, 'Jan 4 2009 should be week 1');
<ide> test("weeks year starting thursday", function (assert) {
<ide> assert.equal(moment([2009, 0, 13]).week(), 3, 'Jan 12 2009 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting friday", function (assert) {
<add>test('weeks year starting friday', function (assert) {
<ide> assert.equal(moment([2009, 11, 28]).week(), 53, 'Dec 28 2009 should be week 53');
<ide> assert.equal(moment([2010, 0, 1]).week(), 53, 'Jan 1 2010 should be week 53');
<ide> assert.equal(moment([2010, 0, 3]).week(), 53, 'Jan 3 2010 should be week 53');
<ide> test("weeks year starting friday", function (assert) {
<ide> assert.equal(moment([2010, 0, 11]).week(), 2, 'Jan 11 2010 should be week 2');
<ide> });
<ide>
<del>test("weeks year starting saturday", function (assert) {
<add>test('weeks year starting saturday', function (assert) {
<ide> assert.equal(moment([2010, 11, 27]).week(), 52, 'Dec 27 2010 should be week 52');
<ide> assert.equal(moment([2011, 0, 1]).week(), 52, 'Jan 1 2011 should be week 52');
<ide> assert.equal(moment([2011, 0, 2]).week(), 52, 'Jan 2 2011 should be week 52');
<ide> test("weeks year starting saturday", function (assert) {
<ide> assert.equal(moment([2011, 0, 10]).week(), 2, 'Jan 10 2011 should be week 2');
<ide> });
<ide>
<del>test("weeks year starting sunday formatted", function (assert) {
<add>test('weeks year starting sunday formatted', function (assert) {
<ide> assert.equal(moment([2012, 0, 1]).format('w ww wo'), '52 52 52.', 'Jan 1 2012 should be week 52');
<ide> assert.equal(moment([2012, 0, 2]).format('w ww wo'), '1 01 1.', 'Jan 2 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 8]).format('w ww wo'), '1 01 1.', 'Jan 8 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 9]).format('w ww wo'), '2 02 2.', 'Jan 9 2012 should be week 2');
<ide> assert.equal(moment([2012, 0, 15]).format('w ww wo'), '2 02 2.', 'Jan 15 2012 should be week 2');
<ide> });
<ide>
<del>test("lenient ordinal parsing", function (assert) {
<add>test('lenient ordinal parsing', function (assert) {
<ide> var i, ordinalStr, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> ordinalStr = moment([2014, 0, i]).format('YYYY MM Do');
<ide> test("lenient ordinal parsing", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("lenient ordinal parsing of number", function (assert) {
<add>test('lenient ordinal parsing of number', function (assert) {
<ide> var i, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> testMoment = moment('2014 01 ' + i, 'YYYY MM Do');
<ide> test("lenient ordinal parsing of number", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("strict ordinal parsing", function (assert) {
<add>test('strict ordinal parsing', function (assert) {
<ide> var i, ordinalStr, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> ordinalStr = moment([2014, 0, i]).format('YYYY MM Do');
<ide><path>src/test/locale/mk.js
<del>import {localeModule, test} from "../qunit";
<del>import {moment} from "../../moment";
<del>localeModule("mk");
<add>import {localeModule, test} from '../qunit';
<add>import {moment} from '../../moment';
<add>localeModule('mk');
<ide>
<del>test("parse", function (assert) {
<add>test('parse', function (assert) {
<ide> var tests = 'јануари јан_февруари фев_март мар_април апр_мај мај_јуни јун_јули јул_август авг_септември сеп_октомври окт_ноември ное_декември дек'.split('_'), i;
<ide> function equalTest(input, mmm, i) {
<ide> assert.equal(moment(input, mmm).month(), i, input + ' should be month ' + (i + 1));
<ide> test("parse", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("format", function (assert) {
<add>test('format', function (assert) {
<ide> var a = [
<ide> ['dddd, MMMM Do YYYY, H:mm:ss', 'недела, февруари 14-ти 2010, 15:25:50'],
<ide> ['ddd, hA', 'нед, 3PM'],
<ide> test("format", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("format ordinal", function (assert) {
<add>test('format ordinal', function (assert) {
<ide> assert.equal(moment([2011, 0, 1]).format('DDDo'), '1-ви', '1-ви');
<ide> assert.equal(moment([2011, 0, 2]).format('DDDo'), '2-ри', '2-ри');
<ide> assert.equal(moment([2011, 0, 3]).format('DDDo'), '3-ти', '3-ти');
<ide> test("format ordinal", function (assert) {
<ide> assert.equal(moment([2011, 0, 31]).format('DDDo'), '31-ви', '31-ви');
<ide> });
<ide>
<del>test("format month", function (assert) {
<add>test('format month', function (assert) {
<ide> var expected = 'јануари јан_февруари фев_март мар_април апр_мај мај_јуни јун_јули јул_август авг_септември сеп_октомври окт_ноември ное_декември дек'.split('_'), i;
<ide> for (i = 0; i < expected.length; i++) {
<ide> assert.equal(moment([2011, i, 1]).format('MMMM MMM'), expected[i], expected[i]);
<ide> }
<ide> });
<ide>
<del>test("format week", function (assert) {
<add>test('format week', function (assert) {
<ide> var expected = 'недела нед нe_понеделник пон пo_вторник вто вт_среда сре ср_четврток чет че_петок пет пе_сабота саб сa'.split('_'), i;
<ide> for (i = 0; i < expected.length; i++) {
<ide> assert.equal(moment([2011, 0, 2 + i]).format('dddd ddd dd'), expected[i], expected[i]);
<ide> }
<ide> });
<ide>
<del>test("from", function (assert) {
<add>test('from', function (assert) {
<ide> var start = moment([2007, 1, 28]);
<ide> assert.equal(start.from(moment([2007, 1, 28]).add({s: 44}), true), 'неколку секунди', '44 seconds = a few seconds');
<ide> assert.equal(start.from(moment([2007, 1, 28]).add({s: 45}), true), 'минута', '45 seconds = a minute');
<ide> test("from", function (assert) {
<ide> assert.equal(start.from(moment([2007, 1, 28]).add({y: 5}), true), '5 години', '5 years = 5 years');
<ide> });
<ide>
<del>test("suffix", function (assert) {
<add>test('suffix', function (assert) {
<ide> assert.equal(moment(30000).from(0), 'после неколку секунди', 'prefix');
<ide> assert.equal(moment(0).from(30000), 'пред неколку секунди', 'suffix');
<ide> });
<ide>
<del>test("now from now", function (assert) {
<add>test('now from now', function (assert) {
<ide> assert.equal(moment().fromNow(), 'пред неколку секунди', 'now from now should display as in the past');
<ide> });
<ide>
<del>test("fromNow", function (assert) {
<add>test('fromNow', function (assert) {
<ide> assert.equal(moment().add({s: 30}).fromNow(), 'после неколку секунди', 'in a few seconds');
<ide> assert.equal(moment().add({d: 5}).fromNow(), 'после 5 дена', 'in 5 days');
<ide> });
<ide>
<del>test("calendar day", function (assert) {
<add>test('calendar day', function (assert) {
<ide> var a = moment().hours(2).minutes(0).seconds(0);
<ide>
<ide> assert.equal(moment(a).calendar(), 'Денес во 2:00', 'today at the same time');
<ide> test("calendar day", function (assert) {
<ide> assert.equal(moment(a).subtract({d: 1}).calendar(), 'Вчера во 2:00', 'yesterday at the same time');
<ide> });
<ide>
<del>test("calendar next week", function (assert) {
<add>test('calendar next week', function (assert) {
<ide> var i, m;
<ide> for (i = 2; i < 7; i++) {
<ide> m = moment().add({d: i});
<ide> test("calendar next week", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("calendar last week", function (assert) {
<add>test('calendar last week', function (assert) {
<ide> var i, m;
<ide>
<ide> function makeFormat(d) {
<ide> test("calendar last week", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("calendar all else", function (assert) {
<add>test('calendar all else', function (assert) {
<ide> var weeksAgo = moment().subtract({w: 1}),
<ide> weeksFromNow = moment().add({w: 1});
<ide>
<ide> test("calendar all else", function (assert) {
<ide> assert.equal(weeksFromNow.calendar(), weeksFromNow.format('L'), 'in 2 weeks');
<ide> });
<ide>
<del>test("weeks year starting sunday", function (assert) {
<add>test('weeks year starting sunday', function (assert) {
<ide> assert.equal(moment([2011, 11, 26]).week(), 1, 'Dec 26 2011 should be week 1');
<ide> assert.equal(moment([2012, 0, 1]).week(), 1, 'Jan 1 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 2]).week(), 2, 'Jan 2 2012 should be week 2');
<ide> assert.equal(moment([2012, 0, 8]).week(), 2, 'Jan 8 2012 should be week 2');
<ide> assert.equal(moment([2012, 0, 9]).week(), 3, 'Jan 9 2012 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting monday", function (assert) {
<add>test('weeks year starting monday', function (assert) {
<ide> assert.equal(moment([2007, 0, 1]).week(), 1, 'Jan 1 2007 should be week 1');
<ide> assert.equal(moment([2007, 0, 7]).week(), 1, 'Jan 7 2007 should be week 1');
<ide> assert.equal(moment([2007, 0, 8]).week(), 2, 'Jan 8 2007 should be week 2');
<ide> assert.equal(moment([2007, 0, 14]).week(), 2, 'Jan 14 2007 should be week 2');
<ide> assert.equal(moment([2007, 0, 15]).week(), 3, 'Jan 15 2007 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting tuesday", function (assert) {
<add>test('weeks year starting tuesday', function (assert) {
<ide> assert.equal(moment([2007, 11, 31]).week(), 1, 'Dec 31 2007 should be week 1');
<ide> assert.equal(moment([2008, 0, 1]).week(), 1, 'Jan 1 2008 should be week 1');
<ide> assert.equal(moment([2008, 0, 6]).week(), 1, 'Jan 6 2008 should be week 1');
<ide> test("weeks year starting tuesday", function (assert) {
<ide> assert.equal(moment([2008, 0, 14]).week(), 3, 'Jan 14 2008 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting wednesday", function (assert) {
<add>test('weeks year starting wednesday', function (assert) {
<ide> assert.equal(moment([2002, 11, 30]).week(), 1, 'Dec 30 2002 should be week 1');
<ide> assert.equal(moment([2003, 0, 1]).week(), 1, 'Jan 1 2003 should be week 1');
<ide> assert.equal(moment([2003, 0, 5]).week(), 1, 'Jan 5 2003 should be week 1');
<ide> test("weeks year starting wednesday", function (assert) {
<ide> assert.equal(moment([2003, 0, 13]).week(), 3, 'Jan 13 2003 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting thursday", function (assert) {
<add>test('weeks year starting thursday', function (assert) {
<ide> assert.equal(moment([2008, 11, 29]).week(), 1, 'Dec 29 2008 should be week 1');
<ide> assert.equal(moment([2009, 0, 1]).week(), 1, 'Jan 1 2009 should be week 1');
<ide> assert.equal(moment([2009, 0, 4]).week(), 1, 'Jan 4 2009 should be week 1');
<ide> test("weeks year starting thursday", function (assert) {
<ide> assert.equal(moment([2009, 0, 12]).week(), 3, 'Jan 12 2009 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting friday", function (assert) {
<add>test('weeks year starting friday', function (assert) {
<ide> assert.equal(moment([2009, 11, 28]).week(), 1, 'Dec 28 2009 should be week 1');
<ide> assert.equal(moment([2010, 0, 1]).week(), 1, 'Jan 1 2010 should be week 1');
<ide> assert.equal(moment([2010, 0, 3]).week(), 1, 'Jan 3 2010 should be week 1');
<ide> test("weeks year starting friday", function (assert) {
<ide> assert.equal(moment([2010, 0, 11]).week(), 3, 'Jan 11 2010 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting saturday", function (assert) {
<add>test('weeks year starting saturday', function (assert) {
<ide> assert.equal(moment([2010, 11, 27]).week(), 1, 'Dec 27 2010 should be week 1');
<ide> assert.equal(moment([2011, 0, 1]).week(), 1, 'Jan 1 2011 should be week 1');
<ide> assert.equal(moment([2011, 0, 2]).week(), 1, 'Jan 2 2011 should be week 1');
<ide> test("weeks year starting saturday", function (assert) {
<ide> assert.equal(moment([2011, 0, 10]).week(), 3, 'Jan 10 2011 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting sunday formatted", function (assert) {
<add>test('weeks year starting sunday formatted', function (assert) {
<ide> assert.equal(moment([2011, 11, 26]).format('w ww wo'), '1 01 1-ви', 'Dec 26 2011 should be week 1');
<ide> assert.equal(moment([2012, 0, 1]).format('w ww wo'), '1 01 1-ви', 'Jan 1 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 2]).format('w ww wo'), '2 02 2-ри', 'Jan 2 2012 should be week 2');
<ide> assert.equal(moment([2012, 0, 8]).format('w ww wo'), '2 02 2-ри', 'Jan 8 2012 should be week 2');
<ide> assert.equal(moment([2012, 0, 9]).format('w ww wo'), '3 03 3-ти', 'Jan 9 2012 should be week 3');
<ide> });
<ide>
<del>test("lenient ordinal parsing", function (assert) {
<add>test('lenient ordinal parsing', function (assert) {
<ide> var i, ordinalStr, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> ordinalStr = moment([2014, 0, i]).format('YYYY MM Do');
<ide> test("lenient ordinal parsing", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("lenient ordinal parsing of number", function (assert) {
<add>test('lenient ordinal parsing of number', function (assert) {
<ide> var i, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> testMoment = moment('2014 01 ' + i, 'YYYY MM Do');
<ide> test("lenient ordinal parsing of number", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("strict ordinal parsing", function (assert) {
<add>test('strict ordinal parsing', function (assert) {
<ide> var i, ordinalStr, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> ordinalStr = moment([2014, 0, i]).format('YYYY MM Do');
<ide><path>src/test/locale/ml.js
<del>import {localeModule, test} from "../qunit";
<del>import {moment} from "../../moment";
<del>localeModule("ml");
<add>import {localeModule, test} from '../qunit';
<add>import {moment} from '../../moment';
<add>localeModule('ml');
<ide>
<del>test("parse", function (assert) {
<add>test('parse', function (assert) {
<ide> var tests = 'ജനുവരി ജനു._ഫെബ്രുവരി ഫെബ്രു._മാർച്ച് മാർ._ഏപ്രിൽ ഏപ്രി._മേയ് മേയ്_ജൂൺ ജൂൺ_ജൂലൈ ജൂലൈ._ഓഗസ്റ്റ് ഓഗ._സെപ്റ്റംബർ സെപ്റ്റ._ഒക്ടോബർ ഒക്ടോ._നവംബർ നവം._ഡിസംബർ ഡിസം.'.split('_'), i;
<ide> function equalTest(input, mmm, i) {
<ide> assert.equal(moment(input, mmm).month(), i, input + ' should be month ' + (i + 1));
<ide> test("parse", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("format", function (assert) {
<add>test('format', function (assert) {
<ide> var a = [
<ide> ['dddd, Do MMMM YYYY, a h:mm:ss -നു', 'ഞായറാഴ്ച, 14 ഫെബ്രുവരി 2010, ഉച്ച കഴിഞ്ഞ് 3:25:50 -നു'],
<ide> ['ddd, a h -നു', 'ഞായർ, ഉച്ച കഴിഞ്ഞ് 3 -നു'],
<ide> test("format", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("format ordinal", function (assert) {
<add>test('format ordinal', function (assert) {
<ide> assert.equal(moment([2011, 0, 1]).format('DDDo'), '1', '1');
<ide> assert.equal(moment([2011, 0, 2]).format('DDDo'), '2', '2');
<ide> assert.equal(moment([2011, 0, 3]).format('DDDo'), '3', '3');
<ide> test("format ordinal", function (assert) {
<ide> assert.equal(moment([2011, 0, 31]).format('DDDo'), '31', '31');
<ide> });
<ide>
<del>test("format month", function (assert) {
<add>test('format month', function (assert) {
<ide> var expected = 'ജനുവരി ജനു._ഫെബ്രുവരി ഫെബ്രു._മാർച്ച് മാർ._ഏപ്രിൽ ഏപ്രി._മേയ് മേയ്_ജൂൺ ജൂൺ_ജൂലൈ ജൂലൈ._ഓഗസ്റ്റ് ഓഗ._സെപ്റ്റംബർ സെപ്റ്റ._ഒക്ടോബർ ഒക്ടോ._നവംബർ നവം._ഡിസംബർ ഡിസം.'.split('_'), i;
<ide> for (i = 0; i < expected.length; i++) {
<ide> assert.equal(moment([2011, i, 1]).format('MMMM MMM'), expected[i], expected[i]);
<ide> }
<ide> });
<ide>
<del>test("format week", function (assert) {
<add>test('format week', function (assert) {
<ide> var expected = 'ഞായറാഴ്ച ഞായർ ഞാ_തിങ്കളാഴ്ച തിങ്കൾ തി_ചൊവ്വാഴ്ച ചൊവ്വ ചൊ_ബുധനാഴ്ച ബുധൻ ബു_വ്യാഴാഴ്ച വ്യാഴം വ്യാ_വെള്ളിയാഴ്ച വെള്ളി വെ_ശനിയാഴ്ച ശനി ശ'.split('_'), i;
<ide> for (i = 0; i < expected.length; i++) {
<ide> assert.equal(moment([2011, 0, 2 + i]).format('dddd ddd dd'), expected[i], expected[i]);
<ide> }
<ide> });
<ide>
<del>test("from", function (assert) {
<add>test('from', function (assert) {
<ide> var start = moment([2007, 1, 28]);
<ide> assert.equal(start.from(moment([2007, 1, 28]).add({s: 44}), true), 'അൽപ നിമിഷങ്ങൾ', '44 seconds = a few seconds');
<ide> assert.equal(start.from(moment([2007, 1, 28]).add({s: 45}), true), 'ഒരു മിനിറ്റ്', '45 seconds = a minute');
<ide> test("from", function (assert) {
<ide> assert.equal(start.from(moment([2007, 1, 28]).add({y: 5}), true), '5 വർഷം', '5 years = 5 years');
<ide> });
<ide>
<del>test("suffix", function (assert) {
<add>test('suffix', function (assert) {
<ide> assert.equal(moment(30000).from(0), 'അൽപ നിമിഷങ്ങൾ കഴിഞ്ഞ്', 'prefix');
<ide> assert.equal(moment(0).from(30000), 'അൽപ നിമിഷങ്ങൾ മുൻപ്', 'suffix');
<ide> });
<ide>
<del>test("now from now", function (assert) {
<add>test('now from now', function (assert) {
<ide> assert.equal(moment().fromNow(), 'അൽപ നിമിഷങ്ങൾ മുൻപ്', 'now from now should display as in the past');
<ide> });
<ide>
<del>test("fromNow", function (assert) {
<add>test('fromNow', function (assert) {
<ide> assert.equal(moment().add({s: 30}).fromNow(), 'അൽപ നിമിഷങ്ങൾ കഴിഞ്ഞ്', 'അൽപ നിമിഷങ്ങൾ കഴിഞ്ഞ്');
<ide> assert.equal(moment().add({d: 5}).fromNow(), '5 ദിവസം കഴിഞ്ഞ്', '5 ദിവസം കഴിഞ്ഞ്');
<ide> });
<ide>
<del>test("calendar day", function (assert) {
<add>test('calendar day', function (assert) {
<ide> var a = moment().hours(2).minutes(0).seconds(0);
<ide>
<ide> assert.equal(moment(a).calendar(), 'ഇന്ന് രാത്രി 2:00 -നു', 'today at the same time');
<ide> test("calendar day", function (assert) {
<ide> assert.equal(moment(a).subtract({d: 1}).calendar(), 'ഇന്നലെ രാത്രി 2:00 -നു', 'yesterday at the same time');
<ide> });
<ide>
<del>test("calendar next week", function (assert) {
<add>test('calendar next week', function (assert) {
<ide> var i, m;
<ide> for (i = 2; i < 7; i++) {
<ide> m = moment().add({d: i});
<ide> test("calendar next week", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("calendar last week", function (assert) {
<add>test('calendar last week', function (assert) {
<ide> var i, m;
<ide>
<ide> for (i = 2; i < 7; i++) {
<ide> test("calendar last week", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("calendar all else", function (assert) {
<add>test('calendar all else', function (assert) {
<ide> var weeksAgo = moment().subtract({w: 1}),
<ide> weeksFromNow = moment().add({w: 1});
<ide>
<ide> test("calendar all else", function (assert) {
<ide> assert.equal(weeksFromNow.calendar(), weeksFromNow.format('L'), 'in 2 weeks');
<ide> });
<ide>
<del>test("meridiem", function (assert) {
<add>test('meridiem', function (assert) {
<ide> assert.equal(moment([2011, 2, 23, 2, 30]).format('a'), 'രാത്രി', 'before dawn');
<ide> assert.equal(moment([2011, 2, 23, 9, 30]).format('a'), 'രാവിലെ', 'morning');
<ide> assert.equal(moment([2011, 2, 23, 14, 30]).format('a'), 'ഉച്ച കഴിഞ്ഞ്', 'during day');
<ide> test("meridiem", function (assert) {
<ide> assert.equal(moment([2011, 2, 23, 21, 20]).format('A'), 'രാത്രി', 'night');
<ide> });
<ide>
<del>test("weeks year starting sunday", function (assert) {
<add>test('weeks year starting sunday', function (assert) {
<ide> assert.equal(moment([2012, 0, 1]).week(), 1, 'Jan 1 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 7]).week(), 1, 'Jan 7 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 8]).week(), 2, 'Jan 8 2012 should be week 2');
<ide> assert.equal(moment([2012, 0, 14]).week(), 2, 'Jan 14 2012 should be week 2');
<ide> assert.equal(moment([2012, 0, 15]).week(), 3, 'Jan 15 2012 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting monday", function (assert) {
<add>test('weeks year starting monday', function (assert) {
<ide> assert.equal(moment([2006, 11, 31]).week(), 1, 'Dec 31 2006 should be week 1');
<ide> assert.equal(moment([2007, 0, 1]).week(), 1, 'Jan 1 2007 should be week 1');
<ide> assert.equal(moment([2007, 0, 6]).week(), 1, 'Jan 6 2007 should be week 1');
<ide> test("weeks year starting monday", function (assert) {
<ide> assert.equal(moment([2007, 0, 14]).week(), 3, 'Jan 14 2007 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting tuesday", function (assert) {
<add>test('weeks year starting tuesday', function (assert) {
<ide> assert.equal(moment([2007, 11, 29]).week(), 52, 'Dec 29 2007 should be week 52');
<ide> assert.equal(moment([2008, 0, 1]).week(), 1, 'Jan 1 2008 should be week 1');
<ide> assert.equal(moment([2008, 0, 5]).week(), 1, 'Jan 5 2008 should be week 1');
<ide> test("weeks year starting tuesday", function (assert) {
<ide> assert.equal(moment([2008, 0, 13]).week(), 3, 'Jan 13 2008 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting wednesday", function (assert) {
<add>test('weeks year starting wednesday', function (assert) {
<ide> assert.equal(moment([2002, 11, 29]).week(), 1, 'Dec 29 2002 should be week 1');
<ide> assert.equal(moment([2003, 0, 1]).week(), 1, 'Jan 1 2003 should be week 1');
<ide> assert.equal(moment([2003, 0, 4]).week(), 1, 'Jan 4 2003 should be week 1');
<ide> test("weeks year starting wednesday", function (assert) {
<ide> assert.equal(moment([2003, 0, 12]).week(), 3, 'Jan 12 2003 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting thursday", function (assert) {
<add>test('weeks year starting thursday', function (assert) {
<ide> assert.equal(moment([2008, 11, 28]).week(), 1, 'Dec 28 2008 should be week 1');
<ide> assert.equal(moment([2009, 0, 1]).week(), 1, 'Jan 1 2009 should be week 1');
<ide> assert.equal(moment([2009, 0, 3]).week(), 1, 'Jan 3 2009 should be week 1');
<ide> test("weeks year starting thursday", function (assert) {
<ide> assert.equal(moment([2009, 0, 11]).week(), 3, 'Jan 11 2009 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting friday", function (assert) {
<add>test('weeks year starting friday', function (assert) {
<ide> assert.equal(moment([2009, 11, 27]).week(), 1, 'Dec 27 2009 should be week 1');
<ide> assert.equal(moment([2010, 0, 1]).week(), 1, 'Jan 1 2010 should be week 1');
<ide> assert.equal(moment([2010, 0, 2]).week(), 1, 'Jan 2 2010 should be week 1');
<ide> test("weeks year starting friday", function (assert) {
<ide> assert.equal(moment([2010, 0, 10]).week(), 3, 'Jan 10 2010 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting saturday", function (assert) {
<add>test('weeks year starting saturday', function (assert) {
<ide> assert.equal(moment([2010, 11, 26]).week(), 1, 'Dec 26 2010 should be week 1');
<ide> assert.equal(moment([2011, 0, 1]).week(), 1, 'Jan 1 2011 should be week 1');
<ide> assert.equal(moment([2011, 0, 2]).week(), 2, 'Jan 2 2011 should be week 2');
<ide> assert.equal(moment([2011, 0, 8]).week(), 2, 'Jan 8 2011 should be week 2');
<ide> assert.equal(moment([2011, 0, 9]).week(), 3, 'Jan 9 2011 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting sunday formatted", function (assert) {
<add>test('weeks year starting sunday formatted', function (assert) {
<ide> assert.equal(moment([2012, 0, 1]).format('w ww wo'), '1 01 1', 'Jan 1 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 7]).format('w ww wo'), '1 01 1', 'Jan 7 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 8]).format('w ww wo'), '2 02 2', 'Jan 8 2012 should be week 2');
<ide> assert.equal(moment([2012, 0, 14]).format('w ww wo'), '2 02 2', 'Jan 14 2012 should be week 2');
<ide> assert.equal(moment([2012, 0, 15]).format('w ww wo'), '3 03 3', 'Jan 15 2012 should be week 3');
<ide> });
<ide>
<del>test("lenient ordinal parsing", function (assert) {
<add>test('lenient ordinal parsing', function (assert) {
<ide> var i, ordinalStr, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> ordinalStr = moment([2014, 0, i]).format('YYYY MM Do');
<ide> test("lenient ordinal parsing", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("lenient ordinal parsing of number", function (assert) {
<add>test('lenient ordinal parsing of number', function (assert) {
<ide> var i, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> testMoment = moment('2014 01 ' + i, 'YYYY MM Do');
<ide> test("lenient ordinal parsing of number", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("strict ordinal parsing", function (assert) {
<add>test('strict ordinal parsing', function (assert) {
<ide> var i, ordinalStr, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> ordinalStr = moment([2014, 0, i]).format('YYYY MM Do');
<ide><path>src/test/locale/mr.js
<del>import {localeModule, test} from "../qunit";
<del>import {moment} from "../../moment";
<del>localeModule("mr");
<add>import {localeModule, test} from '../qunit';
<add>import {moment} from '../../moment';
<add>localeModule('mr');
<ide>
<del>test("parse", function (assert) {
<add>test('parse', function (assert) {
<ide> var tests = 'जानेवारी जाने._फेब्रुवारी फेब्रु._मार्च मार्च._एप्रिल एप्रि._मे मे._जून जून._जुलै जुलै._ऑगस्ट ऑग._सप्टेंबर सप्टें._ऑक्टोबर ऑक्टो._नोव्हेंबर नोव्हें._डिसेंबर डिसें.'.split('_'), i;
<ide> function equalTest(input, mmm, i) {
<ide> assert.equal(moment(input, mmm).month(), i, input + ' should be month ' + (i + 1));
<ide> test("parse", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("format", function (assert) {
<add>test('format', function (assert) {
<ide> var a = [
<ide> ['dddd, Do MMMM YYYY, a h:mm:ss वाजता', 'रविवार, १४ फेब्रुवारी २०१०, दुपारी ३:२५:५० वाजता'],
<ide> ['ddd, a h वाजता', 'रवि, दुपारी ३ वाजता'],
<ide> test("format", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("format ordinal", function (assert) {
<add>test('format ordinal', function (assert) {
<ide> assert.equal(moment([2011, 0, 1]).format('DDDo'), '१', '१');
<ide> assert.equal(moment([2011, 0, 2]).format('DDDo'), '२', '२');
<ide> assert.equal(moment([2011, 0, 3]).format('DDDo'), '३', '३');
<ide> test("format ordinal", function (assert) {
<ide> assert.equal(moment([2011, 0, 31]).format('DDDo'), '३१', '३१');
<ide> });
<ide>
<del>test("format month", function (assert) {
<add>test('format month', function (assert) {
<ide> var expected = 'जानेवारी जाने._फेब्रुवारी फेब्रु._मार्च मार्च._एप्रिल एप्रि._मे मे._जून जून._जुलै जुलै._ऑगस्ट ऑग._सप्टेंबर सप्टें._ऑक्टोबर ऑक्टो._नोव्हेंबर नोव्हें._डिसेंबर डिसें.'.split('_'), i;
<ide> for (i = 0; i < expected.length; i++) {
<ide> assert.equal(moment([2011, i, 1]).format('MMMM MMM'), expected[i], expected[i]);
<ide> }
<ide> });
<ide>
<del>test("format week", function (assert) {
<add>test('format week', function (assert) {
<ide> var expected = 'रविवार रवि र_सोमवार सोम सो_मंगळवार मंगळ मं_बुधवार बुध बु_गुरूवार गुरू गु_शुक्रवार शुक्र शु_शनिवार शनि श'.split('_'), i;
<ide> for (i = 0; i < expected.length; i++) {
<ide> assert.equal(moment([2011, 0, 2 + i]).format('dddd ddd dd'), expected[i], expected[i]);
<ide> }
<ide> });
<ide>
<del>test("from", function (assert) {
<add>test('from', function (assert) {
<ide> var start = moment([2007, 1, 28]);
<ide> assert.equal(start.from(moment([2007, 1, 28]).add({s: 44}), true), 'सेकंद', '44 seconds = a few seconds');
<ide> assert.equal(start.from(moment([2007, 1, 28]).add({s: 45}), true), 'एक मिनिट', '45 seconds = a minute');
<ide> test("from", function (assert) {
<ide> assert.equal(start.from(moment([2007, 1, 28]).add({y: 5}), true), '५ वर्षे', '5 years = 5 years');
<ide> });
<ide>
<del>test("suffix", function (assert) {
<add>test('suffix', function (assert) {
<ide> assert.equal(moment(30000).from(0), 'सेकंद नंतर', 'prefix');
<ide> assert.equal(moment(0).from(30000), 'सेकंद पूर्वी', 'suffix');
<ide> });
<ide>
<del>test("now from now", function (assert) {
<add>test('now from now', function (assert) {
<ide> assert.equal(moment().fromNow(), 'सेकंद पूर्वी', 'now from now should display as in the past');
<ide> });
<ide>
<del>test("fromNow", function (assert) {
<add>test('fromNow', function (assert) {
<ide> assert.equal(moment().add({s: 30}).fromNow(), 'सेकंद नंतर', 'सेकंद नंतर');
<ide> assert.equal(moment().add({d: 5}).fromNow(), '५ दिवस नंतर', '५ दिवस नंतर');
<ide> });
<ide>
<del>test("calendar day", function (assert) {
<add>test('calendar day', function (assert) {
<ide> var a = moment().hours(2).minutes(0).seconds(0);
<ide>
<ide> assert.equal(moment(a).calendar(), 'आज रात्री २:०० वाजता', 'today at the same time');
<ide> test("calendar day", function (assert) {
<ide> assert.equal(moment(a).subtract({d: 1}).calendar(), 'काल रात्री २:०० वाजता', 'yesterday at the same time');
<ide> });
<ide>
<del>test("calendar next week", function (assert) {
<add>test('calendar next week', function (assert) {
<ide> var i, m;
<ide> for (i = 2; i < 7; i++) {
<ide> m = moment().add({d: i});
<ide> test("calendar next week", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("calendar last week", function (assert) {
<add>test('calendar last week', function (assert) {
<ide> var i, m;
<ide>
<ide> for (i = 2; i < 7; i++) {
<ide> test("calendar last week", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("calendar all else", function (assert) {
<add>test('calendar all else', function (assert) {
<ide> var weeksAgo = moment().subtract({w: 1}),
<ide> weeksFromNow = moment().add({w: 1});
<ide>
<ide> test("calendar all else", function (assert) {
<ide> assert.equal(weeksFromNow.calendar(), weeksFromNow.format('L'), 'in 2 weeks');
<ide> });
<ide>
<del>test("meridiem", function (assert) {
<add>test('meridiem', function (assert) {
<ide> assert.equal(moment([2011, 2, 23, 2, 30]).format('a'), 'रात्री', 'before dawn');
<ide> assert.equal(moment([2011, 2, 23, 9, 30]).format('a'), 'सकाळी', 'morning');
<ide> assert.equal(moment([2011, 2, 23, 14, 30]).format('a'), 'दुपारी', 'during day');
<ide> test("meridiem", function (assert) {
<ide> assert.equal(moment([2011, 2, 23, 21, 20]).format('A'), 'रात्री', 'night');
<ide> });
<ide>
<del>test("weeks year starting sunday", function (assert) {
<add>test('weeks year starting sunday', function (assert) {
<ide> assert.equal(moment([2012, 0, 1]).week(), 1, 'Jan 1 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 7]).week(), 1, 'Jan 7 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 8]).week(), 2, 'Jan 8 2012 should be week 2');
<ide> assert.equal(moment([2012, 0, 14]).week(), 2, 'Jan 14 2012 should be week 2');
<ide> assert.equal(moment([2012, 0, 15]).week(), 3, 'Jan 15 2012 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting monday", function (assert) {
<add>test('weeks year starting monday', function (assert) {
<ide> assert.equal(moment([2006, 11, 31]).week(), 1, 'Dec 31 2006 should be week 1');
<ide> assert.equal(moment([2007, 0, 1]).week(), 1, 'Jan 1 2007 should be week 1');
<ide> assert.equal(moment([2007, 0, 6]).week(), 1, 'Jan 6 2007 should be week 1');
<ide> test("weeks year starting monday", function (assert) {
<ide> assert.equal(moment([2007, 0, 14]).week(), 3, 'Jan 14 2007 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting tuesday", function (assert) {
<add>test('weeks year starting tuesday', function (assert) {
<ide> assert.equal(moment([2007, 11, 29]).week(), 52, 'Dec 29 2007 should be week 52');
<ide> assert.equal(moment([2008, 0, 1]).week(), 1, 'Jan 1 2008 should be week 1');
<ide> assert.equal(moment([2008, 0, 5]).week(), 1, 'Jan 5 2008 should be week 1');
<ide> test("weeks year starting tuesday", function (assert) {
<ide> assert.equal(moment([2008, 0, 13]).week(), 3, 'Jan 13 2008 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting wednesday", function (assert) {
<add>test('weeks year starting wednesday', function (assert) {
<ide> assert.equal(moment([2002, 11, 29]).week(), 1, 'Dec 29 2002 should be week 1');
<ide> assert.equal(moment([2003, 0, 1]).week(), 1, 'Jan 1 2003 should be week 1');
<ide> assert.equal(moment([2003, 0, 4]).week(), 1, 'Jan 4 2003 should be week 1');
<ide> test("weeks year starting wednesday", function (assert) {
<ide> assert.equal(moment([2003, 0, 12]).week(), 3, 'Jan 12 2003 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting thursday", function (assert) {
<add>test('weeks year starting thursday', function (assert) {
<ide> assert.equal(moment([2008, 11, 28]).week(), 1, 'Dec 28 2008 should be week 1');
<ide> assert.equal(moment([2009, 0, 1]).week(), 1, 'Jan 1 2009 should be week 1');
<ide> assert.equal(moment([2009, 0, 3]).week(), 1, 'Jan 3 2009 should be week 1');
<ide> test("weeks year starting thursday", function (assert) {
<ide> assert.equal(moment([2009, 0, 11]).week(), 3, 'Jan 11 2009 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting friday", function (assert) {
<add>test('weeks year starting friday', function (assert) {
<ide> assert.equal(moment([2009, 11, 27]).week(), 1, 'Dec 27 2009 should be week 1');
<ide> assert.equal(moment([2010, 0, 1]).week(), 1, 'Jan 1 2010 should be week 1');
<ide> assert.equal(moment([2010, 0, 2]).week(), 1, 'Jan 2 2010 should be week 1');
<ide> test("weeks year starting friday", function (assert) {
<ide> assert.equal(moment([2010, 0, 10]).week(), 3, 'Jan 10 2010 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting saturday", function (assert) {
<add>test('weeks year starting saturday', function (assert) {
<ide> assert.equal(moment([2010, 11, 26]).week(), 1, 'Dec 26 2010 should be week 1');
<ide> assert.equal(moment([2011, 0, 1]).week(), 1, 'Jan 1 2011 should be week 1');
<ide> assert.equal(moment([2011, 0, 2]).week(), 2, 'Jan 2 2011 should be week 2');
<ide> assert.equal(moment([2011, 0, 8]).week(), 2, 'Jan 8 2011 should be week 2');
<ide> assert.equal(moment([2011, 0, 9]).week(), 3, 'Jan 9 2011 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting sunday formatted", function (assert) {
<add>test('weeks year starting sunday formatted', function (assert) {
<ide> assert.equal(moment([2012, 0, 1]).format('w ww wo'), '१ ०१ १', 'Jan 1 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 7]).format('w ww wo'), '१ ०१ १', 'Jan 7 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 8]).format('w ww wo'), '२ ०२ २', 'Jan 8 2012 should be week 2');
<ide> assert.equal(moment([2012, 0, 14]).format('w ww wo'), '२ ०२ २', 'Jan 14 2012 should be week 2');
<ide> assert.equal(moment([2012, 0, 15]).format('w ww wo'), '३ ०३ ३', 'Jan 15 2012 should be week 3');
<ide> });
<ide>
<del>test("lenient ordinal parsing", function (assert) {
<add>test('lenient ordinal parsing', function (assert) {
<ide> var i, ordinalStr, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> ordinalStr = moment([2014, 0, i]).format('YYYY MM Do');
<ide> test("lenient ordinal parsing", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("lenient ordinal parsing of number", function (assert) {
<add>test('lenient ordinal parsing of number', function (assert) {
<ide> var i, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> testMoment = moment('2014 01 ' + i, 'YYYY MM Do');
<ide> test("lenient ordinal parsing of number", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("meridiem invariant", function (assert) {
<add>test('meridiem invariant', function (assert) {
<ide> var h, m, t1, t2;
<ide> for (h = 0; h < 24; ++h) {
<ide> for (m = 0; m < 60; m += 15) {
<ide> test("meridiem invariant", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("strict ordinal parsing", function (assert) {
<add>test('strict ordinal parsing', function (assert) {
<ide> var i, ordinalStr, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> ordinalStr = moment([2014, 0, i]).format('YYYY MM Do');
<ide><path>src/test/locale/ms-my.js
<del>import {localeModule, test} from "../qunit";
<del>import {moment} from "../../moment";
<del>localeModule("ms-my");
<add>import {localeModule, test} from '../qunit';
<add>import {moment} from '../../moment';
<add>localeModule('ms-my');
<ide>
<del>test("parse", function (assert) {
<add>test('parse', function (assert) {
<ide> var i,
<ide> tests = 'Januari Jan_Februari Feb_Mac Mac_April Apr_Mei Mei_Jun Jun_Julai Jul_Ogos Ogs_September Sep_Oktober Okt_November Nov_Disember Dis'.split('_');
<ide>
<ide> test("parse", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("format", function (assert) {
<add>test('format', function (assert) {
<ide> var a = [
<ide> ['dddd, MMMM Do YYYY, h:mm:ss a', 'Ahad, Februari 14 2010, 3:25:50 petang'],
<ide> ['ddd, hA', 'Ahd, 3petang'],
<ide> test("format", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("format ordinal", function (assert) {
<add>test('format ordinal', function (assert) {
<ide> assert.equal(moment([2011, 0, 1]).format('DDDo'), '1', '1');
<ide> assert.equal(moment([2011, 0, 2]).format('DDDo'), '2', '2');
<ide> assert.equal(moment([2011, 0, 3]).format('DDDo'), '3', '3');
<ide> test("format ordinal", function (assert) {
<ide> assert.equal(moment([2011, 0, 31]).format('DDDo'), '31', '31');
<ide> });
<ide>
<del>test("format month", function (assert) {
<add>test('format month', function (assert) {
<ide> var i,
<ide> expected = 'Januari Jan_Februari Feb_Mac Mac_April Apr_Mei Mei_Jun Jun_Julai Jul_Ogos Ogs_September Sep_Oktober Okt_November Nov_Disember Dis'.split('_');
<ide>
<ide> test("format month", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("format week", function (assert) {
<add>test('format week', function (assert) {
<ide> var i,
<ide> expected = 'Ahad Ahd Ah_Isnin Isn Is_Selasa Sel Sl_Rabu Rab Rb_Khamis Kha Km_Jumaat Jum Jm_Sabtu Sab Sb'.split('_');
<ide>
<ide> test("format week", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("from", function (assert) {
<add>test('from', function (assert) {
<ide> var start = moment([2007, 1, 28]);
<ide>
<ide> assert.equal(start.from(moment([2007, 1, 28]).add({s: 44}), true), 'beberapa saat', '44 saat = beberapa saat');
<ide> test("from", function (assert) {
<ide> assert.equal(start.from(moment([2007, 1, 28]).add({y: 5}), true), '5 tahun', '5 tahun = 5 tahun');
<ide> });
<ide>
<del>test("suffix", function (assert) {
<add>test('suffix', function (assert) {
<ide> assert.equal(moment(30000).from(0), 'dalam beberapa saat', 'prefix');
<ide> assert.equal(moment(0).from(30000), 'beberapa saat yang lepas', 'suffix');
<ide> });
<ide>
<del>test("now from now", function (assert) {
<add>test('now from now', function (assert) {
<ide> assert.equal(moment().fromNow(), 'beberapa saat yang lepas', 'waktu sekarang dari sekarang sepatutnya menunjukkan sebagai telah lepas');
<ide> });
<ide>
<del>test("fromNow", function (assert) {
<add>test('fromNow', function (assert) {
<ide> assert.equal(moment().add({s: 30}).fromNow(), 'dalam beberapa saat', 'dalam beberapa saat');
<ide> assert.equal(moment().add({d: 5}).fromNow(), 'dalam 5 hari', 'dalam 5 hari');
<ide> });
<ide>
<del>test("calendar day", function (assert) {
<add>test('calendar day', function (assert) {
<ide> var a = moment().hours(2).minutes(0).seconds(0);
<ide>
<ide> assert.equal(moment(a).calendar(), 'Hari ini pukul 02.00', 'hari ini pada waktu yang sama');
<ide> test("calendar day", function (assert) {
<ide> assert.equal(moment(a).subtract({d: 1}).calendar(), 'Kelmarin pukul 02.00', 'kelmarin pada waktu yang sama');
<ide> });
<ide>
<del>test("calendar next week", function (assert) {
<add>test('calendar next week', function (assert) {
<ide> var i, m;
<ide> for (i = 2; i < 7; i++) {
<ide> m = moment().add({d: i});
<ide> test("calendar next week", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("calendar last week", function (assert) {
<add>test('calendar last week', function (assert) {
<ide> var i, m;
<ide> for (i = 2; i < 7; i++) {
<ide> m = moment().subtract({d: i});
<ide> test("calendar last week", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("calendar all else", function (assert) {
<add>test('calendar all else', function (assert) {
<ide> var weeksAgo = moment().subtract({w: 1}),
<ide> weeksFromNow = moment().add({w: 1});
<ide>
<ide> test("calendar all else", function (assert) {
<ide> assert.equal(weeksFromNow.calendar(), weeksFromNow.format('L'), 'dalam 2 minggu');
<ide> });
<ide>
<del>test("weeks year starting sunday", function (assert) {
<add>test('weeks year starting sunday', function (assert) {
<ide> assert.equal(moment([2012, 0, 1]).week(), 1, 'Jan 1 2012 sepatutnya minggu 1');
<ide> assert.equal(moment([2012, 0, 7]).week(), 2, 'Jan 7 2012 sepatutnya minggu 2');
<ide> assert.equal(moment([2012, 0, 8]).week(), 2, 'Jan 8 2012 sepatutnya minggu 2');
<ide> assert.equal(moment([2012, 0, 14]).week(), 3, 'Jan 14 2012 sepatutnya minggu 3');
<ide> assert.equal(moment([2012, 0, 15]).week(), 3, 'Jan 15 2012 sepatutnya minggu 3');
<ide> });
<ide>
<del>test("weeks year starting monday", function (assert) {
<add>test('weeks year starting monday', function (assert) {
<ide> assert.equal(moment([2006, 11, 31]).week(), 53, 'Dec 31 2006 sepatutnya minggu 53');
<ide> assert.equal(moment([2007, 0, 1]).week(), 1, 'Jan 1 2007 sepatutnya minggu 1');
<ide> assert.equal(moment([2007, 0, 6]).week(), 1, 'Jan 6 2007 sepatutnya minggu 1');
<ide> test("weeks year starting monday", function (assert) {
<ide> assert.equal(moment([2007, 0, 14]).week(), 2, 'Jan 14 2007 sepatutnya minggu 2');
<ide> });
<ide>
<del>test("weeks year starting tuesday", function (assert) {
<add>test('weeks year starting tuesday', function (assert) {
<ide> assert.equal(moment([2007, 11, 30]).week(), 52, 'Dec 30 2007 sepatutnya minggu 52');
<ide> assert.equal(moment([2008, 0, 1]).week(), 1, 'Jan 1 2008 sepatutnya minggu 1');
<ide> assert.equal(moment([2008, 0, 5]).week(), 1, 'Jan 5 2008 sepatutnya minggu 1');
<ide> test("weeks year starting tuesday", function (assert) {
<ide> assert.equal(moment([2008, 0, 13]).week(), 2, 'Jan 13 2008 sepatutnya minggu 2');
<ide> });
<ide>
<del>test("weeks year starting wednesday", function (assert) {
<add>test('weeks year starting wednesday', function (assert) {
<ide> assert.equal(moment([2002, 11, 29]).week(), 52, 'Dec 29 2002 sepatutnya minggu 52');
<ide> assert.equal(moment([2003, 0, 1]).week(), 1, 'Jan 1 2003 sepatutnya minggu 1');
<ide> assert.equal(moment([2003, 0, 4]).week(), 1, 'Jan 4 2003 sepatutnya minggu 1');
<ide> test("weeks year starting wednesday", function (assert) {
<ide> assert.equal(moment([2003, 0, 12]).week(), 2, 'Jan 12 2003 sepatutnya minggu 2');
<ide> });
<ide>
<del>test("weeks year starting thursday", function (assert) {
<add>test('weeks year starting thursday', function (assert) {
<ide> assert.equal(moment([2008, 11, 28]).week(), 52, 'Dec 28 2008 sepatutnya minggu 52');
<ide> assert.equal(moment([2009, 0, 1]).week(), 1, 'Jan 1 2009 sepatutnya minggu 1');
<ide> assert.equal(moment([2009, 0, 3]).week(), 1, 'Jan 3 2009 sepatutnya minggu 1');
<ide> test("weeks year starting thursday", function (assert) {
<ide> assert.equal(moment([2009, 0, 11]).week(), 2, 'Jan 11 2009 sepatutnya minggu 2');
<ide> });
<ide>
<del>test("weeks year starting friday", function (assert) {
<add>test('weeks year starting friday', function (assert) {
<ide> assert.equal(moment([2009, 11, 27]).week(), 52, 'Dec 27 2009 sepatutnya minggu 52');
<ide> assert.equal(moment([2010, 0, 1]).week(), 1, 'Jan 1 2010 sepatutnya minggu 1');
<ide> assert.equal(moment([2010, 0, 2]).week(), 1, 'Jan 2 2010 sepatutnya minggu 1');
<ide> test("weeks year starting friday", function (assert) {
<ide> assert.equal(moment([2010, 0, 10]).week(), 2, 'Jan 10 2010 sepatutnya minggu 2');
<ide> });
<ide>
<del>test("weeks year starting saturday", function (assert) {
<add>test('weeks year starting saturday', function (assert) {
<ide> assert.equal(moment([2010, 11, 26]).week(), 52, 'Dec 26 2010 sepatutnya minggu 52');
<ide> assert.equal(moment([2011, 0, 1]).week(), 1, 'Jan 1 2011 sepatutnya minggu 1');
<ide> assert.equal(moment([2011, 0, 2]).week(), 1, 'Jan 2 2011 sepatutnya minggu 1');
<ide> assert.equal(moment([2011, 0, 8]).week(), 2, 'Jan 8 2011 sepatutnya minggu 2');
<ide> assert.equal(moment([2011, 0, 9]).week(), 2, 'Jan 9 2011 sepatutnya minggu 2');
<ide> });
<ide>
<del>test("weeks year starting sunday format", function (assert) {
<add>test('weeks year starting sunday format', function (assert) {
<ide> assert.equal(moment([2012, 0, 1]).format('w ww wo'), '1 01 1', 'Jan 1 2012 sepatutnya minggu 1');
<ide> assert.equal(moment([2012, 0, 7]).format('w ww wo'), '2 02 2', 'Jan 7 2012 sepatutnya minggu 2');
<ide> assert.equal(moment([2012, 0, 8]).format('w ww wo'), '2 02 2', 'Jan 8 2012 sepatutnya minggu 2');
<ide> assert.equal(moment([2012, 0, 14]).format('w ww wo'), '3 03 3', 'Jan 14 2012 sepatutnya minggu 3');
<ide> assert.equal(moment([2012, 0, 15]).format('w ww wo'), '3 03 3', 'Jan 15 2012 sepatutnya minggu 3');
<ide> });
<ide>
<del>test("lenient ordinal parsing", function (assert) {
<add>test('lenient ordinal parsing', function (assert) {
<ide> var i, ordinalStr, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> ordinalStr = moment([2014, 0, i]).format('YYYY MM Do');
<ide> test("lenient ordinal parsing", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("meridiem invariant", function (assert) {
<add>test('meridiem invariant', function (assert) {
<ide> var h, m, t1, t2;
<ide> for (h = 0; h < 24; ++h) {
<ide> for (m = 0; m < 60; m += 15) {
<ide> test("meridiem invariant", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("lenient ordinal parsing of number", function (assert) {
<add>test('lenient ordinal parsing of number', function (assert) {
<ide> var i, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> testMoment = moment('2014 01 ' + i, 'YYYY MM Do');
<ide> test("lenient ordinal parsing of number", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("strict ordinal parsing", function (assert) {
<add>test('strict ordinal parsing', function (assert) {
<ide> var i, ordinalStr, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> ordinalStr = moment([2014, 0, i]).format('YYYY MM Do');
<ide><path>src/test/locale/my.js
<del>import {localeModule, test} from "../qunit";
<del>import {moment} from "../../moment";
<del>localeModule("my");
<add>import {localeModule, test} from '../qunit';
<add>import {moment} from '../../moment';
<add>localeModule('my');
<ide>
<del>test("parse", function (assert) {
<add>test('parse', function (assert) {
<ide> var tests = 'ဇန်နဝါရီ ဇန်_ဖေဖော်ဝါရီ ဖေ_မတ် မတ်_ဧပြီ ပြီ_မေ မေ_ဇွန် ဇွန်_ဇူလိုင် လိုင်_သြဂုတ် သြ_စက်တင်ဘာ စက်_အောက်တိုဘာ အောက်_နိုဝင်ဘာ နို_ဒီဇင်ဘာ ဒီ'.split('_'),
<ide> i;
<ide>
<ide> test("parse", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("format", function (assert) {
<add>test('format', function (assert) {
<ide> var a = [
<ide> ['dddd, MMMM Do YYYY, h:mm:ss a', 'တနင်္ဂနွေ, ဖေဖော်ဝါရီ ၁၄ ၂၀၁၀, ၃:၂၅:၅၀ pm'],
<ide> ['ddd, hA', 'နွေ, ၃PM'],
<ide> test("format", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("format ordinal", function (assert) {
<add>test('format ordinal', function (assert) {
<ide> assert.equal(moment([2011, 0, 1]).format('DDDo'), '၁', '၁');
<ide> assert.equal(moment([2011, 0, 2]).format('DDDo'), '၂', '၂');
<ide> assert.equal(moment([2011, 0, 3]).format('DDDo'), '၃', '၃');
<ide> test("format ordinal", function (assert) {
<ide> assert.equal(moment([2011, 0, 31]).format('DDDo'), '၃၁', '၃၁');
<ide> });
<ide>
<del>test("format month", function (assert) {
<add>test('format month', function (assert) {
<ide> var expected = 'ဇန်နဝါရီ ဇန်_ဖေဖော်ဝါရီ ဖေ_မတ် မတ်_ဧပြီ ပြီ_မေ မေ_ဇွန် ဇွန်_ဇူလိုင် လိုင်_သြဂုတ် သြ_စက်တင်ဘာ စက်_အောက်တိုဘာ အောက်_နိုဝင်ဘာ နို_ဒီဇင်ဘာ ဒီ'.split('_'),
<ide> i;
<ide> for (i = 0; i < expected.length; i++) {
<ide> assert.equal(moment([2011, i, 1]).format('MMMM MMM'), expected[i], expected[i]);
<ide> }
<ide> });
<ide>
<del>test("format week", function (assert) {
<add>test('format week', function (assert) {
<ide> var expected = 'တနင်္ဂနွေ နွေ နွေ_တနင်္လာ လာ လာ_အင်္ဂါ င်္ဂါ င်္ဂါ_ဗုဒ္ဓဟူး ဟူး ဟူး_ကြာသပတေး ကြာ ကြာ_သောကြာ သော သော_စနေ နေ နေ'.split('_'),
<ide> i;
<ide>
<ide> test("format week", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("from", function (assert) {
<add>test('from', function (assert) {
<ide> var start = moment([2007, 1, 28]);
<ide> assert.equal(start.from(moment([2007, 1, 28]).add({
<ide> s: 44
<ide> test("from", function (assert) {
<ide> }), true), '၅ နှစ်', '၅ နှစ် = ၅ နှစ်');
<ide> });
<ide>
<del>test("suffix", function (assert) {
<add>test('suffix', function (assert) {
<ide> assert.equal(moment(30000).from(0), 'လာမည့် စက္ကန်.အနည်းငယ် မှာ', 'prefix');
<ide> assert.equal(moment(0).from(30000), 'လွန်ခဲ့သော စက္ကန်.အနည်းငယ် က', 'suffix');
<ide> });
<ide>
<del>test("now from now", function (assert) {
<add>test('now from now', function (assert) {
<ide> assert.equal(moment().fromNow(), 'လွန်ခဲ့သော စက္ကန်.အနည်းငယ် က', 'ယခုမှစပြီး အတိတ်တွင်ဖော်ပြသလိုဖော်ပြမည်');
<ide> });
<ide>
<del>test("fromNow", function (assert) {
<add>test('fromNow', function (assert) {
<ide> assert.equal(moment().add({
<ide> s: 30
<ide> }).fromNow(), 'လာမည့် စက္ကန်.အနည်းငယ် မှာ', 'လာမည့် စက္ကန်.အနည်းငယ် မှာ');
<ide> test("fromNow", function (assert) {
<ide> }).fromNow(), 'လာမည့် ၅ ရက် မှာ', 'လာမည့် ၅ ရက် မှာ');
<ide> });
<ide>
<del>test("calendar day", function (assert) {
<add>test('calendar day', function (assert) {
<ide> var a = moment().hours(2).minutes(0).seconds(0);
<ide>
<ide> assert.equal(moment(a).calendar(), 'ယနေ. ၀၂:၀၀ မှာ', 'ယနေ. ဒီအချိန်');
<ide> test("calendar day", function (assert) {
<ide> }).calendar(), 'မနေ.က ၀၂:၀၀ မှာ', 'မနေ.က ဒီအချိန်');
<ide> });
<ide>
<del>test("calendar next week", function (assert) {
<add>test('calendar next week', function (assert) {
<ide> var i, m;
<ide> for (i = 2; i < 7; i++) {
<ide> m = moment().add({
<ide> test("calendar next week", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("calendar last week", function (assert) {
<add>test('calendar last week', function (assert) {
<ide> var i, m;
<ide>
<ide> for (i = 2; i < 7; i++) {
<ide> test("calendar last week", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("calendar all else", function (assert) {
<add>test('calendar all else', function (assert) {
<ide> var weeksAgo = moment().subtract({
<ide> w: 1
<ide> }),
<ide> test("calendar all else", function (assert) {
<ide> assert.equal(weeksFromNow.calendar(), weeksFromNow.format('L'), '၂ ပတ် အတွင်း');
<ide> });
<ide>
<del>test("weeks year starting sunday", function (assert) {
<add>test('weeks year starting sunday', function (assert) {
<ide> assert.equal(moment([2012, 0, 1]).week(), 52, 'Jan 1 2012 should be week 52');
<ide> assert.equal(moment([2012, 0, 2]).week(), 1, 'Jan 2 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 8]).week(), 1, 'Jan 8 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 9]).week(), 2, 'Jan 9 2012 should be week 2');
<ide> assert.equal(moment([2012, 0, 15]).week(), 2, 'Jan 15 2012 should be week 2');
<ide> });
<ide>
<del>test("weeks year starting monday", function (assert) {
<add>test('weeks year starting monday', function (assert) {
<ide> assert.equal(moment([2007, 0, 1]).week(), 1, 'Jan 1 2007 should be week 1');
<ide> assert.equal(moment([2007, 0, 7]).week(), 1, 'Jan 7 2007 should be week 1');
<ide> assert.equal(moment([2007, 0, 8]).week(), 2, 'Jan 8 2007 should be week 2');
<ide> assert.equal(moment([2007, 0, 14]).week(), 2, 'Jan 14 2007 should be week 2');
<ide> assert.equal(moment([2007, 0, 15]).week(), 3, 'Jan 15 2007 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting tuesday", function (assert) {
<add>test('weeks year starting tuesday', function (assert) {
<ide> assert.equal(moment([2007, 11, 31]).week(), 1, 'Dec 31 2007 should be week 1');
<ide> assert.equal(moment([2008, 0, 1]).week(), 1, 'Jan 1 2008 should be week 1');
<ide> assert.equal(moment([2008, 0, 6]).week(), 1, 'Jan 6 2008 should be week 1');
<ide> test("weeks year starting tuesday", function (assert) {
<ide> assert.equal(moment([2008, 0, 14]).week(), 3, 'Jan 14 2008 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting wednesday", function (assert) {
<add>test('weeks year starting wednesday', function (assert) {
<ide> assert.equal(moment([2002, 11, 30]).week(), 1, 'Dec 30 2002 should be week 1');
<ide> assert.equal(moment([2003, 0, 1]).week(), 1, 'Jan 1 2003 should be week 1');
<ide> assert.equal(moment([2003, 0, 5]).week(), 1, 'Jan 5 2003 should be week 1');
<ide> test("weeks year starting wednesday", function (assert) {
<ide> assert.equal(moment([2003, 0, 13]).week(), 3, 'Jan 13 2003 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting thursday", function (assert) {
<add>test('weeks year starting thursday', function (assert) {
<ide> assert.equal(moment([2008, 11, 29]).week(), 1, 'Dec 29 2008 should be week 1');
<ide> assert.equal(moment([2009, 0, 1]).week(), 1, 'Jan 1 2009 should be week 1');
<ide> assert.equal(moment([2009, 0, 4]).week(), 1, 'Jan 4 2009 should be week 1');
<ide> test("weeks year starting thursday", function (assert) {
<ide> assert.equal(moment([2009, 0, 13]).week(), 3, 'Jan 12 2009 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting friday", function (assert) {
<add>test('weeks year starting friday', function (assert) {
<ide> assert.equal(moment([2009, 11, 28]).week(), 53, 'Dec 28 2009 should be week 53');
<ide> assert.equal(moment([2010, 0, 1]).week(), 53, 'Jan 1 2010 should be week 53');
<ide> assert.equal(moment([2010, 0, 3]).week(), 53, 'Jan 3 2010 should be week 53');
<ide> test("weeks year starting friday", function (assert) {
<ide> assert.equal(moment([2010, 0, 11]).week(), 2, 'Jan 11 2010 should be week 2');
<ide> });
<ide>
<del>test("weeks year starting saturday", function (assert) {
<add>test('weeks year starting saturday', function (assert) {
<ide> assert.equal(moment([2010, 11, 27]).week(), 52, 'Dec 27 2010 should be week 52');
<ide> assert.equal(moment([2011, 0, 1]).week(), 52, 'Jan 1 2011 should be week 52');
<ide> assert.equal(moment([2011, 0, 2]).week(), 52, 'Jan 2 2011 should be week 52');
<ide> test("weeks year starting saturday", function (assert) {
<ide> assert.equal(moment([2011, 0, 10]).week(), 2, 'Jan 10 2011 should be week 2');
<ide> });
<ide>
<del>test("weeks year starting sunday formatted", function (assert) {
<add>test('weeks year starting sunday formatted', function (assert) {
<ide> assert.equal(moment([2012, 0, 1]).format('w ww wo'), '၅၂ ၅၂ ၅၂', 'Jan 1 2012 should be week 52');
<ide> assert.equal(moment([2012, 0, 2]).format('w ww wo'), '၁ ၀၁ ၁', 'Jan 2 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 8]).format('w ww wo'), '၁ ၀၁ ၁', 'Jan 8 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 9]).format('w ww wo'), '၂ ၀၂ ၂', 'Jan 9 2012 should be week 2');
<ide> assert.equal(moment([2012, 0, 15]).format('w ww wo'), '၂ ၀၂ ၂', 'Jan 15 2012 should be week 2');
<ide> });
<ide>
<del>test("lenient ordinal parsing", function (assert) {
<add>test('lenient ordinal parsing', function (assert) {
<ide> var i, ordinalStr, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> ordinalStr = moment([2014, 0, i]).format('YYYY MM Do');
<ide> test("lenient ordinal parsing", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("lenient ordinal parsing of number", function (assert) {
<add>test('lenient ordinal parsing of number', function (assert) {
<ide> var i, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> testMoment = moment('2014 01 ' + i, 'YYYY MM Do');
<ide> test("lenient ordinal parsing of number", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("strict ordinal parsing", function (assert) {
<add>test('strict ordinal parsing', function (assert) {
<ide> var i, ordinalStr, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> ordinalStr = moment([2014, 0, i]).format('YYYY MM Do');
<ide><path>src/test/locale/nb.js
<del>import {localeModule, test} from "../qunit";
<del>import {moment} from "../../moment";
<del>localeModule("nb");
<add>import {localeModule, test} from '../qunit';
<add>import {moment} from '../../moment';
<add>localeModule('nb');
<ide>
<del>test("parse", function (assert) {
<add>test('parse', function (assert) {
<ide> var tests = 'januar jan_februar feb_mars mar_april apr_mai mai_juni jun_juli jul_august aug_september sep_oktober okt_november nov_desember des'.split('_'),
<ide> i;
<ide> function equalTest(input, mmm, i) {
<ide> test("parse", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("format", function (assert) {
<add>test('format', function (assert) {
<ide> var a = [
<ide> ['dddd, MMMM Do YYYY, h:mm:ss a', 'søndag, februar 14. 2010, 3:25:50 pm'],
<ide> ['ddd, hA', 'søn, 3PM'],
<ide> test("format", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("format ordinal", function (assert) {
<add>test('format ordinal', function (assert) {
<ide> assert.equal(moment([2011, 0, 1]).format('DDDo'), '1.', '1.');
<ide> assert.equal(moment([2011, 0, 2]).format('DDDo'), '2.', '2.');
<ide> assert.equal(moment([2011, 0, 3]).format('DDDo'), '3.', '3.');
<ide> test("format ordinal", function (assert) {
<ide> assert.equal(moment([2011, 0, 31]).format('DDDo'), '31.', '31.');
<ide> });
<ide>
<del>test("format month", function (assert) {
<add>test('format month', function (assert) {
<ide> var expected = 'januar jan_februar feb_mars mar_april apr_mai mai_juni jun_juli jul_august aug_september sep_oktober okt_november nov_desember des'.split('_'), i;
<ide> for (i = 0; i < expected.length; i++) {
<ide> assert.equal(moment([2011, i, 1]).format('MMMM MMM'), expected[i], expected[i]);
<ide> }
<ide> });
<ide>
<del>test("format week", function (assert) {
<add>test('format week', function (assert) {
<ide> var expected = 'søndag søn sø_mandag man ma_tirsdag tirs ti_onsdag ons on_torsdag tors to_fredag fre fr_lørdag lør lø'.split('_'), i;
<ide> for (i = 0; i < expected.length; i++) {
<ide> assert.equal(moment([2011, 0, 2 + i]).format('dddd ddd dd'), expected[i], expected[i]);
<ide> }
<ide> });
<ide>
<del>test("from", function (assert) {
<add>test('from', function (assert) {
<ide> var start = moment([2007, 1, 28]);
<ide> assert.equal(start.from(moment([2007, 1, 28]).add({s: 44}), true), 'noen sekunder', '44 sekunder = a few seconds');
<ide> assert.equal(start.from(moment([2007, 1, 28]).add({s: 45}), true), 'ett minutt', '45 seconds = a minute');
<ide> test("from", function (assert) {
<ide> assert.equal(start.from(moment([2007, 1, 28]).add({y: 5}), true), '5 år', '5 years = 5 years');
<ide> });
<ide>
<del>test("suffix", function (assert) {
<add>test('suffix', function (assert) {
<ide> assert.equal(moment(30000).from(0), 'om noen sekunder', 'prefix');
<ide> assert.equal(moment(0).from(30000), 'for noen sekunder siden', 'suffix');
<ide> });
<ide>
<del>test("now from now", function (assert) {
<add>test('now from now', function (assert) {
<ide> assert.equal(moment().fromNow(), 'for noen sekunder siden', 'now from now should display as in the past');
<ide> });
<ide>
<del>test("fromNow", function (assert) {
<add>test('fromNow', function (assert) {
<ide> assert.equal(moment().add({s: 30}).fromNow(), 'om noen sekunder', 'in a few seconds');
<ide> assert.equal(moment().add({d: 5}).fromNow(), 'om 5 dager', 'in 5 days');
<ide> });
<ide>
<del>test("calendar day", function (assert) {
<add>test('calendar day', function (assert) {
<ide> var a = moment().hours(2).minutes(0).seconds(0);
<ide>
<ide> assert.equal(moment(a).calendar(), 'i dag kl. 2.00', 'today at the same time');
<ide> test("calendar day", function (assert) {
<ide> assert.equal(moment(a).subtract({d: 1}).calendar(), 'i går kl. 2.00', 'yesterday at the same time');
<ide> });
<ide>
<del>test("calendar next week", function (assert) {
<add>test('calendar next week', function (assert) {
<ide> var i, m;
<ide> for (i = 2; i < 7; i++) {
<ide> m = moment().add({d: i});
<ide> test("calendar next week", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("calendar last week", function (assert) {
<add>test('calendar last week', function (assert) {
<ide> var i, m;
<ide> for (i = 2; i < 7; i++) {
<ide> m = moment().subtract({d: i});
<ide> test("calendar last week", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("calendar all else", function (assert) {
<add>test('calendar all else', function (assert) {
<ide> var weeksAgo = moment().subtract({w: 1}),
<ide> weeksFromNow = moment().add({w: 1});
<ide>
<ide> test("calendar all else", function (assert) {
<ide> assert.equal(weeksFromNow.calendar(), weeksFromNow.format('L'), 'in 2 weeks');
<ide> });
<ide>
<del>test("weeks year starting sunday", function (assert) {
<add>test('weeks year starting sunday', function (assert) {
<ide> assert.equal(moment([2012, 0, 1]).week(), 52, 'Jan 1 2012 should be week 52');
<ide> assert.equal(moment([2012, 0, 2]).week(), 1, 'Jan 2 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 8]).week(), 1, 'Jan 8 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 9]).week(), 2, 'Jan 9 2012 should be week 2');
<ide> assert.equal(moment([2012, 0, 15]).week(), 2, 'Jan 15 2012 should be week 2');
<ide> });
<ide>
<del>test("weeks year starting monday", function (assert) {
<add>test('weeks year starting monday', function (assert) {
<ide> assert.equal(moment([2007, 0, 1]).week(), 1, 'Jan 1 2007 should be week 1');
<ide> assert.equal(moment([2007, 0, 7]).week(), 1, 'Jan 7 2007 should be week 1');
<ide> assert.equal(moment([2007, 0, 8]).week(), 2, 'Jan 8 2007 should be week 2');
<ide> assert.equal(moment([2007, 0, 14]).week(), 2, 'Jan 14 2007 should be week 2');
<ide> assert.equal(moment([2007, 0, 15]).week(), 3, 'Jan 15 2007 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting tuesday", function (assert) {
<add>test('weeks year starting tuesday', function (assert) {
<ide> assert.equal(moment([2007, 11, 31]).week(), 1, 'Dec 31 2007 should be week 1');
<ide> assert.equal(moment([2008, 0, 1]).week(), 1, 'Jan 1 2008 should be week 1');
<ide> assert.equal(moment([2008, 0, 6]).week(), 1, 'Jan 6 2008 should be week 1');
<ide> test("weeks year starting tuesday", function (assert) {
<ide> assert.equal(moment([2008, 0, 14]).week(), 3, 'Jan 14 2008 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting wednesday", function (assert) {
<add>test('weeks year starting wednesday', function (assert) {
<ide> assert.equal(moment([2002, 11, 30]).week(), 1, 'Dec 30 2002 should be week 1');
<ide> assert.equal(moment([2003, 0, 1]).week(), 1, 'Jan 1 2003 should be week 1');
<ide> assert.equal(moment([2003, 0, 5]).week(), 1, 'Jan 5 2003 should be week 1');
<ide> test("weeks year starting wednesday", function (assert) {
<ide> assert.equal(moment([2003, 0, 13]).week(), 3, 'Jan 13 2003 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting thursday", function (assert) {
<add>test('weeks year starting thursday', function (assert) {
<ide> assert.equal(moment([2008, 11, 29]).week(), 1, 'Dec 29 2008 should be week 1');
<ide> assert.equal(moment([2009, 0, 1]).week(), 1, 'Jan 1 2009 should be week 1');
<ide> assert.equal(moment([2009, 0, 4]).week(), 1, 'Jan 4 2009 should be week 1');
<ide> test("weeks year starting thursday", function (assert) {
<ide> assert.equal(moment([2009, 0, 13]).week(), 3, 'Jan 12 2009 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting friday", function (assert) {
<add>test('weeks year starting friday', function (assert) {
<ide> assert.equal(moment([2009, 11, 28]).week(), 53, 'Dec 28 2009 should be week 53');
<ide> assert.equal(moment([2010, 0, 1]).week(), 53, 'Jan 1 2010 should be week 53');
<ide> assert.equal(moment([2010, 0, 3]).week(), 53, 'Jan 3 2010 should be week 53');
<ide> test("weeks year starting friday", function (assert) {
<ide> assert.equal(moment([2010, 0, 11]).week(), 2, 'Jan 11 2010 should be week 2');
<ide> });
<ide>
<del>test("weeks year starting saturday", function (assert) {
<add>test('weeks year starting saturday', function (assert) {
<ide> assert.equal(moment([2010, 11, 27]).week(), 52, 'Dec 27 2010 should be week 52');
<ide> assert.equal(moment([2011, 0, 1]).week(), 52, 'Jan 1 2011 should be week 52');
<ide> assert.equal(moment([2011, 0, 2]).week(), 52, 'Jan 2 2011 should be week 52');
<ide> test("weeks year starting saturday", function (assert) {
<ide> assert.equal(moment([2011, 0, 10]).week(), 2, 'Jan 10 2011 should be week 2');
<ide> });
<ide>
<del>test("weeks year starting sunday formatted", function (assert) {
<add>test('weeks year starting sunday formatted', function (assert) {
<ide> assert.equal(moment([2012, 0, 1]).format('w ww wo'), '52 52 52.', 'Jan 1 2012 should be week 52');
<ide> assert.equal(moment([2012, 0, 2]).format('w ww wo'), '1 01 1.', 'Jan 2 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 8]).format('w ww wo'), '1 01 1.', 'Jan 8 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 9]).format('w ww wo'), '2 02 2.', 'Jan 9 2012 should be week 2');
<ide> assert.equal(moment([2012, 0, 15]).format('w ww wo'), '2 02 2.', 'Jan 15 2012 should be week 2');
<ide> });
<ide>
<del>test("lenient ordinal parsing", function (assert) {
<add>test('lenient ordinal parsing', function (assert) {
<ide> var i, ordinalStr, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> ordinalStr = moment([2014, 0, i]).format('YYYY MM Do');
<ide> test("lenient ordinal parsing", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("lenient ordinal parsing of number", function (assert) {
<add>test('lenient ordinal parsing of number', function (assert) {
<ide> var i, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> testMoment = moment('2014 01 ' + i, 'YYYY MM Do');
<ide> test("lenient ordinal parsing of number", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("strict ordinal parsing", function (assert) {
<add>test('strict ordinal parsing', function (assert) {
<ide> var i, ordinalStr, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> ordinalStr = moment([2014, 0, i]).format('YYYY MM Do');
<ide><path>src/test/locale/ne.js
<del>import {localeModule, test} from "../qunit";
<del>import {moment} from "../../moment";
<del>localeModule("ne");
<add>import {localeModule, test} from '../qunit';
<add>import {moment} from '../../moment';
<add>localeModule('ne');
<ide>
<del>test("parse", function (assert) {
<add>test('parse', function (assert) {
<ide> var tests = 'जनवरी जन._फेब्रुवरी फेब्रु._मार्च मार्च_अप्रिल अप्रि._मई मई_जुन जुन_जुलाई जुलाई._अगष्ट अग._सेप्टेम्बर सेप्ट._अक्टोबर अक्टो._नोभेम्बर नोभे._डिसेम्बर डिसे.'.split('_'), i;
<ide> function equalTest(input, mmm, i) {
<ide> assert.equal(moment(input, mmm).month(), i, input + ' should be month ' + (i + 1));
<ide> test("parse", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("format", function (assert) {
<add>test('format', function (assert) {
<ide> var a = [
<ide> ['dddd, Do MMMM YYYY, aको h:mm:ss बजे', 'आइतबार, १४ फेब्रुवरी २०१०, बेलुकाको ३:२५:५० बजे'],
<ide> ['ddd, aको h बजे', 'आइत., बेलुकाको ३ बजे'],
<ide> test("format", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("format ordinal", function (assert) {
<add>test('format ordinal', function (assert) {
<ide> assert.equal(moment([2011, 0, 1]).format('DDDo'), '१', '१');
<ide> assert.equal(moment([2011, 0, 2]).format('DDDo'), '२', '२');
<ide> assert.equal(moment([2011, 0, 3]).format('DDDo'), '३', '३');
<ide> test("format ordinal", function (assert) {
<ide> assert.equal(moment([2011, 0, 31]).format('DDDo'), '३१', '३१');
<ide> });
<ide>
<del>test("format month", function (assert) {
<add>test('format month', function (assert) {
<ide> var expected = 'जनवरी जन._फेब्रुवरी फेब्रु._मार्च मार्च_अप्रिल अप्रि._मई मई_जुन जुन_जुलाई जुलाई._अगष्ट अग._सेप्टेम्बर सेप्ट._अक्टोबर अक्टो._नोभेम्बर नोभे._डिसेम्बर डिसे.'.split('_'), i;
<ide> for (i = 0; i < expected.length; i++) {
<ide> assert.equal(moment([2011, i, 1]).format('MMMM MMM'), expected[i], expected[i]);
<ide> }
<ide> });
<ide>
<del>test("format week", function (assert) {
<add>test('format week', function (assert) {
<ide> var expected = 'आइतबार आइत. आइ._सोमबार सोम. सो._मङ्गलबार मङ्गल. मङ्_बुधबार बुध. बु._बिहिबार बिहि. बि._शुक्रबार शुक्र. शु._शनिबार शनि. श.'.split('_'), i;
<ide> for (i = 0; i < expected.length; i++) {
<ide> assert.equal(moment([2011, 0, 2 + i]).format('dddd ddd dd'), expected[i], expected[i]);
<ide> }
<ide> });
<ide>
<del>test("from", function (assert) {
<add>test('from', function (assert) {
<ide> var start = moment([2007, 1, 28]);
<ide> assert.equal(start.from(moment([2007, 1, 28]).add({s: 44}), true), 'केही समय', '44 seconds = a few seconds');
<ide> assert.equal(start.from(moment([2007, 1, 28]).add({s: 45}), true), 'एक मिनेट', '45 seconds = a minute');
<ide> test("from", function (assert) {
<ide> assert.equal(start.from(moment([2007, 1, 28]).add({y: 5}), true), '५ बर्ष', '5 years = 5 years');
<ide> });
<ide>
<del>test("suffix", function (assert) {
<add>test('suffix', function (assert) {
<ide> assert.equal(moment(30000).from(0), 'केही समयमा', 'prefix');
<ide> assert.equal(moment(0).from(30000), 'केही समय अगाडी', 'suffix');
<ide> });
<ide>
<del>test("now from now", function (assert) {
<add>test('now from now', function (assert) {
<ide> assert.equal(moment().fromNow(), 'केही समय अगाडी', 'now from now should display as in the past');
<ide> });
<ide>
<del>test("fromNow", function (assert) {
<add>test('fromNow', function (assert) {
<ide> assert.equal(moment().add({s: 30}).fromNow(), 'केही समयमा', 'केही समयमा');
<ide> assert.equal(moment().add({d: 5}).fromNow(), '५ दिनमा', '५ दिनमा');
<ide> });
<ide>
<del>test("calendar day", function (assert) {
<add>test('calendar day', function (assert) {
<ide> var a = moment().hours(2).minutes(0).seconds(0);
<ide>
<ide> assert.equal(moment(a).calendar(), 'आज रातीको २:०० बजे', 'today at the same time');
<ide> test("calendar day", function (assert) {
<ide> assert.equal(moment(a).subtract({d: 1}).calendar(), 'हिजो रातीको २:०० बजे', 'yesterday at the same time');
<ide> });
<ide>
<del>test("calendar next week", function (assert) {
<add>test('calendar next week', function (assert) {
<ide> var i, m;
<ide> for (i = 2; i < 7; i++) {
<ide> m = moment().add({d: i});
<ide> test("calendar next week", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("calendar last week", function (assert) {
<add>test('calendar last week', function (assert) {
<ide> var i, m;
<ide> for (i = 2; i < 7; i++) {
<ide> m = moment().subtract({d: i});
<ide> test("calendar last week", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("calendar all else", function (assert) {
<add>test('calendar all else', function (assert) {
<ide> var weeksAgo = moment().subtract({w: 1}),
<ide> weeksFromNow = moment().add({w: 1});
<ide>
<ide> test("calendar all else", function (assert) {
<ide> assert.equal(weeksFromNow.calendar(), weeksFromNow.format('L'), 'in 2 weeks');
<ide> });
<ide>
<del>test("meridiem", function (assert) {
<add>test('meridiem', function (assert) {
<ide> assert.equal(moment([2011, 2, 23, 2, 30]).format('a'), 'राती', 'before dawn');
<ide> assert.equal(moment([2011, 2, 23, 9, 30]).format('a'), 'बिहान', 'morning');
<ide> assert.equal(moment([2011, 2, 23, 14, 30]).format('a'), 'दिउँसो', 'during day');
<ide> test("meridiem", function (assert) {
<ide> assert.equal(moment([2011, 2, 23, 21, 20]).format('A'), 'राती', 'night');
<ide> });
<ide>
<del>test("weeks year starting sunday", function (assert) {
<add>test('weeks year starting sunday', function (assert) {
<ide> assert.equal(moment([2011, 11, 26]).week(), 1, 'Dec 26 2011 should be week 1');
<ide> assert.equal(moment([2012, 0, 1]).week(), 1, 'Jan 1 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 2]).week(), 2, 'Jan 2 2012 should be week 2');
<ide> assert.equal(moment([2012, 0, 8]).week(), 2, 'Jan 8 2012 should be week 2');
<ide> assert.equal(moment([2012, 0, 9]).week(), 3, 'Jan 9 2012 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting monday", function (assert) {
<add>test('weeks year starting monday', function (assert) {
<ide> assert.equal(moment([2007, 0, 1]).week(), 1, 'Jan 1 2007 should be week 1');
<ide> assert.equal(moment([2007, 0, 7]).week(), 1, 'Jan 7 2007 should be week 1');
<ide> assert.equal(moment([2007, 0, 8]).week(), 2, 'Jan 8 2007 should be week 2');
<ide> assert.equal(moment([2007, 0, 14]).week(), 2, 'Jan 14 2007 should be week 2');
<ide> assert.equal(moment([2007, 0, 15]).week(), 3, 'Jan 15 2007 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting tuesday", function (assert) {
<add>test('weeks year starting tuesday', function (assert) {
<ide> assert.equal(moment([2007, 11, 31]).week(), 1, 'Dec 31 2007 should be week 1');
<ide> assert.equal(moment([2008, 0, 1]).week(), 1, 'Jan 1 2008 should be week 1');
<ide> assert.equal(moment([2008, 0, 6]).week(), 1, 'Jan 6 2008 should be week 1');
<ide> test("weeks year starting tuesday", function (assert) {
<ide> assert.equal(moment([2008, 0, 14]).week(), 3, 'Jan 14 2008 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting wednesday", function (assert) {
<add>test('weeks year starting wednesday', function (assert) {
<ide> assert.equal(moment([2002, 11, 30]).week(), 1, 'Dec 30 2002 should be week 1');
<ide> assert.equal(moment([2003, 0, 1]).week(), 1, 'Jan 1 2003 should be week 1');
<ide> assert.equal(moment([2003, 0, 5]).week(), 1, 'Jan 5 2003 should be week 1');
<ide> test("weeks year starting wednesday", function (assert) {
<ide> assert.equal(moment([2003, 0, 13]).week(), 3, 'Jan 13 2003 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting thursday", function (assert) {
<add>test('weeks year starting thursday', function (assert) {
<ide> assert.equal(moment([2008, 11, 29]).week(), 1, 'Dec 29 2008 should be week 1');
<ide> assert.equal(moment([2009, 0, 1]).week(), 1, 'Jan 1 2009 should be week 1');
<ide> assert.equal(moment([2009, 0, 4]).week(), 1, 'Jan 4 2009 should be week 1');
<ide> test("weeks year starting thursday", function (assert) {
<ide> assert.equal(moment([2009, 0, 12]).week(), 3, 'Jan 12 2009 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting friday", function (assert) {
<add>test('weeks year starting friday', function (assert) {
<ide> assert.equal(moment([2009, 11, 28]).week(), 1, 'Dec 28 2009 should be week 1');
<ide> assert.equal(moment([2010, 0, 1]).week(), 1, 'Jan 1 2010 should be week 1');
<ide> assert.equal(moment([2010, 0, 3]).week(), 1, 'Jan 3 2010 should be week 1');
<ide> test("weeks year starting friday", function (assert) {
<ide> assert.equal(moment([2010, 0, 11]).week(), 3, 'Jan 11 2010 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting saturday", function (assert) {
<add>test('weeks year starting saturday', function (assert) {
<ide> assert.equal(moment([2010, 11, 27]).week(), 1, 'Dec 27 2010 should be week 1');
<ide> assert.equal(moment([2011, 0, 1]).week(), 1, 'Jan 1 2011 should be week 1');
<ide> assert.equal(moment([2011, 0, 2]).week(), 1, 'Jan 2 2011 should be week 1');
<ide> test("weeks year starting saturday", function (assert) {
<ide> assert.equal(moment([2011, 0, 10]).week(), 3, 'Jan 10 2011 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting sunday formatted", function (assert) {
<add>test('weeks year starting sunday formatted', function (assert) {
<ide> assert.equal(moment([2011, 11, 26]).format('w ww wo'), '१ ०१ १', 'Dec 26 2011 should be week 1');
<ide> assert.equal(moment([2012, 0, 1]).format('w ww wo'), '१ ०१ १', 'Jan 1 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 2]).format('w ww wo'), '२ ०२ २', 'Jan 2 2012 should be week 2');
<ide> assert.equal(moment([2012, 0, 8]).format('w ww wo'), '२ ०२ २', 'Jan 8 2012 should be week 2');
<ide> assert.equal(moment([2012, 0, 9]).format('w ww wo'), '३ ०३ ३', 'Jan 9 2012 should be week 3');
<ide> });
<ide>
<del>test("lenient ordinal parsing", function (assert) {
<add>test('lenient ordinal parsing', function (assert) {
<ide> var i, ordinalStr, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> ordinalStr = moment([2014, 0, i]).format('YYYY MM Do');
<ide> test("lenient ordinal parsing", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("lenient ordinal parsing of number", function (assert) {
<add>test('lenient ordinal parsing of number', function (assert) {
<ide> var i, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> testMoment = moment('2014 01 ' + i, 'YYYY MM Do');
<ide> test("lenient ordinal parsing of number", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("meridiem invariant", function (assert) {
<add>test('meridiem invariant', function (assert) {
<ide> var h, m, t1, t2;
<ide> for (h = 0; h < 24; ++h) {
<ide> for (m = 0; m < 60; m += 15) {
<ide> test("meridiem invariant", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("strict ordinal parsing", function (assert) {
<add>test('strict ordinal parsing', function (assert) {
<ide> var i, ordinalStr, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> ordinalStr = moment([2014, 0, i]).format('YYYY MM Do');
<ide><path>src/test/locale/nl.js
<del>import {localeModule, test} from "../qunit";
<del>import {moment} from "../../moment";
<del>localeModule("nl");
<add>import {localeModule, test} from '../qunit';
<add>import {moment} from '../../moment';
<add>localeModule('nl');
<ide>
<del>test("parse", function (assert) {
<add>test('parse', function (assert) {
<ide> var tests = 'januari jan._februari feb._maart mrt._april apr._mei mei._juni jun._juli jul._augustus aug._september sep._oktober okt._november nov._december dec.'.split('_'), i;
<ide> function equalTest(input, mmm, i) {
<ide> assert.equal(moment(input, mmm).month(), i, input + ' should be month ' + (i + 1));
<ide> test("parse", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("format", function (assert) {
<add>test('format', function (assert) {
<ide> var a = [
<ide> ['dddd, MMMM Do YYYY, HH:mm:ss', 'zondag, februari 14de 2010, 15:25:50'],
<ide> ['ddd, HH', 'zo., 15'],
<ide> test("format", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("format ordinal", function (assert) {
<add>test('format ordinal', function (assert) {
<ide> assert.equal(moment([2011, 0, 1]).format('DDDo'), '1ste', '1ste');
<ide> assert.equal(moment([2011, 0, 2]).format('DDDo'), '2de', '2de');
<ide> assert.equal(moment([2011, 0, 3]).format('DDDo'), '3de', '3de');
<ide> test("format ordinal", function (assert) {
<ide> assert.equal(moment([2011, 0, 31]).format('DDDo'), '31ste', '31ste');
<ide> });
<ide>
<del>test("format month", function (assert) {
<add>test('format month', function (assert) {
<ide> var expected = 'januari jan._februari feb._maart mrt._april apr._mei mei_juni jun._juli jul._augustus aug._september sep._oktober okt._november nov._december dec.'.split('_'), i;
<ide> for (i = 0; i < expected.length; i++) {
<ide> assert.equal(moment([2011, i, 1]).format('MMMM MMM'), expected[i], expected[i]);
<ide> }
<ide> });
<ide>
<del>test("format week", function (assert) {
<add>test('format week', function (assert) {
<ide> var expected = 'zondag zo. Zo_maandag ma. Ma_dinsdag di. Di_woensdag wo. Wo_donderdag do. Do_vrijdag vr. Vr_zaterdag za. Za'.split('_'), i;
<ide> for (i = 0; i < expected.length; i++) {
<ide> assert.equal(moment([2011, 0, 2 + i]).format('dddd ddd dd'), expected[i], expected[i]);
<ide> }
<ide> });
<ide>
<del>test("from", function (assert) {
<add>test('from', function (assert) {
<ide> var start = moment([2007, 1, 28]);
<ide> assert.equal(start.from(moment([2007, 1, 28]).add({s: 44}), true), 'een paar seconden', '44 seconds = a few seconds');
<ide> assert.equal(start.from(moment([2007, 1, 28]).add({s: 45}), true), 'één minuut', '45 seconds = a minute');
<ide> test("from", function (assert) {
<ide> assert.equal(start.from(moment([2007, 1, 28]).add({y: 5}), true), '5 jaar', '5 years = 5 years');
<ide> });
<ide>
<del>test("suffix", function (assert) {
<add>test('suffix', function (assert) {
<ide> assert.equal(moment(30000).from(0), 'over een paar seconden', 'prefix');
<ide> assert.equal(moment(0).from(30000), 'een paar seconden geleden', 'suffix');
<ide> });
<ide>
<del>test("now from now", function (assert) {
<add>test('now from now', function (assert) {
<ide> assert.equal(moment().fromNow(), 'een paar seconden geleden', 'now from now should display as in the past');
<ide> });
<ide>
<del>test("fromNow", function (assert) {
<add>test('fromNow', function (assert) {
<ide> assert.equal(moment().add({s: 30}).fromNow(), 'over een paar seconden', 'in a few seconds');
<ide> assert.equal(moment().add({d: 5}).fromNow(), 'over 5 dagen', 'in 5 days');
<ide> });
<ide>
<del>test("calendar day", function (assert) {
<add>test('calendar day', function (assert) {
<ide> var a = moment().hours(2).minutes(0).seconds(0);
<ide>
<ide> assert.equal(moment(a).calendar(), 'vandaag om 02:00', 'today at the same time');
<ide> test("calendar day", function (assert) {
<ide> assert.equal(moment(a).subtract({d: 1}).calendar(), 'gisteren om 02:00', 'yesterday at the same time');
<ide> });
<ide>
<del>test("calendar next week", function (assert) {
<add>test('calendar next week', function (assert) {
<ide> var i, m;
<ide> for (i = 2; i < 7; i++) {
<ide> m = moment().add({d: i});
<ide> test("calendar next week", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("calendar last week", function (assert) {
<add>test('calendar last week', function (assert) {
<ide> var i, m;
<ide> for (i = 2; i < 7; i++) {
<ide> m = moment().subtract({d: i});
<ide> test("calendar last week", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("calendar all else", function (assert) {
<add>test('calendar all else', function (assert) {
<ide> var weeksAgo = moment().subtract({w: 1}),
<ide> weeksFromNow = moment().add({w: 1});
<ide>
<ide> test("calendar all else", function (assert) {
<ide> assert.equal(weeksFromNow.calendar(), weeksFromNow.format('L'), 'in 2 weeks');
<ide> });
<ide>
<del>test("month abbreviation", function (assert) {
<add>test('month abbreviation', function (assert) {
<ide> assert.equal(moment([2012, 5, 23]).format('D-MMM-YYYY'), '23-jun-2012', 'format month abbreviation surrounded by dashes should not include a dot');
<ide> assert.equal(moment([2012, 5, 23]).format('D MMM YYYY'), '23 jun. 2012', 'format month abbreviation not surrounded by dashes should include a dot');
<ide> });
<ide>
<del>test("weeks year starting sunday", function (assert) {
<add>test('weeks year starting sunday', function (assert) {
<ide> assert.equal(moment([2012, 0, 1]).week(), 52, 'Jan 1 2012 should be week 52');
<ide> assert.equal(moment([2012, 0, 2]).week(), 1, 'Jan 2 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 8]).week(), 1, 'Jan 8 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 9]).week(), 2, 'Jan 9 2012 should be week 2');
<ide> assert.equal(moment([2012, 0, 15]).week(), 2, 'Jan 15 2012 should be week 2');
<ide> });
<ide>
<del>test("weeks year starting monday", function (assert) {
<add>test('weeks year starting monday', function (assert) {
<ide> assert.equal(moment([2007, 0, 1]).week(), 1, 'Jan 1 2007 should be week 1');
<ide> assert.equal(moment([2007, 0, 7]).week(), 1, 'Jan 7 2007 should be week 1');
<ide> assert.equal(moment([2007, 0, 8]).week(), 2, 'Jan 8 2007 should be week 2');
<ide> assert.equal(moment([2007, 0, 14]).week(), 2, 'Jan 14 2007 should be week 2');
<ide> assert.equal(moment([2007, 0, 15]).week(), 3, 'Jan 15 2007 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting tuesday", function (assert) {
<add>test('weeks year starting tuesday', function (assert) {
<ide> assert.equal(moment([2007, 11, 31]).week(), 1, 'Dec 31 2007 should be week 1');
<ide> assert.equal(moment([2008, 0, 1]).week(), 1, 'Jan 1 2008 should be week 1');
<ide> assert.equal(moment([2008, 0, 6]).week(), 1, 'Jan 6 2008 should be week 1');
<ide> test("weeks year starting tuesday", function (assert) {
<ide> assert.equal(moment([2008, 0, 14]).week(), 3, 'Jan 14 2008 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting wednesday", function (assert) {
<add>test('weeks year starting wednesday', function (assert) {
<ide> assert.equal(moment([2002, 11, 30]).week(), 1, 'Dec 30 2002 should be week 1');
<ide> assert.equal(moment([2003, 0, 1]).week(), 1, 'Jan 1 2003 should be week 1');
<ide> assert.equal(moment([2003, 0, 5]).week(), 1, 'Jan 5 2003 should be week 1');
<ide> test("weeks year starting wednesday", function (assert) {
<ide> assert.equal(moment([2003, 0, 13]).week(), 3, 'Jan 13 2003 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting thursday", function (assert) {
<add>test('weeks year starting thursday', function (assert) {
<ide> assert.equal(moment([2008, 11, 29]).week(), 1, 'Dec 29 2008 should be week 1');
<ide> assert.equal(moment([2009, 0, 1]).week(), 1, 'Jan 1 2009 should be week 1');
<ide> assert.equal(moment([2009, 0, 4]).week(), 1, 'Jan 4 2009 should be week 1');
<ide> test("weeks year starting thursday", function (assert) {
<ide> assert.equal(moment([2009, 0, 13]).week(), 3, 'Jan 12 2009 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting friday", function (assert) {
<add>test('weeks year starting friday', function (assert) {
<ide> assert.equal(moment([2009, 11, 28]).week(), 53, 'Dec 28 2009 should be week 53');
<ide> assert.equal(moment([2010, 0, 1]).week(), 53, 'Jan 1 2010 should be week 53');
<ide> assert.equal(moment([2010, 0, 3]).week(), 53, 'Jan 3 2010 should be week 53');
<ide> test("weeks year starting friday", function (assert) {
<ide> assert.equal(moment([2010, 0, 11]).week(), 2, 'Jan 11 2010 should be week 2');
<ide> });
<ide>
<del>test("weeks year starting saturday", function (assert) {
<add>test('weeks year starting saturday', function (assert) {
<ide> assert.equal(moment([2010, 11, 27]).week(), 52, 'Dec 27 2010 should be week 52');
<ide> assert.equal(moment([2011, 0, 1]).week(), 52, 'Jan 1 2011 should be week 52');
<ide> assert.equal(moment([2011, 0, 2]).week(), 52, 'Jan 2 2011 should be week 52');
<ide> test("weeks year starting saturday", function (assert) {
<ide> assert.equal(moment([2011, 0, 10]).week(), 2, 'Jan 10 2011 should be week 2');
<ide> });
<ide>
<del>test("weeks year starting sunday formatted", function (assert) {
<add>test('weeks year starting sunday formatted', function (assert) {
<ide> assert.equal(moment([2012, 0, 1]).format('w ww wo'), '52 52 52ste', 'Jan 1 2012 should be week 52');
<ide> assert.equal(moment([2012, 0, 2]).format('w ww wo'), '1 01 1ste', 'Jan 2 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 8]).format('w ww wo'), '1 01 1ste', 'Jan 8 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 9]).format('w ww wo'), '2 02 2de', 'Jan 9 2012 should be week 2');
<ide> assert.equal(moment([2012, 0, 15]).format('w ww wo'), '2 02 2de', 'Jan 15 2012 should be week 2');
<ide> });
<ide>
<del>test("lenient ordinal parsing", function (assert) {
<add>test('lenient ordinal parsing', function (assert) {
<ide> var i, ordinalStr, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> ordinalStr = moment([2014, 0, i]).format('YYYY MM Do');
<ide> test("lenient ordinal parsing", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("lenient ordinal parsing of number", function (assert) {
<add>test('lenient ordinal parsing of number', function (assert) {
<ide> var i, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> testMoment = moment('2014 01 ' + i, 'YYYY MM Do');
<ide> test("lenient ordinal parsing of number", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("strict ordinal parsing", function (assert) {
<add>test('strict ordinal parsing', function (assert) {
<ide> var i, ordinalStr, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> ordinalStr = moment([2014, 0, i]).format('YYYY MM Do');
<ide><path>src/test/locale/nn.js
<del>import {localeModule, test} from "../qunit";
<del>import {moment} from "../../moment";
<del>localeModule("nn");
<add>import {localeModule, test} from '../qunit';
<add>import {moment} from '../../moment';
<add>localeModule('nn');
<ide>
<del>test("parse", function (assert) {
<add>test('parse', function (assert) {
<ide> var tests = 'januar jan_februar feb_mars mar_april apr_mai mai_juni jun_juli jul_august aug_september sep_oktober okt_november nov_desember des'.split('_'), i;
<ide> function equalTest(input, mmm, i) {
<ide> assert.equal(moment(input, mmm).month(), i, input + ' should be month ' + (i + 1));
<ide> test("parse", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("format", function (assert) {
<add>test('format', function (assert) {
<ide> var a = [
<ide> ['dddd, MMMM Do YYYY, h:mm:ss a', 'sundag, februar 14. 2010, 3:25:50 pm'],
<ide> ['ddd, hA', 'sun, 3PM'],
<ide> test("format", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("format ordinal", function (assert) {
<add>test('format ordinal', function (assert) {
<ide> assert.equal(moment([2011, 0, 1]).format('DDDo'), '1.', '1.');
<ide> assert.equal(moment([2011, 0, 2]).format('DDDo'), '2.', '2.');
<ide> assert.equal(moment([2011, 0, 3]).format('DDDo'), '3.', '3.');
<ide> test("format ordinal", function (assert) {
<ide> assert.equal(moment([2011, 0, 31]).format('DDDo'), '31.', '31.');
<ide> });
<ide>
<del>test("format month", function (assert) {
<add>test('format month', function (assert) {
<ide> var expected = 'januar jan_februar feb_mars mar_april apr_mai mai_juni jun_juli jul_august aug_september sep_oktober okt_november nov_desember des'.split('_'), i;
<ide> for (i = 0; i < expected.length; i++) {
<ide> assert.equal(moment([2011, i, 1]).format('MMMM MMM'), expected[i], expected[i]);
<ide> }
<ide> });
<ide>
<del>test("format week", function (assert) {
<add>test('format week', function (assert) {
<ide> var expected = 'sundag sun su_måndag mån må_tysdag tys ty_onsdag ons on_torsdag tor to_fredag fre fr_laurdag lau lø'.split('_'), i;
<ide> for (i = 0; i < expected.length; i++) {
<ide> assert.equal(moment([2011, 0, 2 + i]).format('dddd ddd dd'), expected[i], expected[i]);
<ide> }
<ide> });
<ide>
<del>test("from", function (assert) {
<add>test('from', function (assert) {
<ide> var start = moment([2007, 1, 28]);
<ide> assert.equal(start.from(moment([2007, 1, 28]).add({s: 44}), true), 'nokre sekund', '44 sekunder = a few seconds');
<ide> assert.equal(start.from(moment([2007, 1, 28]).add({s: 45}), true), 'eit minutt', '45 seconds = a minute');
<ide> test("from", function (assert) {
<ide> assert.equal(start.from(moment([2007, 1, 28]).add({y: 5}), true), '5 år', '5 years = 5 years');
<ide> });
<ide>
<del>test("suffix", function (assert) {
<add>test('suffix', function (assert) {
<ide> assert.equal(moment(30000).from(0), 'om nokre sekund', 'prefix');
<ide> assert.equal(moment(0).from(30000), 'for nokre sekund sidan', 'suffix');
<ide> });
<ide>
<del>test("now from now", function (assert) {
<add>test('now from now', function (assert) {
<ide> assert.equal(moment().fromNow(), 'for nokre sekund sidan', 'now from now should display as in the past');
<ide> });
<ide>
<del>test("fromNow", function (assert) {
<add>test('fromNow', function (assert) {
<ide> assert.equal(moment().add({s: 30}).fromNow(), 'om nokre sekund', 'in a few seconds');
<ide> assert.equal(moment().add({d: 5}).fromNow(), 'om 5 dagar', 'in 5 days');
<ide> });
<ide>
<del>test("calendar day", function (assert) {
<add>test('calendar day', function (assert) {
<ide> var a = moment().hours(2).minutes(0).seconds(0);
<ide>
<ide> assert.equal(moment(a).calendar(), 'I dag klokka 02:00', 'today at the same time');
<ide> test("calendar day", function (assert) {
<ide> assert.equal(moment(a).subtract({d: 1}).calendar(), 'I går klokka 02:00', 'yesterday at the same time');
<ide> });
<ide>
<del>test("calendar next week", function (assert) {
<add>test('calendar next week', function (assert) {
<ide> var i, m;
<ide> for (i = 2; i < 7; i++) {
<ide> m = moment().add({d: i});
<ide> test("calendar next week", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("calendar last week", function (assert) {
<add>test('calendar last week', function (assert) {
<ide> var i, m;
<ide> for (i = 2; i < 7; i++) {
<ide> m = moment().subtract({d: i});
<ide> test("calendar last week", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("calendar all else", function (assert) {
<add>test('calendar all else', function (assert) {
<ide> var weeksAgo = moment().subtract({w: 1}),
<ide> weeksFromNow = moment().add({w: 1});
<ide>
<ide> test("calendar all else", function (assert) {
<ide> assert.equal(weeksFromNow.calendar(), weeksFromNow.format('L'), 'in 2 weeks');
<ide> });
<ide>
<del>test("weeks year starting sunday", function (assert) {
<add>test('weeks year starting sunday', function (assert) {
<ide> assert.equal(moment([2012, 0, 1]).week(), 52, 'Jan 1 2012 should be week 52');
<ide> assert.equal(moment([2012, 0, 2]).week(), 1, 'Jan 2 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 8]).week(), 1, 'Jan 8 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 9]).week(), 2, 'Jan 9 2012 should be week 2');
<ide> assert.equal(moment([2012, 0, 15]).week(), 2, 'Jan 15 2012 should be week 2');
<ide> });
<ide>
<del>test("weeks year starting monday", function (assert) {
<add>test('weeks year starting monday', function (assert) {
<ide> assert.equal(moment([2007, 0, 1]).week(), 1, 'Jan 1 2007 should be week 1');
<ide> assert.equal(moment([2007, 0, 7]).week(), 1, 'Jan 7 2007 should be week 1');
<ide> assert.equal(moment([2007, 0, 8]).week(), 2, 'Jan 8 2007 should be week 2');
<ide> assert.equal(moment([2007, 0, 14]).week(), 2, 'Jan 14 2007 should be week 2');
<ide> assert.equal(moment([2007, 0, 15]).week(), 3, 'Jan 15 2007 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting tuesday", function (assert) {
<add>test('weeks year starting tuesday', function (assert) {
<ide> assert.equal(moment([2007, 11, 31]).week(), 1, 'Dec 31 2007 should be week 1');
<ide> assert.equal(moment([2008, 0, 1]).week(), 1, 'Jan 1 2008 should be week 1');
<ide> assert.equal(moment([2008, 0, 6]).week(), 1, 'Jan 6 2008 should be week 1');
<ide> test("weeks year starting tuesday", function (assert) {
<ide> assert.equal(moment([2008, 0, 14]).week(), 3, 'Jan 14 2008 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting wednesday", function (assert) {
<add>test('weeks year starting wednesday', function (assert) {
<ide> assert.equal(moment([2002, 11, 30]).week(), 1, 'Dec 30 2002 should be week 1');
<ide> assert.equal(moment([2003, 0, 1]).week(), 1, 'Jan 1 2003 should be week 1');
<ide> assert.equal(moment([2003, 0, 5]).week(), 1, 'Jan 5 2003 should be week 1');
<ide> test("weeks year starting wednesday", function (assert) {
<ide> assert.equal(moment([2003, 0, 13]).week(), 3, 'Jan 13 2003 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting thursday", function (assert) {
<add>test('weeks year starting thursday', function (assert) {
<ide> assert.equal(moment([2008, 11, 29]).week(), 1, 'Dec 29 2008 should be week 1');
<ide> assert.equal(moment([2009, 0, 1]).week(), 1, 'Jan 1 2009 should be week 1');
<ide> assert.equal(moment([2009, 0, 4]).week(), 1, 'Jan 4 2009 should be week 1');
<ide> test("weeks year starting thursday", function (assert) {
<ide> assert.equal(moment([2009, 0, 13]).week(), 3, 'Jan 12 2009 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting friday", function (assert) {
<add>test('weeks year starting friday', function (assert) {
<ide> assert.equal(moment([2009, 11, 28]).week(), 53, 'Dec 28 2009 should be week 53');
<ide> assert.equal(moment([2010, 0, 1]).week(), 53, 'Jan 1 2010 should be week 53');
<ide> assert.equal(moment([2010, 0, 3]).week(), 53, 'Jan 3 2010 should be week 53');
<ide> test("weeks year starting friday", function (assert) {
<ide> assert.equal(moment([2010, 0, 11]).week(), 2, 'Jan 11 2010 should be week 2');
<ide> });
<ide>
<del>test("weeks year starting saturday", function (assert) {
<add>test('weeks year starting saturday', function (assert) {
<ide> assert.equal(moment([2010, 11, 27]).week(), 52, 'Dec 27 2010 should be week 52');
<ide> assert.equal(moment([2011, 0, 1]).week(), 52, 'Jan 1 2011 should be week 52');
<ide> assert.equal(moment([2011, 0, 2]).week(), 52, 'Jan 2 2011 should be week 52');
<ide> test("weeks year starting saturday", function (assert) {
<ide> assert.equal(moment([2011, 0, 10]).week(), 2, 'Jan 10 2011 should be week 2');
<ide> });
<ide>
<del>test("weeks year starting sunday formatted", function (assert) {
<add>test('weeks year starting sunday formatted', function (assert) {
<ide> assert.equal(moment([2012, 0, 1]).format('w ww wo'), '52 52 52.', 'Jan 1 2012 should be week 52');
<ide> assert.equal(moment([2012, 0, 2]).format('w ww wo'), '1 01 1.', 'Jan 2 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 8]).format('w ww wo'), '1 01 1.', 'Jan 8 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 9]).format('w ww wo'), '2 02 2.', 'Jan 9 2012 should be week 2');
<ide> assert.equal(moment([2012, 0, 15]).format('w ww wo'), '2 02 2.', 'Jan 15 2012 should be week 2');
<ide> });
<ide>
<del>test("lenient ordinal parsing", function (assert) {
<add>test('lenient ordinal parsing', function (assert) {
<ide> var i, ordinalStr, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> ordinalStr = moment([2014, 0, i]).format('YYYY MM Do');
<ide> test("lenient ordinal parsing", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("lenient ordinal parsing of number", function (assert) {
<add>test('lenient ordinal parsing of number', function (assert) {
<ide> var i, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> testMoment = moment('2014 01 ' + i, 'YYYY MM Do');
<ide> test("lenient ordinal parsing of number", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("strict ordinal parsing", function (assert) {
<add>test('strict ordinal parsing', function (assert) {
<ide> var i, ordinalStr, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> ordinalStr = moment([2014, 0, i]).format('YYYY MM Do');
<ide><path>src/test/locale/pl.js
<del>import {localeModule, test} from "../qunit";
<del>import {moment} from "../../moment";
<del>localeModule("pl");
<add>import {localeModule, test} from '../qunit';
<add>import {moment} from '../../moment';
<add>localeModule('pl');
<ide>
<del>test("parse", function (assert) {
<add>test('parse', function (assert) {
<ide> var tests = 'styczeń sty_luty lut_marzec mar_kwiecień kwi_maj maj_czerwiec cze_lipiec lip_sierpień sie_wrzesień wrz_październik paź_listopad lis_grudzień gru'.split('_'), i;
<ide> function equalTest(input, mmm, i) {
<ide> assert.equal(moment(input, mmm).month(), i, input + ' should be month ' + (i + 1));
<ide> test("parse", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("format", function (assert) {
<add>test('format', function (assert) {
<ide> var a = [
<ide> ['dddd, MMMM Do YYYY, h:mm:ss a', 'niedziela, luty 14. 2010, 3:25:50 pm'],
<ide> ['ddd, hA', 'nie, 3PM'],
<ide> test("format", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("format ordinal", function (assert) {
<add>test('format ordinal', function (assert) {
<ide> assert.equal(moment([2011, 0, 1]).format('DDDo'), '1.', '1.');
<ide> assert.equal(moment([2011, 0, 2]).format('DDDo'), '2.', '2.');
<ide> assert.equal(moment([2011, 0, 3]).format('DDDo'), '3.', '3.');
<ide> test("format ordinal", function (assert) {
<ide> assert.equal(moment([2011, 0, 31]).format('DDDo'), '31.', '31.');
<ide> });
<ide>
<del>test("format month", function (assert) {
<add>test('format month', function (assert) {
<ide> var expected = 'styczeń sty_luty lut_marzec mar_kwiecień kwi_maj maj_czerwiec cze_lipiec lip_sierpień sie_wrzesień wrz_październik paź_listopad lis_grudzień gru'.split('_'), i;
<ide> for (i = 0; i < expected.length; i++) {
<ide> assert.equal(moment([2011, i, 1]).format('MMMM MMM'), expected[i], expected[i]);
<ide> }
<ide> });
<ide>
<del>test("format week", function (assert) {
<add>test('format week', function (assert) {
<ide> var expected = 'niedziela nie N_poniedziałek pon Pn_wtorek wt Wt_środa śr Śr_czwartek czw Cz_piątek pt Pt_sobota sb So'.split('_'), i;
<ide> for (i = 0; i < expected.length; i++) {
<ide> assert.equal(moment([2011, 0, 2 + i]).format('dddd ddd dd'), expected[i], expected[i]);
<ide> }
<ide> });
<ide>
<del>test("from", function (assert) {
<add>test('from', function (assert) {
<ide> var start = moment([2007, 1, 28]);
<ide> assert.equal(start.from(moment([2007, 1, 28]).add({s: 44}), true), 'kilka sekund', '44 seconds = a few seconds');
<ide> assert.equal(start.from(moment([2007, 1, 28]).add({s: 45}), true), 'minuta', '45 seconds = a minute');
<ide> test("from", function (assert) {
<ide> assert.equal(start.from(moment([2007, 1, 28]).add({y: 223}), true), '223 lata', '223 years = 223 years');
<ide> });
<ide>
<del>test("suffix", function (assert) {
<add>test('suffix', function (assert) {
<ide> assert.equal(moment(30000).from(0), 'za kilka sekund', 'prefix');
<ide> assert.equal(moment(0).from(30000), 'kilka sekund temu', 'suffix');
<ide> });
<ide>
<del>test("now from now", function (assert) {
<add>test('now from now', function (assert) {
<ide> assert.equal(moment().fromNow(), 'kilka sekund temu', 'now from now should display as in the past');
<ide> });
<ide>
<del>test("fromNow", function (assert) {
<add>test('fromNow', function (assert) {
<ide> assert.equal(moment().add({s: 30}).fromNow(), 'za kilka sekund', 'in a few seconds');
<ide> assert.equal(moment().add({h: 1}).fromNow(), 'za godzinę', 'in an hour');
<ide> assert.equal(moment().add({d: 5}).fromNow(), 'za 5 dni', 'in 5 days');
<ide> });
<ide>
<del>test("calendar day", function (assert) {
<add>test('calendar day', function (assert) {
<ide> var a = moment().hours(2).minutes(0).seconds(0);
<ide>
<ide> assert.equal(moment(a).calendar(), 'Dziś o 02:00', 'today at the same time');
<ide> test("calendar day", function (assert) {
<ide> assert.equal(moment(a).subtract({d: 1}).calendar(), 'Wczoraj o 02:00', 'yesterday at the same time');
<ide> });
<ide>
<del>test("calendar next week", function (assert) {
<add>test('calendar next week', function (assert) {
<ide> var i, m;
<ide> for (i = 2; i < 7; i++) {
<ide> m = moment().add({d: i});
<ide> test("calendar next week", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("calendar last week", function (assert) {
<add>test('calendar last week', function (assert) {
<ide> var i, m;
<ide>
<ide> function makeFormat(d) {
<ide> test("calendar last week", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("calendar all else", function (assert) {
<add>test('calendar all else', function (assert) {
<ide> var weeksAgo = moment().subtract({w: 1}),
<ide> weeksFromNow = moment().add({w: 1});
<ide>
<ide> test("calendar all else", function (assert) {
<ide> assert.equal(weeksFromNow.calendar(), weeksFromNow.format('L'), 'in 2 weeks');
<ide> });
<ide>
<del>test("weeks year starting sunday", function (assert) {
<add>test('weeks year starting sunday', function (assert) {
<ide> assert.equal(moment([2012, 0, 1]).week(), 52, 'Jan 1 2012 should be week 52');
<ide> assert.equal(moment([2012, 0, 2]).week(), 1, 'Jan 2 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 8]).week(), 1, 'Jan 8 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 9]).week(), 2, 'Jan 9 2012 should be week 2');
<ide> assert.equal(moment([2012, 0, 15]).week(), 2, 'Jan 15 2012 should be week 2');
<ide> });
<ide>
<del>test("weeks year starting monday", function (assert) {
<add>test('weeks year starting monday', function (assert) {
<ide> assert.equal(moment([2007, 0, 1]).week(), 1, 'Jan 1 2007 should be week 1');
<ide> assert.equal(moment([2007, 0, 7]).week(), 1, 'Jan 7 2007 should be week 1');
<ide> assert.equal(moment([2007, 0, 8]).week(), 2, 'Jan 8 2007 should be week 2');
<ide> assert.equal(moment([2007, 0, 14]).week(), 2, 'Jan 14 2007 should be week 2');
<ide> assert.equal(moment([2007, 0, 15]).week(), 3, 'Jan 15 2007 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting tuesday", function (assert) {
<add>test('weeks year starting tuesday', function (assert) {
<ide> assert.equal(moment([2007, 11, 31]).week(), 1, 'Dec 31 2007 should be week 1');
<ide> assert.equal(moment([2008, 0, 1]).week(), 1, 'Jan 1 2008 should be week 1');
<ide> assert.equal(moment([2008, 0, 6]).week(), 1, 'Jan 6 2008 should be week 1');
<ide> test("weeks year starting tuesday", function (assert) {
<ide> assert.equal(moment([2008, 0, 14]).week(), 3, 'Jan 14 2008 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting wednesday", function (assert) {
<add>test('weeks year starting wednesday', function (assert) {
<ide> assert.equal(moment([2002, 11, 30]).week(), 1, 'Dec 30 2002 should be week 1');
<ide> assert.equal(moment([2003, 0, 1]).week(), 1, 'Jan 1 2003 should be week 1');
<ide> assert.equal(moment([2003, 0, 5]).week(), 1, 'Jan 5 2003 should be week 1');
<ide> test("weeks year starting wednesday", function (assert) {
<ide> assert.equal(moment([2003, 0, 13]).week(), 3, 'Jan 13 2003 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting thursday", function (assert) {
<add>test('weeks year starting thursday', function (assert) {
<ide> assert.equal(moment([2008, 11, 29]).week(), 1, 'Dec 29 2008 should be week 1');
<ide> assert.equal(moment([2009, 0, 1]).week(), 1, 'Jan 1 2009 should be week 1');
<ide> assert.equal(moment([2009, 0, 4]).week(), 1, 'Jan 4 2009 should be week 1');
<ide> test("weeks year starting thursday", function (assert) {
<ide> assert.equal(moment([2009, 0, 13]).week(), 3, 'Jan 12 2009 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting friday", function (assert) {
<add>test('weeks year starting friday', function (assert) {
<ide> assert.equal(moment([2009, 11, 28]).week(), 53, 'Dec 28 2009 should be week 53');
<ide> assert.equal(moment([2010, 0, 1]).week(), 53, 'Jan 1 2010 should be week 53');
<ide> assert.equal(moment([2010, 0, 3]).week(), 53, 'Jan 3 2010 should be week 53');
<ide> test("weeks year starting friday", function (assert) {
<ide> assert.equal(moment([2010, 0, 11]).week(), 2, 'Jan 11 2010 should be week 2');
<ide> });
<ide>
<del>test("weeks year starting saturday", function (assert) {
<add>test('weeks year starting saturday', function (assert) {
<ide> assert.equal(moment([2010, 11, 27]).week(), 52, 'Dec 27 2010 should be week 52');
<ide> assert.equal(moment([2011, 0, 1]).week(), 52, 'Jan 1 2011 should be week 52');
<ide> assert.equal(moment([2011, 0, 2]).week(), 52, 'Jan 2 2011 should be week 52');
<ide> test("weeks year starting saturday", function (assert) {
<ide> assert.equal(moment([2011, 0, 10]).week(), 2, 'Jan 10 2011 should be week 2');
<ide> });
<ide>
<del>test("weeks year starting sunday formatted", function (assert) {
<add>test('weeks year starting sunday formatted', function (assert) {
<ide> assert.equal(moment([2012, 0, 1]).format('w ww wo'), '52 52 52.', 'Jan 1 2012 should be week 52');
<ide> assert.equal(moment([2012, 0, 2]).format('w ww wo'), '1 01 1.', 'Jan 2 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 8]).format('w ww wo'), '1 01 1.', 'Jan 8 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 9]).format('w ww wo'), '2 02 2.', 'Jan 9 2012 should be week 2');
<ide> assert.equal(moment([2012, 0, 15]).format('w ww wo'), '2 02 2.', 'Jan 15 2012 should be week 2');
<ide> });
<ide>
<del>test("lenient ordinal parsing", function (assert) {
<add>test('lenient ordinal parsing', function (assert) {
<ide> var i, ordinalStr, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> ordinalStr = moment([2014, 0, i]).format('YYYY MM Do');
<ide> test("lenient ordinal parsing", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("lenient ordinal parsing of number", function (assert) {
<add>test('lenient ordinal parsing of number', function (assert) {
<ide> var i, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> testMoment = moment('2014 01 ' + i, 'YYYY MM Do');
<ide> test("lenient ordinal parsing of number", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("strict ordinal parsing", function (assert) {
<add>test('strict ordinal parsing', function (assert) {
<ide> var i, ordinalStr, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> ordinalStr = moment([2014, 0, i]).format('YYYY MM Do');
<ide><path>src/test/locale/pt-br.js
<del>import {localeModule, test} from "../qunit";
<del>import {moment} from "../../moment";
<del>localeModule("pt-br");
<add>import {localeModule, test} from '../qunit';
<add>import {moment} from '../../moment';
<add>localeModule('pt-br');
<ide>
<del>test("parse", function (assert) {
<add>test('parse', function (assert) {
<ide> var tests = 'janeiro jan_fevereiro fev_março mar_abril abr_maio mai_junho jun_julho jul_agosto ago_setembro set_outubro out_novembro nov_dezembro dez'.split('_'), i;
<ide>
<ide> function equalTest(input, mmm, i) {
<ide> test("parse", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("format", function (assert) {
<add>test('format', function (assert) {
<ide> var a = [
<ide> ['dddd, MMMM Do YYYY, h:mm:ss a', 'domingo, fevereiro 14º 2010, 3:25:50 pm'],
<ide> ['ddd, hA', 'dom, 3PM'],
<ide> test("format", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("format ordinal", function (assert) {
<add>test('format ordinal', function (assert) {
<ide> assert.equal(moment([2011, 0, 1]).format('DDDo'), '1º', '1º');
<ide> assert.equal(moment([2011, 0, 2]).format('DDDo'), '2º', '2º');
<ide> assert.equal(moment([2011, 0, 3]).format('DDDo'), '3º', '3º');
<ide> test("format ordinal", function (assert) {
<ide> assert.equal(moment([2011, 0, 31]).format('DDDo'), '31º', '31º');
<ide> });
<ide>
<del>test("format month", function (assert) {
<add>test('format month', function (assert) {
<ide> var expected = 'janeiro jan_fevereiro fev_março mar_abril abr_maio mai_junho jun_julho jul_agosto ago_setembro set_outubro out_novembro nov_dezembro dez'.split('_'), i;
<ide> for (i = 0; i < expected.length; i++) {
<ide> assert.equal(moment([2011, i, 1]).format('MMMM MMM'), expected[i], expected[i]);
<ide> }
<ide> });
<ide>
<del>test("format week", function (assert) {
<add>test('format week', function (assert) {
<ide> var expected = 'domingo dom_segunda-feira seg_terça-feira ter_quarta-feira qua_quinta-feira qui_sexta-feira sex_sábado sáb'.split('_'), i;
<ide> for (i = 0; i < expected.length; i++) {
<ide> assert.equal(moment([2011, 0, 2 + i]).format('dddd ddd'), expected[i], expected[i]);
<ide> }
<ide> });
<ide>
<del>test("from", function (assert) {
<add>test('from', function (assert) {
<ide> var start = moment([2007, 1, 28]);
<ide> assert.equal(start.from(moment([2007, 1, 28]).add({s: 44}), true), 'segundos', '44 seconds = seconds');
<ide> assert.equal(start.from(moment([2007, 1, 28]).add({s: 45}), true), 'um minuto', '45 seconds = a minute');
<ide> test("from", function (assert) {
<ide> assert.equal(start.from(moment([2007, 1, 28]).add({y: 5}), true), '5 anos', '5 years = 5 years');
<ide> });
<ide>
<del>test("suffix", function (assert) {
<add>test('suffix', function (assert) {
<ide> assert.equal(moment(30000).from(0), 'em segundos', 'prefix');
<ide> assert.equal(moment(0).from(30000), 'segundos atrás', 'suffix');
<ide> });
<ide>
<del>test("fromNow", function (assert) {
<add>test('fromNow', function (assert) {
<ide> assert.equal(moment().add({s: 30}).fromNow(), 'em segundos', 'in seconds');
<ide> assert.equal(moment().add({d: 5}).fromNow(), 'em 5 dias', 'in 5 days');
<ide> });
<ide>
<del>test("calendar day", function (assert) {
<add>test('calendar day', function (assert) {
<ide> var a = moment().hours(2).minutes(0).seconds(0);
<ide>
<ide> assert.equal(moment(a).calendar(), 'Hoje às 02:00', 'today at the same time');
<ide> test("calendar day", function (assert) {
<ide> assert.equal(moment(a).subtract({d: 1}).calendar(), 'Ontem às 02:00', 'yesterday at the same time');
<ide> });
<ide>
<del>test("calendar next week", function (assert) {
<add>test('calendar next week', function (assert) {
<ide> var i, m;
<ide> for (i = 2; i < 7; i++) {
<ide> m = moment().add({d: i});
<ide> test("calendar next week", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("calendar last week", function (assert) {
<add>test('calendar last week', function (assert) {
<ide> var i, m;
<ide> for (i = 2; i < 7; i++) {
<ide> m = moment().subtract({d: i});
<ide> test("calendar last week", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("calendar all else", function (assert) {
<add>test('calendar all else', function (assert) {
<ide> var weeksAgo = moment().subtract({w: 1}),
<ide> weeksFromNow = moment().add({w: 1});
<ide>
<ide> test("calendar all else", function (assert) {
<ide> assert.equal(weeksFromNow.calendar(), weeksFromNow.format('L'), 'in 2 weeks');
<ide> });
<ide>
<del>test("weeks year starting sunday", function (assert) {
<add>test('weeks year starting sunday', function (assert) {
<ide> assert.equal(moment([2012, 0, 1]).week(), 1, 'Jan 1 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 7]).week(), 1, 'Jan 7 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 8]).week(), 2, 'Jan 8 2012 should be week 2');
<ide> assert.equal(moment([2012, 0, 14]).week(), 2, 'Jan 14 2012 should be week 2');
<ide> assert.equal(moment([2012, 0, 15]).week(), 3, 'Jan 15 2012 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting monday", function (assert) {
<add>test('weeks year starting monday', function (assert) {
<ide> assert.equal(moment([2006, 11, 31]).week(), 1, 'Dec 31 2006 should be week 1');
<ide> assert.equal(moment([2007, 0, 1]).week(), 1, 'Jan 1 2007 should be week 1');
<ide> assert.equal(moment([2007, 0, 6]).week(), 1, 'Jan 6 2007 should be week 1');
<ide> test("weeks year starting monday", function (assert) {
<ide> assert.equal(moment([2007, 0, 14]).week(), 3, 'Jan 14 2007 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting tuesday", function (assert) {
<add>test('weeks year starting tuesday', function (assert) {
<ide> assert.equal(moment([2007, 11, 29]).week(), 52, 'Dec 29 2007 should be week 52');
<ide> assert.equal(moment([2008, 0, 1]).week(), 1, 'Jan 1 2008 should be week 1');
<ide> assert.equal(moment([2008, 0, 5]).week(), 1, 'Jan 5 2008 should be week 1');
<ide> test("weeks year starting tuesday", function (assert) {
<ide> assert.equal(moment([2008, 0, 13]).week(), 3, 'Jan 13 2008 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting wednesday", function (assert) {
<add>test('weeks year starting wednesday', function (assert) {
<ide> assert.equal(moment([2002, 11, 29]).week(), 1, 'Dec 29 2002 should be week 1');
<ide> assert.equal(moment([2003, 0, 1]).week(), 1, 'Jan 1 2003 should be week 1');
<ide> assert.equal(moment([2003, 0, 4]).week(), 1, 'Jan 4 2003 should be week 1');
<ide> test("weeks year starting wednesday", function (assert) {
<ide> assert.equal(moment([2003, 0, 12]).week(), 3, 'Jan 12 2003 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting thursday", function (assert) {
<add>test('weeks year starting thursday', function (assert) {
<ide> assert.equal(moment([2008, 11, 28]).week(), 1, 'Dec 28 2008 should be week 1');
<ide> assert.equal(moment([2009, 0, 1]).week(), 1, 'Jan 1 2009 should be week 1');
<ide> assert.equal(moment([2009, 0, 3]).week(), 1, 'Jan 3 2009 should be week 1');
<ide> test("weeks year starting thursday", function (assert) {
<ide> assert.equal(moment([2009, 0, 11]).week(), 3, 'Jan 11 2009 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting friday", function (assert) {
<add>test('weeks year starting friday', function (assert) {
<ide> assert.equal(moment([2009, 11, 27]).week(), 1, 'Dec 27 2009 should be week 1');
<ide> assert.equal(moment([2010, 0, 1]).week(), 1, 'Jan 1 2010 should be week 1');
<ide> assert.equal(moment([2010, 0, 2]).week(), 1, 'Jan 2 2010 should be week 1');
<ide> test("weeks year starting friday", function (assert) {
<ide> assert.equal(moment([2010, 0, 10]).week(), 3, 'Jan 10 2010 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting saturday", function (assert) {
<add>test('weeks year starting saturday', function (assert) {
<ide> assert.equal(moment([2010, 11, 26]).week(), 1, 'Dec 26 2010 should be week 1');
<ide> assert.equal(moment([2011, 0, 1]).week(), 1, 'Jan 1 2011 should be week 1');
<ide> assert.equal(moment([2011, 0, 2]).week(), 2, 'Jan 2 2011 should be week 2');
<ide> assert.equal(moment([2011, 0, 8]).week(), 2, 'Jan 8 2011 should be week 2');
<ide> assert.equal(moment([2011, 0, 9]).week(), 3, 'Jan 9 2011 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting sunday format", function (assert) {
<add>test('weeks year starting sunday format', function (assert) {
<ide> assert.equal(moment([2012, 0, 1]).format('w ww wo'), '1 01 1º', 'Jan 1 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 7]).format('w ww wo'), '1 01 1º', 'Jan 7 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 8]).format('w ww wo'), '2 02 2º', 'Jan 8 2012 should be week 2');
<ide> assert.equal(moment([2012, 0, 14]).format('w ww wo'), '2 02 2º', 'Jan 14 2012 should be week 2');
<ide> assert.equal(moment([2012, 0, 15]).format('w ww wo'), '3 03 3º', 'Jan 15 2012 should be week 3');
<ide> });
<ide>
<del>test("lenient ordinal parsing", function (assert) {
<add>test('lenient ordinal parsing', function (assert) {
<ide> var i, ordinalStr, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> ordinalStr = moment([2014, 0, i]).format('YYYY MM Do');
<ide> test("lenient ordinal parsing", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("lenient ordinal parsing of number", function (assert) {
<add>test('lenient ordinal parsing of number', function (assert) {
<ide> var i, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> testMoment = moment('2014 01 ' + i, 'YYYY MM Do');
<ide> test("lenient ordinal parsing of number", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("strict ordinal parsing", function (assert) {
<add>test('strict ordinal parsing', function (assert) {
<ide> var i, ordinalStr, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> ordinalStr = moment([2014, 0, i]).format('YYYY MM Do');
<ide><path>src/test/locale/pt.js
<del>import {localeModule, test} from "../qunit";
<del>import {moment} from "../../moment";
<del>localeModule("pt");
<add>import {localeModule, test} from '../qunit';
<add>import {moment} from '../../moment';
<add>localeModule('pt');
<ide>
<del>test("parse", function (assert) {
<add>test('parse', function (assert) {
<ide> var tests = 'Janeiro Jan_Fevereiro Fev_Março Mar_Abril Abr_Maio Mai_Junho Jun_Julho Jul_Agosto Ago_Setembro Set_Outubro Out_Novembro Nov_Dezembro Dez'.split('_'), i;
<ide> function equalTest(input, mmm, i) {
<ide> assert.equal(moment(input, mmm).month(), i, input + ' should be month ' + (i + 1));
<ide> test("parse", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("format", function (assert) {
<add>test('format', function (assert) {
<ide> var a = [
<ide> ['dddd, MMMM Do YYYY, h:mm:ss a', 'domingo, fevereiro 14º 2010, 3:25:50 pm'],
<ide> ['ddd, hA', 'dom, 3PM'],
<ide> test("format", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("format ordinal", function (assert) {
<add>test('format ordinal', function (assert) {
<ide> assert.equal(moment([2011, 0, 1]).format('DDDo'), '1º', '1º');
<ide> assert.equal(moment([2011, 0, 2]).format('DDDo'), '2º', '2º');
<ide> assert.equal(moment([2011, 0, 3]).format('DDDo'), '3º', '3º');
<ide> test("format ordinal", function (assert) {
<ide> assert.equal(moment([2011, 0, 31]).format('DDDo'), '31º', '31º');
<ide> });
<ide>
<del>test("format month", function (assert) {
<add>test('format month', function (assert) {
<ide> var expected = 'janeiro jan_fevereiro fev_março mar_abril abr_maio mai_junho jun_julho jul_agosto ago_setembro set_outubro out_novembro nov_dezembro dez'.split('_'), i;
<ide> for (i = 0; i < expected.length; i++) {
<ide> assert.equal(moment([2011, i, 1]).format('MMMM MMM'), expected[i], expected[i]);
<ide> }
<ide> });
<ide>
<del>test("format week", function (assert) {
<add>test('format week', function (assert) {
<ide> var expected = 'domingo dom dom_segunda-feira seg 2ª_terça-feira ter 3ª_quarta-feira qua 4ª_quinta-feira qui 5ª_sexta-feira sex 6ª_sábado sáb sáb'.split('_'), i;
<ide> for (i = 0; i < expected.length; i++) {
<ide> assert.equal(moment([2011, 0, 2 + i]).format('dddd ddd dd'), expected[i], expected[i]);
<ide> }
<ide> });
<ide>
<del>test("from", function (assert) {
<add>test('from', function (assert) {
<ide> var start = moment([2007, 1, 28]);
<ide> assert.equal(start.from(moment([2007, 1, 28]).add({s: 44}), true), 'segundos', '44 seconds = seconds');
<ide> assert.equal(start.from(moment([2007, 1, 28]).add({s: 45}), true), 'um minuto', '45 seconds = a minute');
<ide> test("from", function (assert) {
<ide> assert.equal(start.from(moment([2007, 1, 28]).add({y: 5}), true), '5 anos', '5 years = 5 years');
<ide> });
<ide>
<del>test("suffix", function (assert) {
<add>test('suffix', function (assert) {
<ide> assert.equal(moment(30000).from(0), 'em segundos', 'prefix');
<ide> assert.equal(moment(0).from(30000), 'há segundos', 'suffix');
<ide> });
<ide>
<del>test("fromNow", function (assert) {
<add>test('fromNow', function (assert) {
<ide> assert.equal(moment().add({s: 30}).fromNow(), 'em segundos', 'in seconds');
<ide> assert.equal(moment().add({d: 5}).fromNow(), 'em 5 dias', 'in 5 days');
<ide> });
<ide>
<del>test("calendar day", function (assert) {
<add>test('calendar day', function (assert) {
<ide> var a = moment().hours(2).minutes(0).seconds(0);
<ide>
<ide> assert.equal(moment(a).calendar(), 'Hoje às 02:00', 'today at the same time');
<ide> test("calendar day", function (assert) {
<ide> assert.equal(moment(a).subtract({d: 1}).calendar(), 'Ontem às 02:00', 'yesterday at the same time');
<ide> });
<ide>
<del>test("calendar next week", function (assert) {
<add>test('calendar next week', function (assert) {
<ide> var i, m;
<ide> for (i = 2; i < 7; i++) {
<ide> m = moment().add({d: i});
<ide> test("calendar next week", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("calendar last week", function (assert) {
<add>test('calendar last week', function (assert) {
<ide> var i, m;
<ide> for (i = 2; i < 7; i++) {
<ide> m = moment().subtract({d: i});
<ide> test("calendar last week", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("calendar all else", function (assert) {
<add>test('calendar all else', function (assert) {
<ide> var weeksAgo = moment().subtract({w: 1}),
<ide> weeksFromNow = moment().add({w: 1});
<ide>
<ide> test("calendar all else", function (assert) {
<ide> assert.equal(weeksFromNow.calendar(), weeksFromNow.format('L'), 'in 2 weeks');
<ide> });
<ide>
<del>test("weeks year starting sunday", function (assert) {
<add>test('weeks year starting sunday', function (assert) {
<ide> assert.equal(moment([2012, 0, 1]).week(), 52, 'Jan 1 2012 should be week 52');
<ide> assert.equal(moment([2012, 0, 2]).week(), 1, 'Jan 2 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 8]).week(), 1, 'Jan 8 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 9]).week(), 2, 'Jan 9 2012 should be week 2');
<ide> assert.equal(moment([2012, 0, 15]).week(), 2, 'Jan 15 2012 should be week 2');
<ide> });
<ide>
<del>test("weeks year starting monday", function (assert) {
<add>test('weeks year starting monday', function (assert) {
<ide> assert.equal(moment([2007, 0, 1]).week(), 1, 'Jan 1 2007 should be week 1');
<ide> assert.equal(moment([2007, 0, 7]).week(), 1, 'Jan 7 2007 should be week 1');
<ide> assert.equal(moment([2007, 0, 8]).week(), 2, 'Jan 8 2007 should be week 2');
<ide> assert.equal(moment([2007, 0, 14]).week(), 2, 'Jan 14 2007 should be week 2');
<ide> assert.equal(moment([2007, 0, 15]).week(), 3, 'Jan 15 2007 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting tuesday", function (assert) {
<add>test('weeks year starting tuesday', function (assert) {
<ide> assert.equal(moment([2007, 11, 31]).week(), 1, 'Dec 31 2007 should be week 1');
<ide> assert.equal(moment([2008, 0, 1]).week(), 1, 'Jan 1 2008 should be week 1');
<ide> assert.equal(moment([2008, 0, 6]).week(), 1, 'Jan 6 2008 should be week 1');
<ide> test("weeks year starting tuesday", function (assert) {
<ide> assert.equal(moment([2008, 0, 14]).week(), 3, 'Jan 14 2008 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting wednesday", function (assert) {
<add>test('weeks year starting wednesday', function (assert) {
<ide> assert.equal(moment([2002, 11, 30]).week(), 1, 'Dec 30 2002 should be week 1');
<ide> assert.equal(moment([2003, 0, 1]).week(), 1, 'Jan 1 2003 should be week 1');
<ide> assert.equal(moment([2003, 0, 5]).week(), 1, 'Jan 5 2003 should be week 1');
<ide> test("weeks year starting wednesday", function (assert) {
<ide> assert.equal(moment([2003, 0, 13]).week(), 3, 'Jan 13 2003 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting thursday", function (assert) {
<add>test('weeks year starting thursday', function (assert) {
<ide> assert.equal(moment([2008, 11, 29]).week(), 1, 'Dec 29 2008 should be week 1');
<ide> assert.equal(moment([2009, 0, 1]).week(), 1, 'Jan 1 2009 should be week 1');
<ide> assert.equal(moment([2009, 0, 4]).week(), 1, 'Jan 4 2009 should be week 1');
<ide> test("weeks year starting thursday", function (assert) {
<ide> assert.equal(moment([2009, 0, 13]).week(), 3, 'Jan 12 2009 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting friday", function (assert) {
<add>test('weeks year starting friday', function (assert) {
<ide> assert.equal(moment([2009, 11, 28]).week(), 53, 'Dec 28 2009 should be week 53');
<ide> assert.equal(moment([2010, 0, 1]).week(), 53, 'Jan 1 2010 should be week 53');
<ide> assert.equal(moment([2010, 0, 3]).week(), 53, 'Jan 3 2010 should be week 53');
<ide> test("weeks year starting friday", function (assert) {
<ide> assert.equal(moment([2010, 0, 11]).week(), 2, 'Jan 11 2010 should be week 2');
<ide> });
<ide>
<del>test("weeks year starting saturday", function (assert) {
<add>test('weeks year starting saturday', function (assert) {
<ide> assert.equal(moment([2010, 11, 27]).week(), 52, 'Dec 27 2010 should be week 52');
<ide> assert.equal(moment([2011, 0, 1]).week(), 52, 'Jan 1 2011 should be week 52');
<ide> assert.equal(moment([2011, 0, 2]).week(), 52, 'Jan 2 2011 should be week 52');
<ide> test("weeks year starting saturday", function (assert) {
<ide> assert.equal(moment([2011, 0, 10]).week(), 2, 'Jan 10 2011 should be week 2');
<ide> });
<ide>
<del>test("weeks year starting sunday formatted", function (assert) {
<add>test('weeks year starting sunday formatted', function (assert) {
<ide> assert.equal(moment([2012, 0, 1]).format('w ww wo'), '52 52 52º', 'Jan 1 2012 should be week 52');
<ide> assert.equal(moment([2012, 0, 2]).format('w ww wo'), '1 01 1º', 'Jan 2 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 8]).format('w ww wo'), '1 01 1º', 'Jan 8 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 9]).format('w ww wo'), '2 02 2º', 'Jan 9 2012 should be week 2');
<ide> assert.equal(moment([2012, 0, 15]).format('w ww wo'), '2 02 2º', 'Jan 15 2012 should be week 2');
<ide> });
<ide>
<del>test("lenient ordinal parsing", function (assert) {
<add>test('lenient ordinal parsing', function (assert) {
<ide> var i, ordinalStr, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> ordinalStr = moment([2014, 0, i]).format('YYYY MM Do');
<ide> test("lenient ordinal parsing", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("lenient ordinal parsing of number", function (assert) {
<add>test('lenient ordinal parsing of number', function (assert) {
<ide> var i, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> testMoment = moment('2014 01 ' + i, 'YYYY MM Do');
<ide> test("lenient ordinal parsing of number", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("strict ordinal parsing", function (assert) {
<add>test('strict ordinal parsing', function (assert) {
<ide> var i, ordinalStr, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> ordinalStr = moment([2014, 0, i]).format('YYYY MM Do');
<ide><path>src/test/locale/ro.js
<del>import {localeModule, test} from "../qunit";
<del>import {moment} from "../../moment";
<del>localeModule("ro");
<add>import {localeModule, test} from '../qunit';
<add>import {moment} from '../../moment';
<add>localeModule('ro');
<ide>
<del>test("parse", function (assert) {
<add>test('parse', function (assert) {
<ide> var tests = 'ianuarie ian._februarie febr._martie mart._aprilie apr._mai mai_iunie iun._iulie iul._august aug._septembrie sept._octombrie oct._noiembrie nov._decembrie dec.'.split('_'), i;
<ide> function equalTest(input, mmm, i) {
<ide> assert.equal(moment(input, mmm).month(), i, input + ' should be month ' + (i + 1));
<ide> test("parse", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("format", function (assert) {
<add>test('format', function (assert) {
<ide> var a = [
<ide> ['dddd, MMMM Do YYYY, h:mm:ss A', 'duminică, februarie 14 2010, 3:25:50 PM'],
<ide> ['ddd, hA', 'Dum, 3PM'],
<ide> test("format", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("format ordinal", function (assert) {
<add>test('format ordinal', function (assert) {
<ide> assert.equal(moment([2011, 0, 1]).format('DDDo'), '1', '1');
<ide> assert.equal(moment([2011, 0, 2]).format('DDDo'), '2', '2');
<ide> assert.equal(moment([2011, 0, 3]).format('DDDo'), '3', '3');
<ide> test("format ordinal", function (assert) {
<ide> assert.equal(moment([2011, 0, 31]).format('DDDo'), '31', '31');
<ide> });
<ide>
<del>test("format month", function (assert) {
<add>test('format month', function (assert) {
<ide> var expected = 'ianuarie ian._februarie febr._martie mart._aprilie apr._mai mai_iunie iun._iulie iul._august aug._septembrie sept._octombrie oct._noiembrie nov._decembrie dec.'.split('_'), i;
<ide> for (i = 0; i < expected.length; i++) {
<ide> assert.equal(moment([2011, i, 1]).format('MMMM MMM'), expected[i], expected[i]);
<ide> }
<ide> });
<ide>
<del>test("format week", function (assert) {
<add>test('format week', function (assert) {
<ide> var expected = 'duminică Dum Du_luni Lun Lu_marți Mar Ma_miercuri Mie Mi_joi Joi Jo_vineri Vin Vi_sâmbătă Sâm Sâ'.split('_'), i;
<ide> for (i = 0; i < expected.length; i++) {
<ide> assert.equal(moment([2011, 0, 2 + i]).format('dddd ddd dd'), expected[i], expected[i]);
<ide> }
<ide> });
<ide>
<del>test("from", function (assert) {
<add>test('from', function (assert) {
<ide> var start = moment([2007, 1, 28]);
<ide> assert.equal(start.from(moment([2007, 1, 28]).add({s: 44}), true), 'câteva secunde', '44 seconds = a few seconds');
<ide> assert.equal(start.from(moment([2007, 1, 28]).add({s: 45}), true), 'un minut', '45 seconds = a minute');
<ide> test("from", function (assert) {
<ide> assert.equal(start.from(moment([2007, 1, 28]).add({y: 220}), true), '220 de ani', '220 years = 220 years');
<ide> });
<ide>
<del>test("suffix", function (assert) {
<add>test('suffix', function (assert) {
<ide> assert.equal(moment(30000).from(0), 'peste câteva secunde', 'prefix');
<ide> assert.equal(moment(0).from(30000), 'câteva secunde în urmă', 'suffix');
<ide> });
<ide>
<del>test("now from now", function (assert) {
<add>test('now from now', function (assert) {
<ide> assert.equal(moment().fromNow(), 'câteva secunde în urmă', 'now from now should display as in the past');
<ide> });
<ide>
<del>test("fromNow", function (assert) {
<add>test('fromNow', function (assert) {
<ide> assert.equal(moment().add({s: 30}).fromNow(), 'peste câteva secunde', 'in a few seconds');
<ide> assert.equal(moment().add({d: 5}).fromNow(), 'peste 5 zile', 'in 5 days');
<ide> });
<ide>
<del>test("calendar day", function (assert) {
<add>test('calendar day', function (assert) {
<ide> var a = moment().hours(2).minutes(0).seconds(0);
<ide>
<ide> assert.equal(moment(a).calendar(), 'azi la 2:00', 'today at the same time');
<ide> test("calendar day", function (assert) {
<ide> assert.equal(moment(a).subtract({d: 1}).calendar(), 'ieri la 2:00', 'yesterday at the same time');
<ide> });
<ide>
<del>test("calendar next week", function (assert) {
<add>test('calendar next week', function (assert) {
<ide> var i, m;
<ide> for (i = 2; i < 7; i++) {
<ide> m = moment().add({d: i});
<ide> test("calendar next week", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("calendar last week", function (assert) {
<add>test('calendar last week', function (assert) {
<ide> var i, m;
<ide> for (i = 2; i < 7; i++) {
<ide> m = moment().subtract({d: i});
<ide> test("calendar last week", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("calendar all else", function (assert) {
<add>test('calendar all else', function (assert) {
<ide> var weeksAgo = moment().subtract({w: 1}),
<ide> weeksFromNow = moment().add({w: 1});
<ide>
<ide> test("calendar all else", function (assert) {
<ide> assert.equal(weeksFromNow.calendar(), weeksFromNow.format('L'), 'in 2 weeks');
<ide> });
<ide>
<del>test("weeks year starting sunday", function (assert) {
<add>test('weeks year starting sunday', function (assert) {
<ide> assert.equal(moment([2011, 11, 26]).week(), 1, 'Dec 26 2011 should be week 1');
<ide> assert.equal(moment([2012, 0, 1]).week(), 1, 'Jan 1 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 2]).week(), 2, 'Jan 2 2012 should be week 2');
<ide> assert.equal(moment([2012, 0, 8]).week(), 2, 'Jan 8 2012 should be week 2');
<ide> assert.equal(moment([2012, 0, 9]).week(), 3, 'Jan 9 2012 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting monday", function (assert) {
<add>test('weeks year starting monday', function (assert) {
<ide> assert.equal(moment([2007, 0, 1]).week(), 1, 'Jan 1 2007 should be week 1');
<ide> assert.equal(moment([2007, 0, 7]).week(), 1, 'Jan 7 2007 should be week 1');
<ide> assert.equal(moment([2007, 0, 8]).week(), 2, 'Jan 8 2007 should be week 2');
<ide> assert.equal(moment([2007, 0, 14]).week(), 2, 'Jan 14 2007 should be week 2');
<ide> assert.equal(moment([2007, 0, 15]).week(), 3, 'Jan 15 2007 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting tuesday", function (assert) {
<add>test('weeks year starting tuesday', function (assert) {
<ide> assert.equal(moment([2007, 11, 31]).week(), 1, 'Dec 31 2007 should be week 1');
<ide> assert.equal(moment([2008, 0, 1]).week(), 1, 'Jan 1 2008 should be week 1');
<ide> assert.equal(moment([2008, 0, 6]).week(), 1, 'Jan 6 2008 should be week 1');
<ide> test("weeks year starting tuesday", function (assert) {
<ide> assert.equal(moment([2008, 0, 14]).week(), 3, 'Jan 14 2008 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting wednesday", function (assert) {
<add>test('weeks year starting wednesday', function (assert) {
<ide> assert.equal(moment([2002, 11, 30]).week(), 1, 'Dec 30 2002 should be week 1');
<ide> assert.equal(moment([2003, 0, 1]).week(), 1, 'Jan 1 2003 should be week 1');
<ide> assert.equal(moment([2003, 0, 5]).week(), 1, 'Jan 5 2003 should be week 1');
<ide> test("weeks year starting wednesday", function (assert) {
<ide> assert.equal(moment([2003, 0, 13]).week(), 3, 'Jan 13 2003 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting thursday", function (assert) {
<add>test('weeks year starting thursday', function (assert) {
<ide> assert.equal(moment([2008, 11, 29]).week(), 1, 'Dec 29 2008 should be week 1');
<ide> assert.equal(moment([2009, 0, 1]).week(), 1, 'Jan 1 2009 should be week 1');
<ide> assert.equal(moment([2009, 0, 4]).week(), 1, 'Jan 4 2009 should be week 1');
<ide> test("weeks year starting thursday", function (assert) {
<ide> assert.equal(moment([2009, 0, 12]).week(), 3, 'Jan 12 2009 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting friday", function (assert) {
<add>test('weeks year starting friday', function (assert) {
<ide> assert.equal(moment([2009, 11, 28]).week(), 1, 'Dec 28 2009 should be week 1');
<ide> assert.equal(moment([2010, 0, 1]).week(), 1, 'Jan 1 2010 should be week 1');
<ide> assert.equal(moment([2010, 0, 3]).week(), 1, 'Jan 3 2010 should be week 1');
<ide> test("weeks year starting friday", function (assert) {
<ide> assert.equal(moment([2010, 0, 11]).week(), 3, 'Jan 11 2010 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting saturday", function (assert) {
<add>test('weeks year starting saturday', function (assert) {
<ide> assert.equal(moment([2010, 11, 27]).week(), 1, 'Dec 27 2010 should be week 1');
<ide> assert.equal(moment([2011, 0, 1]).week(), 1, 'Jan 1 2011 should be week 1');
<ide> assert.equal(moment([2011, 0, 2]).week(), 1, 'Jan 2 2011 should be week 1');
<ide> test("weeks year starting saturday", function (assert) {
<ide> assert.equal(moment([2011, 0, 10]).week(), 3, 'Jan 10 2011 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting sunday formatted", function (assert) {
<add>test('weeks year starting sunday formatted', function (assert) {
<ide> assert.equal(moment([2011, 11, 26]).format('w ww wo'), '1 01 1', 'Dec 26 2011 should be week 1');
<ide> assert.equal(moment([2012, 0, 1]).format('w ww wo'), '1 01 1', 'Jan 1 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 2]).format('w ww wo'), '2 02 2', 'Jan 2 2012 should be week 2');
<ide> assert.equal(moment([2012, 0, 8]).format('w ww wo'), '2 02 2', 'Jan 8 2012 should be week 2');
<ide> assert.equal(moment([2012, 0, 9]).format('w ww wo'), '3 03 3', 'Jan 9 2012 should be week 3');
<ide> });
<ide>
<del>test("lenient ordinal parsing", function (assert) {
<add>test('lenient ordinal parsing', function (assert) {
<ide> var i, ordinalStr, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> ordinalStr = moment([2014, 0, i]).format('YYYY MM Do');
<ide> test("lenient ordinal parsing", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("lenient ordinal parsing of number", function (assert) {
<add>test('lenient ordinal parsing of number', function (assert) {
<ide> var i, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> testMoment = moment('2014 01 ' + i, 'YYYY MM Do');
<ide> test("lenient ordinal parsing of number", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("strict ordinal parsing", function (assert) {
<add>test('strict ordinal parsing', function (assert) {
<ide> var i, ordinalStr, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> ordinalStr = moment([2014, 0, i]).format('YYYY MM Do');
<ide><path>src/test/locale/ru.js
<del>import {localeModule, test} from "../qunit";
<del>import {moment} from "../../moment";
<del>localeModule("ru");
<add>import {localeModule, test} from '../qunit';
<add>import {moment} from '../../moment';
<add>localeModule('ru');
<ide>
<del>test("parse", function (assert) {
<add>test('parse', function (assert) {
<ide> var tests = 'январь янв_февраль фев_март март_апрель апр_май май_июнь июнь_июль июль_август авг_сентябрь сен_октябрь окт_ноябрь ноя_декабрь дек'.split('_'), i;
<ide> function equalTest(input, mmm, i) {
<ide> assert.equal(moment(input, mmm).month(), i, input + ' should be month ' + (i + 1));
<ide> test("parse", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("parse exceptional case", function (assert) {
<add>test('parse exceptional case', function (assert) {
<ide> assert.equal(moment('11 мая 1989', ['DD MMMM YYYY']).format('DD-MM-YYYY'), '11-05-1989');
<ide> });
<ide>
<del>test("format", function (assert) {
<add>test('format', function (assert) {
<ide> var a = [
<ide> ['dddd, Do MMMM YYYY, HH:mm:ss', 'воскресенье, 14-го февраля 2010, 15:25:50'],
<ide> ['ddd, h A', 'вс, 3 дня'],
<ide> test("format", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("format meridiem", function (assert) {
<add>test('format meridiem', function (assert) {
<ide> assert.equal(moment([2012, 11, 28, 0, 0]).format('A'), 'ночи', 'night');
<ide> assert.equal(moment([2012, 11, 28, 3, 59]).format('A'), 'ночи', 'night');
<ide> assert.equal(moment([2012, 11, 28, 4, 0]).format('A'), 'утра', 'morning');
<ide> test("format meridiem", function (assert) {
<ide> assert.equal(moment([2012, 11, 28, 23, 59]).format('A'), 'вечера', 'evening');
<ide> });
<ide>
<del>test("format ordinal", function (assert) {
<add>test('format ordinal', function (assert) {
<ide> assert.equal(moment([2011, 0, 1]).format('DDDo'), '1-й', '1-й');
<ide> assert.equal(moment([2011, 0, 2]).format('DDDo'), '2-й', '2-й');
<ide> assert.equal(moment([2011, 0, 3]).format('DDDo'), '3-й', '3-й');
<ide> test("format ordinal", function (assert) {
<ide> assert.equal(moment([2011, 0, 31]).format('DDDo'), '31-й', '31-й');
<ide> });
<ide>
<del>test("format month", function (assert) {
<add>test('format month', function (assert) {
<ide> var expected = 'январь янв_февраль фев_март март_апрель апр_май май_июнь июнь_июль июль_август авг_сентябрь сен_октябрь окт_ноябрь ноя_декабрь дек'.split('_'), i;
<ide> for (i = 0; i < expected.length; i++) {
<ide> assert.equal(moment([2011, i, 1]).format('MMMM MMM'), expected[i], expected[i]);
<ide> }
<ide> });
<ide>
<del>test("format month case", function (assert) {
<add>test('format month case', function (assert) {
<ide> var months = {
<ide> 'nominative': 'январь_февраль_март_апрель_май_июнь_июль_август_сентябрь_октябрь_ноябрь_декабрь'.split('_'),
<ide> 'accusative': 'января_февраля_марта_апреля_мая_июня_июля_августа_сентября_октября_ноября_декабря'.split('_')
<ide> test("format month case", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("format month short case", function (assert) {
<add>test('format month short case', function (assert) {
<ide> var monthsShort = {
<ide> 'nominative': 'янв_фев_март_апр_май_июнь_июль_авг_сен_окт_ноя_дек'.split('_'),
<ide> 'accusative': 'янв_фев_мар_апр_мая_июня_июля_авг_сен_окт_ноя_дек'.split('_')
<ide> test("format month short case", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("format month case with escaped symbols", function (assert) {
<add>test('format month case with escaped symbols', function (assert) {
<ide> var months = {
<ide> 'nominative': 'январь_февраль_март_апрель_май_июнь_июль_август_сентябрь_октябрь_ноябрь_декабрь'.split('_'),
<ide> 'accusative': 'января_февраля_марта_апреля_мая_июня_июля_августа_сентября_октября_ноября_декабря'.split('_')
<ide> test("format month case with escaped symbols", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("format month short case with escaped symbols", function (assert) {
<add>test('format month short case with escaped symbols', function (assert) {
<ide> var monthsShort = {
<ide> 'nominative': 'янв_фев_март_апр_май_июнь_июль_авг_сен_окт_ноя_дек'.split('_'),
<ide> 'accusative': 'янв_фев_мар_апр_мая_июня_июля_авг_сен_окт_ноя_дек'.split('_')
<ide> test("format month short case with escaped symbols", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("format week", function (assert) {
<add>test('format week', function (assert) {
<ide> var expected = 'воскресенье вс вс_понедельник пн пн_вторник вт вт_среда ср ср_четверг чт чт_пятница пт пт_суббота сб сб'.split('_'), i;
<ide> for (i = 0; i < expected.length; i++) {
<ide> assert.equal(moment([2011, 0, 2 + i]).format('dddd ddd dd'), expected[i], expected[i]);
<ide> }
<ide> });
<ide>
<del>test("from", function (assert) {
<add>test('from', function (assert) {
<ide> var start = moment([2007, 1, 28]);
<ide> assert.equal(start.from(moment([2007, 1, 28]).add({s: 44}), true), 'несколько секунд', '44 seconds = seconds');
<ide> assert.equal(start.from(moment([2007, 1, 28]).add({s: 45}), true), 'минута', '45 seconds = a minute');
<ide> test("from", function (assert) {
<ide> assert.equal(start.from(moment([2007, 1, 28]).add({y: 5}), true), '5 лет', '5 years = 5 years');
<ide> });
<ide>
<del>test("suffix", function (assert) {
<add>test('suffix', function (assert) {
<ide> assert.equal(moment(30000).from(0), 'через несколько секунд', 'prefix');
<ide> assert.equal(moment(0).from(30000), 'несколько секунд назад', 'suffix');
<ide> });
<ide>
<del>test("fromNow", function (assert) {
<add>test('fromNow', function (assert) {
<ide> assert.equal(moment().add({s: 30}).fromNow(), 'через несколько секунд', 'in seconds');
<ide> assert.equal(moment().add({d: 5}).fromNow(), 'через 5 дней', 'in 5 days');
<ide> assert.equal(moment().add({m: 31}).fromNow(), 'через 31 минуту', 'in 31 minutes = in 31 minutes');
<ide> assert.equal(moment().subtract({m: 31}).fromNow(), '31 минуту назад', '31 minutes ago = 31 minutes ago');
<ide> });
<ide>
<del>test("calendar day", function (assert) {
<add>test('calendar day', function (assert) {
<ide> var a = moment().hours(2).minutes(0).seconds(0);
<ide>
<ide> assert.equal(moment(a).calendar(), 'Сегодня в 02:00', 'today at the same time');
<ide> test("calendar day", function (assert) {
<ide> assert.equal(moment(a).subtract({d: 1}).calendar(), 'Вчера в 02:00', 'yesterday at the same time');
<ide> });
<ide>
<del>test("calendar next week", function (assert) {
<add>test('calendar next week', function (assert) {
<ide> var i, m;
<ide> function makeFormat(d) {
<ide> return d.day() === 2 ? '[Во] dddd [в] LT' : '[В] dddd [в] LT';
<ide> test("calendar next week", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("calendar last week", function (assert) {
<add>test('calendar last week', function (assert) {
<ide> var i, m, now;
<ide>
<ide> function makeFormatLast(d) {
<ide> test("calendar last week", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("calendar all else", function (assert) {
<add>test('calendar all else', function (assert) {
<ide> var weeksAgo = moment().subtract({w: 1}),
<ide> weeksFromNow = moment().add({w: 1});
<ide>
<ide> test("calendar all else", function (assert) {
<ide> assert.equal(weeksFromNow.calendar(), weeksFromNow.format('L'), 'in 2 weeks');
<ide> });
<ide>
<del>test("weeks year starting sunday", function (assert) {
<add>test('weeks year starting sunday', function (assert) {
<ide> assert.equal(moment([2011, 11, 26]).week(), 1, 'Dec 26 2011 should be week 1');
<ide> assert.equal(moment([2012, 0, 1]).week(), 1, 'Jan 1 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 2]).week(), 2, 'Jan 2 2012 should be week 2');
<ide> assert.equal(moment([2012, 0, 8]).week(), 2, 'Jan 8 2012 should be week 2');
<ide> assert.equal(moment([2012, 0, 9]).week(), 3, 'Jan 9 2012 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting monday", function (assert) {
<add>test('weeks year starting monday', function (assert) {
<ide> assert.equal(moment([2007, 0, 1]).week(), 1, 'Jan 1 2007 should be week 1');
<ide> assert.equal(moment([2007, 0, 7]).week(), 1, 'Jan 7 2007 should be week 1');
<ide> assert.equal(moment([2007, 0, 8]).week(), 2, 'Jan 8 2007 should be week 2');
<ide> assert.equal(moment([2007, 0, 14]).week(), 2, 'Jan 14 2007 should be week 2');
<ide> assert.equal(moment([2007, 0, 15]).week(), 3, 'Jan 15 2007 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting tuesday", function (assert) {
<add>test('weeks year starting tuesday', function (assert) {
<ide> assert.equal(moment([2007, 11, 31]).week(), 1, 'Dec 31 2007 should be week 1');
<ide> assert.equal(moment([2008, 0, 1]).week(), 1, 'Jan 1 2008 should be week 1');
<ide> assert.equal(moment([2008, 0, 6]).week(), 1, 'Jan 6 2008 should be week 1');
<ide> test("weeks year starting tuesday", function (assert) {
<ide> assert.equal(moment([2008, 0, 14]).week(), 3, 'Jan 14 2008 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting wednesday", function (assert) {
<add>test('weeks year starting wednesday', function (assert) {
<ide> assert.equal(moment([2002, 11, 30]).week(), 1, 'Dec 30 2002 should be week 1');
<ide> assert.equal(moment([2003, 0, 1]).week(), 1, 'Jan 1 2003 should be week 1');
<ide> assert.equal(moment([2003, 0, 5]).week(), 1, 'Jan 5 2003 should be week 1');
<ide> test("weeks year starting wednesday", function (assert) {
<ide> assert.equal(moment([2003, 0, 13]).week(), 3, 'Jan 13 2003 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting thursday", function (assert) {
<add>test('weeks year starting thursday', function (assert) {
<ide> assert.equal(moment([2008, 11, 29]).week(), 1, 'Dec 29 2008 should be week 1');
<ide> assert.equal(moment([2009, 0, 1]).week(), 1, 'Jan 1 2009 should be week 1');
<ide> assert.equal(moment([2009, 0, 4]).week(), 1, 'Jan 4 2009 should be week 1');
<ide> test("weeks year starting thursday", function (assert) {
<ide> assert.equal(moment([2009, 0, 12]).week(), 3, 'Jan 12 2009 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting friday", function (assert) {
<add>test('weeks year starting friday', function (assert) {
<ide> assert.equal(moment([2009, 11, 28]).week(), 1, 'Dec 28 2009 should be week 1');
<ide> assert.equal(moment([2010, 0, 1]).week(), 1, 'Jan 1 2010 should be week 1');
<ide> assert.equal(moment([2010, 0, 3]).week(), 1, 'Jan 3 2010 should be week 1');
<ide> test("weeks year starting friday", function (assert) {
<ide> assert.equal(moment([2010, 0, 11]).week(), 3, 'Jan 11 2010 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting saturday", function (assert) {
<add>test('weeks year starting saturday', function (assert) {
<ide> assert.equal(moment([2010, 11, 27]).week(), 1, 'Dec 27 2010 should be week 1');
<ide> assert.equal(moment([2011, 0, 1]).week(), 1, 'Jan 1 2011 should be week 1');
<ide> assert.equal(moment([2011, 0, 2]).week(), 1, 'Jan 2 2011 should be week 1');
<ide> test("weeks year starting saturday", function (assert) {
<ide> assert.equal(moment([2011, 0, 10]).week(), 3, 'Jan 10 2011 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting sunday formatted", function (assert) {
<add>test('weeks year starting sunday formatted', function (assert) {
<ide> assert.equal(moment([2011, 11, 26]).format('w ww wo'), '1 01 1-я', 'Dec 26 2011 should be week 1');
<ide> assert.equal(moment([2012, 0, 1]).format('w ww wo'), '1 01 1-я', 'Jan 1 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 2]).format('w ww wo'), '2 02 2-я', 'Jan 2 2012 should be week 2');
<ide> assert.equal(moment([2012, 0, 8]).format('w ww wo'), '2 02 2-я', 'Jan 8 2012 should be week 2');
<ide> assert.equal(moment([2012, 0, 9]).format('w ww wo'), '3 03 3-я', 'Jan 9 2012 should be week 3');
<ide> });
<ide>
<del>test("lenient ordinal parsing", function (assert) {
<add>test('lenient ordinal parsing', function (assert) {
<ide> var i, ordinalStr, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> ordinalStr = moment([2014, 0, i]).format('YYYY MM Do');
<ide> test("lenient ordinal parsing", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("lenient ordinal parsing of number", function (assert) {
<add>test('lenient ordinal parsing of number', function (assert) {
<ide> var i, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> testMoment = moment('2014 01 ' + i, 'YYYY MM Do');
<ide> test("lenient ordinal parsing of number", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("strict ordinal parsing", function (assert) {
<add>test('strict ordinal parsing', function (assert) {
<ide> var i, ordinalStr, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> ordinalStr = moment([2014, 0, i]).format('YYYY MM Do');
<ide><path>src/test/locale/sk.js
<del>import {localeModule, test} from "../qunit";
<del>import {moment} from "../../moment";
<del>localeModule("sk");
<add>import {localeModule, test} from '../qunit';
<add>import {moment} from '../../moment';
<add>localeModule('sk');
<ide>
<del>test("parse", function (assert) {
<add>test('parse', function (assert) {
<ide> var tests = 'január jan._február feb._marec mar._apríl apr._máj máj_jún jún._júl júl._august aug._september sep._október okt._november nov._december dec.'.split('_'), i;
<ide> function equalTest(input, mmm, monthIndex) {
<ide> assert.equal(moment(input, mmm).month(), monthIndex, input + ' should be month ' + (monthIndex + 1));
<ide> test("parse", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("format", function (assert) {
<add>test('format', function (assert) {
<ide> var a = [
<ide> ['dddd, MMMM Do YYYY, h:mm:ss', 'nedeľa, február 14. 2010, 3:25:50'],
<ide> ['ddd, h', 'ne, 3'],
<ide> test("format", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("format ordinal", function (assert) {
<add>test('format ordinal', function (assert) {
<ide> assert.equal(moment([2011, 0, 1]).format('DDDo'), '1.', '1.');
<ide> assert.equal(moment([2011, 0, 2]).format('DDDo'), '2.', '2.');
<ide> assert.equal(moment([2011, 0, 3]).format('DDDo'), '3.', '3.');
<ide> test("format ordinal", function (assert) {
<ide> assert.equal(moment([2011, 0, 31]).format('DDDo'), '31.', '31.');
<ide> });
<ide>
<del>test("format month", function (assert) {
<add>test('format month', function (assert) {
<ide> var expected = 'január jan_február feb_marec mar_apríl apr_máj máj_jún jún_júl júl_august aug_september sep_október okt_november nov_december dec'.split('_'), i;
<ide> for (i = 0; i < expected.length; i++) {
<ide> assert.equal(moment([2011, i, 1]).format('MMMM MMM'), expected[i], expected[i]);
<ide> }
<ide> });
<ide>
<del>test("format week", function (assert) {
<add>test('format week', function (assert) {
<ide> var expected = 'nedeľa ne ne_pondelok po po_utorok ut ut_streda st st_štvrtok št št_piatok pi pi_sobota so so'.split('_'), i;
<ide> for (i = 0; i < expected.length; i++) {
<ide> assert.equal(moment([2011, 0, 2 + i]).format('dddd ddd dd'), expected[i], expected[i]);
<ide> }
<ide> });
<ide>
<del>test("from", function (assert) {
<add>test('from', function (assert) {
<ide> var start = moment([2007, 1, 28]);
<ide> assert.equal(start.from(moment([2007, 1, 28]).add({s: 44}), true), 'pár sekúnd', '44 seconds = a few seconds');
<ide> assert.equal(start.from(moment([2007, 1, 28]).add({s: 45}), true), 'minúta', '45 seconds = a minute');
<ide> test("from", function (assert) {
<ide> assert.equal(start.from(moment([2007, 1, 28]).add({y: 5}), true), '5 rokov', '5 years = 5 years');
<ide> });
<ide>
<del>test("suffix", function (assert) {
<add>test('suffix', function (assert) {
<ide> assert.equal(moment(30000).from(0), 'za pár sekúnd', 'prefix');
<ide> assert.equal(moment(0).from(30000), 'pred pár sekundami', 'suffix');
<ide> });
<ide>
<del>test("now from now", function (assert) {
<add>test('now from now', function (assert) {
<ide> assert.equal(moment().fromNow(), 'pred pár sekundami', 'now from now should display as in the past');
<ide> });
<ide>
<del>test("fromNow (future)", function (assert) {
<add>test('fromNow (future)', function (assert) {
<ide> assert.equal(moment().add({s: 30}).fromNow(), 'za pár sekúnd', 'in a few seconds');
<ide> assert.equal(moment().add({m: 1}).fromNow(), 'za minútu', 'in a minute');
<ide> assert.equal(moment().add({m: 3}).fromNow(), 'za 3 minúty', 'in 3 minutes');
<ide> test("fromNow (future)", function (assert) {
<ide> assert.equal(moment().add({y: 10}).fromNow(), 'za 10 rokov', 'in 10 years');
<ide> });
<ide>
<del>test("fromNow (past)", function (assert) {
<add>test('fromNow (past)', function (assert) {
<ide> assert.equal(moment().subtract({s: 30}).fromNow(), 'pred pár sekundami', 'a few seconds ago');
<ide> assert.equal(moment().subtract({m: 1}).fromNow(), 'pred minútou', 'a minute ago');
<ide> assert.equal(moment().subtract({m: 3}).fromNow(), 'pred 3 minútami', '3 minutes ago');
<ide> test("fromNow (past)", function (assert) {
<ide> assert.equal(moment().subtract({y: 10}).fromNow(), 'pred 10 rokmi', '10 years ago');
<ide> });
<ide>
<del>test("calendar day", function (assert) {
<add>test('calendar day', function (assert) {
<ide> var a = moment().hours(2).minutes(0).seconds(0);
<ide>
<ide> assert.equal(moment(a).calendar(), 'dnes o 2:00', 'today at the same time');
<ide> test("calendar day", function (assert) {
<ide> assert.equal(moment(a).subtract({d: 1}).calendar(), 'včera o 2:00', 'yesterday at the same time');
<ide> });
<ide>
<del>test("calendar next week", function (assert) {
<add>test('calendar next week', function (assert) {
<ide> var i, m, nextDay;
<ide> for (i = 2; i < 7; i++) {
<ide> m = moment().add({d: i});
<ide> test("calendar next week", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("calendar last week", function (assert) {
<add>test('calendar last week', function (assert) {
<ide> var i, m, lastDay;
<ide> for (i = 2; i < 7; i++) {
<ide> m = moment().subtract({d: i});
<ide> test("calendar last week", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("calendar all else", function (assert) {
<add>test('calendar all else', function (assert) {
<ide> var weeksAgo = moment().subtract({w: 1}),
<ide> weeksFromNow = moment().add({w: 1});
<ide>
<ide> test("calendar all else", function (assert) {
<ide> assert.equal(weeksFromNow.calendar(), weeksFromNow.format('L'), 'in 2 weeks');
<ide> });
<ide>
<del>test("humanize duration", function (assert) {
<add>test('humanize duration', function (assert) {
<ide> assert.equal(moment.duration(1, 'minutes').humanize(), 'minúta', 'a minute (future)');
<ide> assert.equal(moment.duration(1, 'minutes').humanize(true), 'za minútu', 'in a minute');
<ide> assert.equal(moment.duration(-1, 'minutes').humanize(), 'minúta', 'a minute (past)');
<ide> assert.equal(moment.duration(-1, 'minutes').humanize(true), 'pred minútou', 'a minute ago');
<ide> });
<ide>
<del>test("weeks year starting sunday", function (assert) {
<add>test('weeks year starting sunday', function (assert) {
<ide> assert.equal(moment([2012, 0, 1]).week(), 52, 'Jan 1 2012 should be week 52');
<ide> assert.equal(moment([2012, 0, 2]).week(), 1, 'Jan 2 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 8]).week(), 1, 'Jan 8 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 9]).week(), 2, 'Jan 9 2012 should be week 2');
<ide> assert.equal(moment([2012, 0, 15]).week(), 2, 'Jan 15 2012 should be week 2');
<ide> });
<ide>
<del>test("weeks year starting monday", function (assert) {
<add>test('weeks year starting monday', function (assert) {
<ide> assert.equal(moment([2007, 0, 1]).week(), 1, 'Jan 1 2007 should be week 1');
<ide> assert.equal(moment([2007, 0, 7]).week(), 1, 'Jan 7 2007 should be week 1');
<ide> assert.equal(moment([2007, 0, 8]).week(), 2, 'Jan 8 2007 should be week 2');
<ide> assert.equal(moment([2007, 0, 14]).week(), 2, 'Jan 14 2007 should be week 2');
<ide> assert.equal(moment([2007, 0, 15]).week(), 3, 'Jan 15 2007 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting tuesday", function (assert) {
<add>test('weeks year starting tuesday', function (assert) {
<ide> assert.equal(moment([2007, 11, 31]).week(), 1, 'Dec 31 2007 should be week 1');
<ide> assert.equal(moment([2008, 0, 1]).week(), 1, 'Jan 1 2008 should be week 1');
<ide> assert.equal(moment([2008, 0, 6]).week(), 1, 'Jan 6 2008 should be week 1');
<ide> test("weeks year starting tuesday", function (assert) {
<ide> assert.equal(moment([2008, 0, 14]).week(), 3, 'Jan 14 2008 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting wednesday", function (assert) {
<add>test('weeks year starting wednesday', function (assert) {
<ide> assert.equal(moment([2002, 11, 30]).week(), 1, 'Dec 30 2002 should be week 1');
<ide> assert.equal(moment([2003, 0, 1]).week(), 1, 'Jan 1 2003 should be week 1');
<ide> assert.equal(moment([2003, 0, 5]).week(), 1, 'Jan 5 2003 should be week 1');
<ide> test("weeks year starting wednesday", function (assert) {
<ide> assert.equal(moment([2003, 0, 13]).week(), 3, 'Jan 13 2003 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting thursday", function (assert) {
<add>test('weeks year starting thursday', function (assert) {
<ide> assert.equal(moment([2008, 11, 29]).week(), 1, 'Dec 29 2008 should be week 1');
<ide> assert.equal(moment([2009, 0, 1]).week(), 1, 'Jan 1 2009 should be week 1');
<ide> assert.equal(moment([2009, 0, 4]).week(), 1, 'Jan 4 2009 should be week 1');
<ide> test("weeks year starting thursday", function (assert) {
<ide> assert.equal(moment([2009, 0, 13]).week(), 3, 'Jan 12 2009 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting friday", function (assert) {
<add>test('weeks year starting friday', function (assert) {
<ide> assert.equal(moment([2009, 11, 28]).week(), 53, 'Dec 28 2009 should be week 53');
<ide> assert.equal(moment([2010, 0, 1]).week(), 53, 'Jan 1 2010 should be week 53');
<ide> assert.equal(moment([2010, 0, 3]).week(), 53, 'Jan 3 2010 should be week 53');
<ide> test("weeks year starting friday", function (assert) {
<ide> assert.equal(moment([2010, 0, 11]).week(), 2, 'Jan 11 2010 should be week 2');
<ide> });
<ide>
<del>test("weeks year starting saturday", function (assert) {
<add>test('weeks year starting saturday', function (assert) {
<ide> assert.equal(moment([2010, 11, 27]).week(), 52, 'Dec 27 2010 should be week 52');
<ide> assert.equal(moment([2011, 0, 1]).week(), 52, 'Jan 1 2011 should be week 52');
<ide> assert.equal(moment([2011, 0, 2]).week(), 52, 'Jan 2 2011 should be week 52');
<ide> test("weeks year starting saturday", function (assert) {
<ide> assert.equal(moment([2011, 0, 10]).week(), 2, 'Jan 10 2011 should be week 2');
<ide> });
<ide>
<del>test("weeks year starting sunday formatted", function (assert) {
<add>test('weeks year starting sunday formatted', function (assert) {
<ide> assert.equal(moment([2012, 0, 1]).format('w ww wo'), '52 52 52.', 'Jan 1 2012 should be week 52');
<ide> assert.equal(moment([2012, 0, 2]).format('w ww wo'), '1 01 1.', 'Jan 2 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 8]).format('w ww wo'), '1 01 1.', 'Jan 8 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 9]).format('w ww wo'), '2 02 2.', 'Jan 9 2012 should be week 2');
<ide> assert.equal(moment([2012, 0, 15]).format('w ww wo'), '2 02 2.', 'Jan 15 2012 should be week 2');
<ide> });
<ide>
<del>test("lenient ordinal parsing", function (assert) {
<add>test('lenient ordinal parsing', function (assert) {
<ide> var i, ordinalStr, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> ordinalStr = moment([2014, 0, i]).format('YYYY MM Do');
<ide> test("lenient ordinal parsing", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("lenient ordinal parsing of number", function (assert) {
<add>test('lenient ordinal parsing of number', function (assert) {
<ide> var i, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> testMoment = moment('2014 01 ' + i, 'YYYY MM Do');
<ide> test("lenient ordinal parsing of number", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("strict ordinal parsing", function (assert) {
<add>test('strict ordinal parsing', function (assert) {
<ide> var i, ordinalStr, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> ordinalStr = moment([2014, 0, i]).format('YYYY MM Do');
<ide><path>src/test/locale/sl.js
<del>import {localeModule, test} from "../qunit";
<del>import {moment} from "../../moment";
<del>localeModule("sl");
<add>import {localeModule, test} from '../qunit';
<add>import {moment} from '../../moment';
<add>localeModule('sl');
<ide>
<del>test("parse", function (assert) {
<add>test('parse', function (assert) {
<ide> var tests = 'januar jan._februar feb._marec mar._april apr._maj maj_junij jun._julij jul._avgust avg._september sep._oktober okt._november nov._december dec.'.split('_'), i;
<ide> function equalTest(input, mmm, i) {
<ide> assert.equal(moment(input, mmm).month(), i, input + ' should be month ' + (i + 1));
<ide> test("parse", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("format", function (assert) {
<add>test('format', function (assert) {
<ide> var a = [
<ide> ['dddd, Do MMMM YYYY, h:mm:ss a', 'nedelja, 14. februar 2010, 3:25:50 pm'],
<ide> ['ddd, hA', 'ned., 3PM'],
<ide> test("format", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("format ordinal", function (assert) {
<add>test('format ordinal', function (assert) {
<ide> assert.equal(moment([2011, 0, 1]).format('DDDo'), '1.', '1.');
<ide> assert.equal(moment([2011, 0, 2]).format('DDDo'), '2.', '2.');
<ide> assert.equal(moment([2011, 0, 3]).format('DDDo'), '3.', '3.');
<ide> test("format ordinal", function (assert) {
<ide> assert.equal(moment([2011, 0, 31]).format('DDDo'), '31.', '31.');
<ide> });
<ide>
<del>test("format month", function (assert) {
<add>test('format month', function (assert) {
<ide> var expected = 'januar jan._februar feb._marec mar._april apr._maj maj._junij jun._julij jul._avgust avg._september sep._oktober okt._november nov._december dec.'.split('_'), i;
<ide> for (i = 0; i < expected.length; i++) {
<ide> assert.equal(moment([2011, i, 1]).format('MMMM MMM'), expected[i], expected[i]);
<ide> }
<ide> });
<ide>
<del>test("format week", function (assert) {
<add>test('format week', function (assert) {
<ide> var expected = 'nedelja ned. ne_ponedeljek pon. po_torek tor. to_sreda sre. sr_četrtek čet. če_petek pet. pe_sobota sob. so'.split('_'), i;
<ide> for (i = 0; i < expected.length; i++) {
<ide> assert.equal(moment([2011, 0, 2 + i]).format('dddd ddd dd'), expected[i], expected[i]);
<ide> }
<ide> });
<ide>
<del>test("from", function (assert) {
<add>test('from', function (assert) {
<ide> var start = moment([2007, 1, 28]);
<ide> assert.equal(start.from(moment([2007, 1, 28]).add({s: 44}), true), 'nekaj sekund', '44 seconds = a few seconds');
<ide> assert.equal(start.from(moment([2007, 1, 28]).add({s: 45}), true), 'ena minuta', '45 seconds = a minute');
<ide> test("from", function (assert) {
<ide> assert.equal(start.from(moment([2007, 1, 28]).add({y: 5}), true), '5 let', '5 years = 5 years');
<ide> });
<ide>
<del>test("suffix", function (assert) {
<add>test('suffix', function (assert) {
<ide> assert.equal(moment(30000).from(0), 'čez nekaj sekund', 'prefix');
<ide> assert.equal(moment(0).from(30000), 'nekaj sekund nazaj', 'suffix');
<ide> });
<ide>
<del>test("now from now", function (assert) {
<add>test('now from now', function (assert) {
<ide> assert.equal(moment().fromNow(), 'nekaj sekund nazaj', 'now from now should display as in the past');
<ide> });
<ide>
<del>test("fromNow", function (assert) {
<add>test('fromNow', function (assert) {
<ide> assert.equal(moment().add({s: 30}).fromNow(), 'čez nekaj sekund', 'in a few seconds');
<ide> assert.equal(moment().add({d: 5}).fromNow(), 'čez 5 dni', 'in 5 days');
<ide> });
<ide>
<del>test("calendar day", function (assert) {
<add>test('calendar day', function (assert) {
<ide> var a = moment().hours(2).minutes(0).seconds(0);
<ide>
<ide> assert.equal(moment(a).calendar(), 'danes ob 2:00', 'today at the same time');
<ide> test("calendar day", function (assert) {
<ide> assert.equal(moment(a).subtract({d: 1}).calendar(), 'včeraj ob 2:00', 'yesterday at the same time');
<ide> });
<ide>
<del>test("calendar next week", function (assert) {
<add>test('calendar next week', function (assert) {
<ide> var i, m;
<ide>
<ide> function makeFormat(d) {
<ide> test("calendar next week", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("calendar last week", function (assert) {
<add>test('calendar last week', function (assert) {
<ide> var i, m;
<ide>
<ide> function makeFormat(d) {
<ide> test("calendar last week", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("calendar all else", function (assert) {
<add>test('calendar all else', function (assert) {
<ide> var weeksAgo = moment().subtract({w: 1}),
<ide> weeksFromNow = moment().add({w: 1});
<ide>
<ide> test("calendar all else", function (assert) {
<ide> assert.equal(weeksFromNow.calendar(), weeksFromNow.format('L'), 'in 2 weeks');
<ide> });
<ide>
<del>test("weeks year starting sunday", function (assert) {
<add>test('weeks year starting sunday', function (assert) {
<ide> assert.equal(moment([2011, 11, 26]).week(), 1, 'Dec 26 2011 should be week 1');
<ide> assert.equal(moment([2012, 0, 1]).week(), 1, 'Jan 1 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 2]).week(), 2, 'Jan 2 2012 should be week 2');
<ide> assert.equal(moment([2012, 0, 8]).week(), 2, 'Jan 8 2012 should be week 2');
<ide> assert.equal(moment([2012, 0, 9]).week(), 3, 'Jan 9 2012 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting monday", function (assert) {
<add>test('weeks year starting monday', function (assert) {
<ide> assert.equal(moment([2007, 0, 1]).week(), 1, 'Jan 1 2007 should be week 1');
<ide> assert.equal(moment([2007, 0, 7]).week(), 1, 'Jan 7 2007 should be week 1');
<ide> assert.equal(moment([2007, 0, 8]).week(), 2, 'Jan 8 2007 should be week 2');
<ide> assert.equal(moment([2007, 0, 14]).week(), 2, 'Jan 14 2007 should be week 2');
<ide> assert.equal(moment([2007, 0, 15]).week(), 3, 'Jan 15 2007 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting tuesday", function (assert) {
<add>test('weeks year starting tuesday', function (assert) {
<ide> assert.equal(moment([2007, 11, 31]).week(), 1, 'Dec 31 2007 should be week 1');
<ide> assert.equal(moment([2008, 0, 1]).week(), 1, 'Jan 1 2008 should be week 1');
<ide> assert.equal(moment([2008, 0, 6]).week(), 1, 'Jan 6 2008 should be week 1');
<ide> test("weeks year starting tuesday", function (assert) {
<ide> assert.equal(moment([2008, 0, 14]).week(), 3, 'Jan 14 2008 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting wednesday", function (assert) {
<add>test('weeks year starting wednesday', function (assert) {
<ide> assert.equal(moment([2002, 11, 30]).week(), 1, 'Dec 30 2002 should be week 1');
<ide> assert.equal(moment([2003, 0, 1]).week(), 1, 'Jan 1 2003 should be week 1');
<ide> assert.equal(moment([2003, 0, 5]).week(), 1, 'Jan 5 2003 should be week 1');
<ide> test("weeks year starting wednesday", function (assert) {
<ide> assert.equal(moment([2003, 0, 13]).week(), 3, 'Jan 13 2003 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting thursday", function (assert) {
<add>test('weeks year starting thursday', function (assert) {
<ide> assert.equal(moment([2008, 11, 29]).week(), 1, 'Dec 29 2008 should be week 1');
<ide> assert.equal(moment([2009, 0, 1]).week(), 1, 'Jan 1 2009 should be week 1');
<ide> assert.equal(moment([2009, 0, 4]).week(), 1, 'Jan 4 2009 should be week 1');
<ide> test("weeks year starting thursday", function (assert) {
<ide> assert.equal(moment([2009, 0, 12]).week(), 3, 'Jan 12 2009 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting friday", function (assert) {
<add>test('weeks year starting friday', function (assert) {
<ide> assert.equal(moment([2009, 11, 28]).week(), 1, 'Dec 28 2009 should be week 1');
<ide> assert.equal(moment([2010, 0, 1]).week(), 1, 'Jan 1 2010 should be week 1');
<ide> assert.equal(moment([2010, 0, 3]).week(), 1, 'Jan 3 2010 should be week 1');
<ide> test("weeks year starting friday", function (assert) {
<ide> assert.equal(moment([2010, 0, 11]).week(), 3, 'Jan 11 2010 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting saturday", function (assert) {
<add>test('weeks year starting saturday', function (assert) {
<ide> assert.equal(moment([2010, 11, 27]).week(), 1, 'Dec 27 2010 should be week 1');
<ide> assert.equal(moment([2011, 0, 1]).week(), 1, 'Jan 1 2011 should be week 1');
<ide> assert.equal(moment([2011, 0, 2]).week(), 1, 'Jan 2 2011 should be week 1');
<ide> test("weeks year starting saturday", function (assert) {
<ide> assert.equal(moment([2011, 0, 10]).week(), 3, 'Jan 10 2011 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting sunday formatted", function (assert) {
<add>test('weeks year starting sunday formatted', function (assert) {
<ide> assert.equal(moment([2011, 11, 26]).format('w ww wo'), '1 01 1.', 'Dec 26 2011 should be week 1');
<ide> assert.equal(moment([2012, 0, 1]).format('w ww wo'), '1 01 1.', 'Jan 1 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 2]).format('w ww wo'), '2 02 2.', 'Jan 2 2012 should be week 2');
<ide> assert.equal(moment([2012, 0, 8]).format('w ww wo'), '2 02 2.', 'Jan 8 2012 should be week 2');
<ide> assert.equal(moment([2012, 0, 9]).format('w ww wo'), '3 03 3.', 'Jan 9 2012 should be week 3');
<ide> });
<ide>
<del>test("lenient ordinal parsing", function (assert) {
<add>test('lenient ordinal parsing', function (assert) {
<ide> var i, ordinalStr, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> ordinalStr = moment([2014, 0, i]).format('YYYY MM Do');
<ide> test("lenient ordinal parsing", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("lenient ordinal parsing of number", function (assert) {
<add>test('lenient ordinal parsing of number', function (assert) {
<ide> var i, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> testMoment = moment('2014 01 ' + i, 'YYYY MM Do');
<ide> test("lenient ordinal parsing of number", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("strict ordinal parsing", function (assert) {
<add>test('strict ordinal parsing', function (assert) {
<ide> var i, ordinalStr, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> ordinalStr = moment([2014, 0, i]).format('YYYY MM Do');
<ide><path>src/test/locale/sq.js
<del>import {localeModule, test} from "../qunit";
<del>import {moment} from "../../moment";
<del>localeModule("sq");
<add>import {localeModule, test} from '../qunit';
<add>import {moment} from '../../moment';
<add>localeModule('sq');
<ide>
<del>test("parse", function (assert) {
<add>test('parse', function (assert) {
<ide> var i,
<ide> tests = 'Janar Jan_Shkurt Shk_Mars Mar_Prill Pri_Maj Maj_Qershor Qer_Korrik Kor_Gusht Gus_Shtator Sht_Tetor Tet_Nëntor Nën_Dhjetor Dhj'.split('_');
<ide>
<ide> test("parse", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("format", function (assert) {
<add>test('format', function (assert) {
<ide> var a = [
<ide> ['dddd, MMMM Do YYYY, HH:mm:ss', 'E Diel, Shkurt 14. 2010, 15:25:50'],
<ide> ['ddd, HH', 'Die, 15'],
<ide> test("format", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("meridiem", function (assert) {
<add>test('meridiem', function (assert) {
<ide> assert.equal(moment([2011, 2, 23, 0, 0]).format('A'), 'PD', 'before dawn');
<ide> assert.equal(moment([2011, 2, 23, 12, 0]).format('A'), 'MD', 'noon');
<ide> });
<ide>
<del>test("format ordinal", function (assert) {
<add>test('format ordinal', function (assert) {
<ide> assert.equal(moment([2011, 0, 1]).format('DDDo'), '1.', '1.');
<ide> assert.equal(moment([2011, 0, 2]).format('DDDo'), '2.', '2.');
<ide> assert.equal(moment([2011, 0, 3]).format('DDDo'), '3.', '3.');
<ide> test("format ordinal", function (assert) {
<ide> assert.equal(moment([2011, 0, 31]).format('DDDo'), '31.', '31.');
<ide> });
<ide>
<del>test("format month", function (assert) {
<add>test('format month', function (assert) {
<ide> var i,
<ide> expected = 'Janar Jan_Shkurt Shk_Mars Mar_Prill Pri_Maj Maj_Qershor Qer_Korrik Kor_Gusht Gus_Shtator Sht_Tetor Tet_Nëntor Nën_Dhjetor Dhj'.split('_');
<ide>
<ide> test("format month", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("format week", function (assert) {
<add>test('format week', function (assert) {
<ide> var i,
<ide> expected = 'E Diel Die D_E Hënë Hën H_E Martë Mar Ma_E Mërkurë Mër Më_E Enjte Enj E_E Premte Pre P_E Shtunë Sht Sh'.split('_');
<ide>
<ide> test("format week", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("from", function (assert) {
<add>test('from', function (assert) {
<ide> var start = moment([2007, 1, 28]);
<ide>
<ide> assert.equal(start.from(moment([2007, 1, 28]).add({s: 44}), true), 'disa sekonda', '44 seconds = a few seconds');
<ide> test("from", function (assert) {
<ide> assert.equal(start.from(moment([2007, 1, 28]).add({y: 5}), true), '5 vite', '5 years = 5 years');
<ide> });
<ide>
<del>test("suffix", function (assert) {
<add>test('suffix', function (assert) {
<ide> assert.equal(moment(30000).from(0), 'në disa sekonda', 'prefix');
<ide> assert.equal(moment(0).from(30000), 'disa sekonda më parë', 'suffix');
<ide> });
<ide>
<del>test("now from now", function (assert) {
<add>test('now from now', function (assert) {
<ide> assert.equal(moment().fromNow(), 'disa sekonda më parë', 'now from now should display as in the past');
<ide> });
<ide>
<del>test("fromNow", function (assert) {
<add>test('fromNow', function (assert) {
<ide> assert.equal(moment().add({s: 30}).fromNow(), 'në disa sekonda', 'in a few seconds');
<ide> assert.equal(moment().add({d: 5}).fromNow(), 'në 5 ditë', 'in 5 days');
<ide> });
<ide>
<del>test("calendar day", function (assert) {
<add>test('calendar day', function (assert) {
<ide> var a = moment().hours(2).minutes(0).seconds(0);
<ide>
<ide> assert.equal(moment(a).calendar(), 'Sot në 02:00', 'today at the same time');
<ide> test("calendar day", function (assert) {
<ide> assert.equal(moment(a).subtract({d: 1}).calendar(), 'Dje në 02:00', 'yesterday at the same time');
<ide> });
<ide>
<del>test("calendar next week", function (assert) {
<add>test('calendar next week', function (assert) {
<ide> var i, m;
<ide>
<ide> for (i = 2; i < 7; i++) {
<ide> test("calendar next week", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("calendar last week", function (assert) {
<add>test('calendar last week', function (assert) {
<ide> var i, m;
<ide>
<ide> for (i = 2; i < 7; i++) {
<ide> test("calendar last week", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("calendar all else", function (assert) {
<add>test('calendar all else', function (assert) {
<ide> var weeksAgo = moment().subtract({w: 1}),
<ide> weeksFromNow = moment().add({w: 1});
<ide>
<ide> test("calendar all else", function (assert) {
<ide> assert.equal(weeksFromNow.calendar(), weeksFromNow.format('L'), 'in 2 weeks');
<ide> });
<ide>
<del>test("weeks year starting sunday", function (assert) {
<add>test('weeks year starting sunday', function (assert) {
<ide> assert.equal(moment([2012, 0, 1]).week(), 52, 'Jan 1 2012 should be week 52');
<ide> assert.equal(moment([2012, 0, 2]).week(), 1, 'Jan 2 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 8]).week(), 1, 'Jan 8 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 9]).week(), 2, 'Jan 9 2012 should be week 2');
<ide> assert.equal(moment([2012, 0, 15]).week(), 2, 'Jan 15 2012 should be week 2');
<ide> });
<ide>
<del>test("weeks year starting monday", function (assert) {
<add>test('weeks year starting monday', function (assert) {
<ide> assert.equal(moment([2007, 0, 1]).week(), 1, 'Jan 1 2007 should be week 1');
<ide> assert.equal(moment([2007, 0, 7]).week(), 1, 'Jan 7 2007 should be week 1');
<ide> assert.equal(moment([2007, 0, 8]).week(), 2, 'Jan 8 2007 should be week 2');
<ide> assert.equal(moment([2007, 0, 14]).week(), 2, 'Jan 14 2007 should be week 2');
<ide> assert.equal(moment([2007, 0, 15]).week(), 3, 'Jan 15 2007 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting tuesday", function (assert) {
<add>test('weeks year starting tuesday', function (assert) {
<ide> assert.equal(moment([2007, 11, 31]).week(), 1, 'Dec 31 2007 should be week 1');
<ide> assert.equal(moment([2008, 0, 1]).week(), 1, 'Jan 1 2008 should be week 1');
<ide> assert.equal(moment([2008, 0, 6]).week(), 1, 'Jan 6 2008 should be week 1');
<ide> test("weeks year starting tuesday", function (assert) {
<ide> assert.equal(moment([2008, 0, 14]).week(), 3, 'Jan 14 2008 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting wednesday", function (assert) {
<add>test('weeks year starting wednesday', function (assert) {
<ide> assert.equal(moment([2002, 11, 30]).week(), 1, 'Dec 30 2002 should be week 1');
<ide> assert.equal(moment([2003, 0, 1]).week(), 1, 'Jan 1 2003 should be week 1');
<ide> assert.equal(moment([2003, 0, 5]).week(), 1, 'Jan 5 2003 should be week 1');
<ide> test("weeks year starting wednesday", function (assert) {
<ide> assert.equal(moment([2003, 0, 13]).week(), 3, 'Jan 13 2003 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting thursday", function (assert) {
<add>test('weeks year starting thursday', function (assert) {
<ide> assert.equal(moment([2008, 11, 29]).week(), 1, 'Dec 29 2008 should be week 1');
<ide> assert.equal(moment([2009, 0, 1]).week(), 1, 'Jan 1 2009 should be week 1');
<ide> assert.equal(moment([2009, 0, 4]).week(), 1, 'Jan 4 2009 should be week 1');
<ide> test("weeks year starting thursday", function (assert) {
<ide> assert.equal(moment([2009, 0, 13]).week(), 3, 'Jan 12 2009 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting friday", function (assert) {
<add>test('weeks year starting friday', function (assert) {
<ide> assert.equal(moment([2009, 11, 28]).week(), 53, 'Dec 28 2009 should be week 53');
<ide> assert.equal(moment([2010, 0, 1]).week(), 53, 'Jan 1 2010 should be week 53');
<ide> assert.equal(moment([2010, 0, 3]).week(), 53, 'Jan 3 2010 should be week 53');
<ide> test("weeks year starting friday", function (assert) {
<ide> assert.equal(moment([2010, 0, 11]).week(), 2, 'Jan 11 2010 should be week 2');
<ide> });
<ide>
<del>test("weeks year starting saturday", function (assert) {
<add>test('weeks year starting saturday', function (assert) {
<ide> assert.equal(moment([2010, 11, 27]).week(), 52, 'Dec 27 2010 should be week 52');
<ide> assert.equal(moment([2011, 0, 1]).week(), 52, 'Jan 1 2011 should be week 52');
<ide> assert.equal(moment([2011, 0, 2]).week(), 52, 'Jan 2 2011 should be week 52');
<ide> test("weeks year starting saturday", function (assert) {
<ide> assert.equal(moment([2011, 0, 10]).week(), 2, 'Jan 10 2011 should be week 2');
<ide> });
<ide>
<del>test("weeks year starting sunday formatted", function (assert) {
<add>test('weeks year starting sunday formatted', function (assert) {
<ide> assert.equal(moment([2012, 0, 1]).format('w ww wo'), '52 52 52.', 'Jan 1 2012 should be week 52');
<ide> assert.equal(moment([2012, 0, 2]).format('w ww wo'), '1 01 1.', 'Jan 2 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 8]).format('w ww wo'), '1 01 1.', 'Jan 8 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 9]).format('w ww wo'), '2 02 2.', 'Jan 9 2012 should be week 2');
<ide> assert.equal(moment([2012, 0, 15]).format('w ww wo'), '2 02 2.', 'Jan 15 2012 should be week 2');
<ide> });
<ide>
<del>test("lenient ordinal parsing", function (assert) {
<add>test('lenient ordinal parsing', function (assert) {
<ide> var i, ordinalStr, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> ordinalStr = moment([2014, 0, i]).format('YYYY MM Do');
<ide> test("lenient ordinal parsing", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("lenient ordinal parsing of number", function (assert) {
<add>test('lenient ordinal parsing of number', function (assert) {
<ide> var i, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> testMoment = moment('2014 01 ' + i, 'YYYY MM Do');
<ide> test("lenient ordinal parsing of number", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("strict ordinal parsing", function (assert) {
<add>test('strict ordinal parsing', function (assert) {
<ide> var i, ordinalStr, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> ordinalStr = moment([2014, 0, i]).format('YYYY MM Do');
<ide><path>src/test/locale/sr-cyrl.js
<del>import {localeModule, test} from "../qunit";
<del>import {moment} from "../../moment";
<del>localeModule("sr-cyrl");
<add>import {localeModule, test} from '../qunit';
<add>import {moment} from '../../moment';
<add>localeModule('sr-cyrl');
<ide>
<del>test("parse", function (assert) {
<add>test('parse', function (assert) {
<ide> var tests = 'јануар јан._фебруар феб._март мар._април апр._мај мај_јун јун_јул јул_август авг._септембар сеп._октобар окт._новембар нов._децембар дец.'.split('_'),
<ide> i;
<ide> function equalTest(input, mmm, i) {
<ide> test("parse", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("format", function (assert) {
<add>test('format', function (assert) {
<ide> var a = [
<ide> ['dddd, Do MMMM YYYY, h:mm:ss a', 'недеља, 14. фебруар 2010, 3:25:50 pm'],
<ide> ['ddd, hA', 'нед., 3PM'],
<ide> test("format", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("format ordinal", function (assert) {
<add>test('format ordinal', function (assert) {
<ide> assert.equal(moment([2011, 0, 1]).format('DDDo'), '1.', '1.');
<ide> assert.equal(moment([2011, 0, 2]).format('DDDo'), '2.', '2.');
<ide> assert.equal(moment([2011, 0, 3]).format('DDDo'), '3.', '3.');
<ide> test("format ordinal", function (assert) {
<ide> assert.equal(moment([2011, 0, 31]).format('DDDo'), '31.', '31.');
<ide> });
<ide>
<del>test("format month", function (assert) {
<add>test('format month', function (assert) {
<ide> var expected = 'јануар јан._фебруар феб._март мар._април апр._мај мај_јун јун_јул јул_август авг._септембар сеп._октобар окт._новембар нов._децембар дец.'.split('_'),
<ide> i;
<ide> for (i = 0; i < expected.length; i++) {
<ide> assert.equal(moment([2011, i, 1]).format('MMMM MMM'), expected[i], expected[i]);
<ide> }
<ide> });
<ide>
<del>test("format week", function (assert) {
<add>test('format week', function (assert) {
<ide> var expected = 'недеља нед. не_понедељак пон. по_уторак уто. ут_среда сре. ср_четвртак чет. че_петак пет. пе_субота суб. су'.split('_'),
<ide> i;
<ide> for (i = 0; i < expected.length; i++) {
<ide> assert.equal(moment([2011, 0, 2 + i]).format('dddd ddd dd'), expected[i], expected[i]);
<ide> }
<ide> });
<ide>
<del>test("from", function (assert) {
<add>test('from', function (assert) {
<ide> var start = moment([2007, 1, 28]);
<ide> assert.equal(start.from(moment([2007, 1, 28]).add({s: 44}), true), 'неколико секунди', '44 seconds = a few seconds');
<ide> assert.equal(start.from(moment([2007, 1, 28]).add({s: 45}), true), 'један минут', '45 seconds = a minute');
<ide> test("from", function (assert) {
<ide> assert.equal(start.from(moment([2007, 1, 28]).add({y: 5}), true), '5 година', '5 years = 5 years');
<ide> });
<ide>
<del>test("suffix", function (assert) {
<add>test('suffix', function (assert) {
<ide> assert.equal(moment(30000).from(0), 'за неколико секунди', 'prefix');
<ide> assert.equal(moment(0).from(30000), 'пре неколико секунди', 'prefix');
<ide> });
<ide>
<del>test("now from now", function (assert) {
<add>test('now from now', function (assert) {
<ide> assert.equal(moment().fromNow(), 'пре неколико секунди', 'now from now should display as in the past');
<ide> });
<ide>
<del>test("fromNow", function (assert) {
<add>test('fromNow', function (assert) {
<ide> assert.equal(moment().add({s: 30}).fromNow(), 'за неколико секунди', 'in a few seconds');
<ide> assert.equal(moment().add({d: 5}).fromNow(), 'за 5 дана', 'in 5 days');
<ide> });
<ide>
<del>test("calendar day", function (assert) {
<add>test('calendar day', function (assert) {
<ide> var a = moment().hours(2).minutes(0).seconds(0);
<ide>
<ide> assert.equal(moment(a).calendar(), 'данас у 2:00', 'today at the same time');
<ide> test("calendar day", function (assert) {
<ide> assert.equal(moment(a).subtract({d: 1}).calendar(), 'јуче у 2:00', 'yesterday at the same time');
<ide> });
<ide>
<del>test("calendar next week", function (assert) {
<add>test('calendar next week', function (assert) {
<ide> var i, m;
<ide>
<ide> function makeFormat(d) {
<ide> test("calendar next week", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("calendar last week", function (assert) {
<add>test('calendar last week', function (assert) {
<ide> var i, m;
<ide>
<ide> function makeFormat(d) {
<ide> test("calendar last week", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("calendar all else", function (assert) {
<add>test('calendar all else', function (assert) {
<ide> var weeksAgo = moment().subtract({w: 1}),
<ide> weeksFromNow = moment().add({w: 1});
<ide>
<ide> test("calendar all else", function (assert) {
<ide> assert.equal(weeksFromNow.calendar(), weeksFromNow.format('L'), 'in 2 weeks');
<ide> });
<ide>
<del>test("weeks year starting sunday", function (assert) {
<add>test('weeks year starting sunday', function (assert) {
<ide> assert.equal(moment([2011, 11, 26]).week(), 1, 'Dec 26 2011 should be week 1');
<ide> assert.equal(moment([2012, 0, 1]).week(), 1, 'Jan 1 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 2]).week(), 2, 'Jan 2 2012 should be week 2');
<ide> assert.equal(moment([2012, 0, 8]).week(), 2, 'Jan 8 2012 should be week 2');
<ide> assert.equal(moment([2012, 0, 9]).week(), 3, 'Jan 9 2012 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting monday", function (assert) {
<add>test('weeks year starting monday', function (assert) {
<ide> assert.equal(moment([2007, 0, 1]).week(), 1, 'Jan 1 2007 should be week 1');
<ide> assert.equal(moment([2007, 0, 7]).week(), 1, 'Jan 7 2007 should be week 1');
<ide> assert.equal(moment([2007, 0, 8]).week(), 2, 'Jan 8 2007 should be week 2');
<ide> assert.equal(moment([2007, 0, 14]).week(), 2, 'Jan 14 2007 should be week 2');
<ide> assert.equal(moment([2007, 0, 15]).week(), 3, 'Jan 15 2007 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting tuesday", function (assert) {
<add>test('weeks year starting tuesday', function (assert) {
<ide> assert.equal(moment([2007, 11, 31]).week(), 1, 'Dec 31 2007 should be week 1');
<ide> assert.equal(moment([2008, 0, 1]).week(), 1, 'Jan 1 2008 should be week 1');
<ide> assert.equal(moment([2008, 0, 6]).week(), 1, 'Jan 6 2008 should be week 1');
<ide> test("weeks year starting tuesday", function (assert) {
<ide> assert.equal(moment([2008, 0, 14]).week(), 3, 'Jan 14 2008 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting wednesday", function (assert) {
<add>test('weeks year starting wednesday', function (assert) {
<ide> assert.equal(moment([2002, 11, 30]).week(), 1, 'Dec 30 2002 should be week 1');
<ide> assert.equal(moment([2003, 0, 1]).week(), 1, 'Jan 1 2003 should be week 1');
<ide> assert.equal(moment([2003, 0, 5]).week(), 1, 'Jan 5 2003 should be week 1');
<ide> test("weeks year starting wednesday", function (assert) {
<ide> assert.equal(moment([2003, 0, 13]).week(), 3, 'Jan 13 2003 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting thursday", function (assert) {
<add>test('weeks year starting thursday', function (assert) {
<ide> assert.equal(moment([2008, 11, 29]).week(), 1, 'Dec 29 2008 should be week 1');
<ide> assert.equal(moment([2009, 0, 1]).week(), 1, 'Jan 1 2009 should be week 1');
<ide> assert.equal(moment([2009, 0, 4]).week(), 1, 'Jan 4 2009 should be week 1');
<ide> test("weeks year starting thursday", function (assert) {
<ide> assert.equal(moment([2009, 0, 12]).week(), 3, 'Jan 12 2009 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting friday", function (assert) {
<add>test('weeks year starting friday', function (assert) {
<ide> assert.equal(moment([2009, 11, 28]).week(), 1, 'Dec 28 2009 should be week 1');
<ide> assert.equal(moment([2010, 0, 1]).week(), 1, 'Jan 1 2010 should be week 1');
<ide> assert.equal(moment([2010, 0, 3]).week(), 1, 'Jan 3 2010 should be week 1');
<ide> test("weeks year starting friday", function (assert) {
<ide> assert.equal(moment([2010, 0, 11]).week(), 3, 'Jan 11 2010 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting saturday", function (assert) {
<add>test('weeks year starting saturday', function (assert) {
<ide> assert.equal(moment([2010, 11, 27]).week(), 1, 'Dec 27 2010 should be week 1');
<ide> assert.equal(moment([2011, 0, 1]).week(), 1, 'Jan 1 2011 should be week 1');
<ide> assert.equal(moment([2011, 0, 2]).week(), 1, 'Jan 2 2011 should be week 1');
<ide> test("weeks year starting saturday", function (assert) {
<ide> assert.equal(moment([2011, 0, 10]).week(), 3, 'Jan 10 2011 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting sunday formatted", function (assert) {
<add>test('weeks year starting sunday formatted', function (assert) {
<ide> assert.equal(moment([2011, 11, 26]).format('w ww wo'), '1 01 1.', 'Dec 26 2011 should be week 1');
<ide> assert.equal(moment([2012, 0, 1]).format('w ww wo'), '1 01 1.', 'Jan 1 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 2]).format('w ww wo'), '2 02 2.', 'Jan 2 2012 should be week 2');
<ide> assert.equal(moment([2012, 0, 8]).format('w ww wo'), '2 02 2.', 'Jan 8 2012 should be week 2');
<ide> assert.equal(moment([2012, 0, 9]).format('w ww wo'), '3 03 3.', 'Jan 9 2012 should be week 3');
<ide> });
<ide>
<del>test("lenient ordinal parsing", function (assert) {
<add>test('lenient ordinal parsing', function (assert) {
<ide> var i, ordinalStr, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> ordinalStr = moment([2014, 0, i]).format('YYYY MM Do');
<ide> test("lenient ordinal parsing", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("lenient ordinal parsing of number", function (assert) {
<add>test('lenient ordinal parsing of number', function (assert) {
<ide> var i, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> testMoment = moment('2014 01 ' + i, 'YYYY MM Do');
<ide> test("lenient ordinal parsing of number", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("strict ordinal parsing", function (assert) {
<add>test('strict ordinal parsing', function (assert) {
<ide> var i, ordinalStr, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> ordinalStr = moment([2014, 0, i]).format('YYYY MM Do');
<ide><path>src/test/locale/sr.js
<del>import {localeModule, test} from "../qunit";
<del>import {moment} from "../../moment";
<del>localeModule("sr");
<add>import {localeModule, test} from '../qunit';
<add>import {moment} from '../../moment';
<add>localeModule('sr');
<ide>
<del>test("parse", function (assert) {
<add>test('parse', function (assert) {
<ide> var tests = 'januar jan._februar feb._mart mar._april apr._maj maj_jun jun_jul jul_avgust avg._septembar sep._oktobar okt._novembar nov._decembar dec.'.split('_'),
<ide> i;
<ide> function equalTest(input, mmm, i) {
<ide> test("parse", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("format", function (assert) {
<add>test('format', function (assert) {
<ide> var a = [
<ide> ['dddd, Do MMMM YYYY, h:mm:ss a', 'nedelja, 14. februar 2010, 3:25:50 pm'],
<ide> ['ddd, hA', 'ned., 3PM'],
<ide> test("format", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("format ordinal", function (assert) {
<add>test('format ordinal', function (assert) {
<ide> assert.equal(moment([2011, 0, 1]).format('DDDo'), '1.', '1.');
<ide> assert.equal(moment([2011, 0, 2]).format('DDDo'), '2.', '2.');
<ide> assert.equal(moment([2011, 0, 3]).format('DDDo'), '3.', '3.');
<ide> test("format ordinal", function (assert) {
<ide> assert.equal(moment([2011, 0, 31]).format('DDDo'), '31.', '31.');
<ide> });
<ide>
<del>test("format month", function (assert) {
<add>test('format month', function (assert) {
<ide> var expected = 'januar jan._februar feb._mart mar._april apr._maj maj_jun jun_jul jul_avgust avg._septembar sep._oktobar okt._novembar nov._decembar dec.'.split('_'),
<ide> i;
<ide> for (i = 0; i < expected.length; i++) {
<ide> assert.equal(moment([2011, i, 1]).format('MMMM MMM'), expected[i], expected[i]);
<ide> }
<ide> });
<ide>
<del>test("format week", function (assert) {
<add>test('format week', function (assert) {
<ide> var expected = 'nedelja ned. ne_ponedeljak pon. po_utorak uto. ut_sreda sre. sr_četvrtak čet. če_petak pet. pe_subota sub. su'.split('_'),
<ide> i;
<ide> for (i = 0; i < expected.length; i++) {
<ide> assert.equal(moment([2011, 0, 2 + i]).format('dddd ddd dd'), expected[i], expected[i]);
<ide> }
<ide> });
<ide>
<del>test("from", function (assert) {
<add>test('from', function (assert) {
<ide> var start = moment([2007, 1, 28]);
<ide> assert.equal(start.from(moment([2007, 1, 28]).add({s: 44}), true), 'nekoliko sekundi', '44 seconds = a few seconds');
<ide> assert.equal(start.from(moment([2007, 1, 28]).add({s: 45}), true), 'jedan minut', '45 seconds = a minute');
<ide> test("from", function (assert) {
<ide> assert.equal(start.from(moment([2007, 1, 28]).add({y: 5}), true), '5 godina', '5 years = 5 years');
<ide> });
<ide>
<del>test("suffix", function (assert) {
<add>test('suffix', function (assert) {
<ide> assert.equal(moment(30000).from(0), 'za nekoliko sekundi', 'prefix');
<ide> assert.equal(moment(0).from(30000), 'pre nekoliko sekundi', 'prefix');
<ide> });
<ide>
<del>test("now from now", function (assert) {
<add>test('now from now', function (assert) {
<ide> assert.equal(moment().fromNow(), 'pre nekoliko sekundi', 'now from now should display as in the past');
<ide> });
<ide>
<del>test("fromNow", function (assert) {
<add>test('fromNow', function (assert) {
<ide> assert.equal(moment().add({s: 30}).fromNow(), 'za nekoliko sekundi', 'in a few seconds');
<ide> assert.equal(moment().add({d: 5}).fromNow(), 'za 5 dana', 'in 5 days');
<ide> });
<ide>
<del>test("calendar day", function (assert) {
<add>test('calendar day', function (assert) {
<ide> var a = moment().hours(2).minutes(0).seconds(0);
<ide>
<ide> assert.equal(moment(a).calendar(), 'danas u 2:00', 'today at the same time');
<ide> test("calendar day", function (assert) {
<ide> assert.equal(moment(a).subtract({d: 1}).calendar(), 'juče u 2:00', 'yesterday at the same time');
<ide> });
<ide>
<del>test("calendar next week", function (assert) {
<add>test('calendar next week', function (assert) {
<ide> var i, m;
<ide>
<ide> function makeFormat(d) {
<ide> test("calendar next week", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("calendar last week", function (assert) {
<add>test('calendar last week', function (assert) {
<ide> var i, m;
<ide>
<ide> function makeFormat(d) {
<ide> test("calendar last week", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("calendar all else", function (assert) {
<add>test('calendar all else', function (assert) {
<ide> var weeksAgo = moment().subtract({w: 1}),
<ide> weeksFromNow = moment().add({w: 1});
<ide>
<ide> test("calendar all else", function (assert) {
<ide> assert.equal(weeksFromNow.calendar(), weeksFromNow.format('L'), 'in 2 weeks');
<ide> });
<ide>
<del>test("weeks year starting sunday", function (assert) {
<add>test('weeks year starting sunday', function (assert) {
<ide> assert.equal(moment([2011, 11, 26]).week(), 1, 'Dec 26 2011 should be week 1');
<ide> assert.equal(moment([2012, 0, 1]).week(), 1, 'Jan 1 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 2]).week(), 2, 'Jan 2 2012 should be week 2');
<ide> assert.equal(moment([2012, 0, 8]).week(), 2, 'Jan 8 2012 should be week 2');
<ide> assert.equal(moment([2012, 0, 9]).week(), 3, 'Jan 9 2012 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting monday", function (assert) {
<add>test('weeks year starting monday', function (assert) {
<ide> assert.equal(moment([2007, 0, 1]).week(), 1, 'Jan 1 2007 should be week 1');
<ide> assert.equal(moment([2007, 0, 7]).week(), 1, 'Jan 7 2007 should be week 1');
<ide> assert.equal(moment([2007, 0, 8]).week(), 2, 'Jan 8 2007 should be week 2');
<ide> assert.equal(moment([2007, 0, 14]).week(), 2, 'Jan 14 2007 should be week 2');
<ide> assert.equal(moment([2007, 0, 15]).week(), 3, 'Jan 15 2007 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting tuesday", function (assert) {
<add>test('weeks year starting tuesday', function (assert) {
<ide> assert.equal(moment([2007, 11, 31]).week(), 1, 'Dec 31 2007 should be week 1');
<ide> assert.equal(moment([2008, 0, 1]).week(), 1, 'Jan 1 2008 should be week 1');
<ide> assert.equal(moment([2008, 0, 6]).week(), 1, 'Jan 6 2008 should be week 1');
<ide> test("weeks year starting tuesday", function (assert) {
<ide> assert.equal(moment([2008, 0, 14]).week(), 3, 'Jan 14 2008 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting wednesday", function (assert) {
<add>test('weeks year starting wednesday', function (assert) {
<ide> assert.equal(moment([2002, 11, 30]).week(), 1, 'Dec 30 2002 should be week 1');
<ide> assert.equal(moment([2003, 0, 1]).week(), 1, 'Jan 1 2003 should be week 1');
<ide> assert.equal(moment([2003, 0, 5]).week(), 1, 'Jan 5 2003 should be week 1');
<ide> test("weeks year starting wednesday", function (assert) {
<ide> assert.equal(moment([2003, 0, 13]).week(), 3, 'Jan 13 2003 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting thursday", function (assert) {
<add>test('weeks year starting thursday', function (assert) {
<ide> assert.equal(moment([2008, 11, 29]).week(), 1, 'Dec 29 2008 should be week 1');
<ide> assert.equal(moment([2009, 0, 1]).week(), 1, 'Jan 1 2009 should be week 1');
<ide> assert.equal(moment([2009, 0, 4]).week(), 1, 'Jan 4 2009 should be week 1');
<ide> test("weeks year starting thursday", function (assert) {
<ide> assert.equal(moment([2009, 0, 12]).week(), 3, 'Jan 12 2009 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting friday", function (assert) {
<add>test('weeks year starting friday', function (assert) {
<ide> assert.equal(moment([2009, 11, 28]).week(), 1, 'Dec 28 2009 should be week 1');
<ide> assert.equal(moment([2010, 0, 1]).week(), 1, 'Jan 1 2010 should be week 1');
<ide> assert.equal(moment([2010, 0, 3]).week(), 1, 'Jan 3 2010 should be week 1');
<ide> test("weeks year starting friday", function (assert) {
<ide> assert.equal(moment([2010, 0, 11]).week(), 3, 'Jan 11 2010 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting saturday", function (assert) {
<add>test('weeks year starting saturday', function (assert) {
<ide> assert.equal(moment([2010, 11, 27]).week(), 1, 'Dec 27 2010 should be week 1');
<ide> assert.equal(moment([2011, 0, 1]).week(), 1, 'Jan 1 2011 should be week 1');
<ide> assert.equal(moment([2011, 0, 2]).week(), 1, 'Jan 2 2011 should be week 1');
<ide> test("weeks year starting saturday", function (assert) {
<ide> assert.equal(moment([2011, 0, 10]).week(), 3, 'Jan 10 2011 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting sunday formatted", function (assert) {
<add>test('weeks year starting sunday formatted', function (assert) {
<ide> assert.equal(moment([2011, 11, 26]).format('w ww wo'), '1 01 1.', 'Dec 26 2011 should be week 1');
<ide> assert.equal(moment([2012, 0, 1]).format('w ww wo'), '1 01 1.', 'Jan 1 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 2]).format('w ww wo'), '2 02 2.', 'Jan 2 2012 should be week 2');
<ide> assert.equal(moment([2012, 0, 8]).format('w ww wo'), '2 02 2.', 'Jan 8 2012 should be week 2');
<ide> assert.equal(moment([2012, 0, 9]).format('w ww wo'), '3 03 3.', 'Jan 9 2012 should be week 3');
<ide> });
<ide>
<del>test("lenient ordinal parsing", function (assert) {
<add>test('lenient ordinal parsing', function (assert) {
<ide> var i, ordinalStr, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> ordinalStr = moment([2014, 0, i]).format('YYYY MM Do');
<ide> test("lenient ordinal parsing", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("lenient ordinal parsing of number", function (assert) {
<add>test('lenient ordinal parsing of number', function (assert) {
<ide> var i, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> testMoment = moment('2014 01 ' + i, 'YYYY MM Do');
<ide> test("lenient ordinal parsing of number", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("strict ordinal parsing", function (assert) {
<add>test('strict ordinal parsing', function (assert) {
<ide> var i, ordinalStr, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> ordinalStr = moment([2014, 0, i]).format('YYYY MM Do');
<ide><path>src/test/locale/sv.js
<del>import {localeModule, test} from "../qunit";
<del>import {moment} from "../../moment";
<del>localeModule("sv");
<add>import {localeModule, test} from '../qunit';
<add>import {moment} from '../../moment';
<add>localeModule('sv');
<ide>
<del>test("parse", function (assert) {
<add>test('parse', function (assert) {
<ide> var tests = 'januari jan_februari feb_mars mar_april apr_maj maj_juni jun_juli jul_augusti aug_september sep_oktober okt_november nov_december dec'.split('_'), i;
<ide> function equalTest(input, mmm, i) {
<ide> assert.equal(moment(input, mmm).month(), i, input + ' should be month ' + (i + 1));
<ide> test("parse", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("format", function (assert) {
<add>test('format', function (assert) {
<ide> var a = [
<ide> ['dddd, MMMM Do YYYY, h:mm:ss a', 'söndag, februari 14e 2010, 3:25:50 pm'],
<ide> ['ddd, hA', 'sön, 3PM'],
<ide> test("format", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("format ordinal", function (assert) {
<add>test('format ordinal', function (assert) {
<ide> assert.equal(moment([2011, 0, 1]).format('DDDo'), '1a', '1a');
<ide> assert.equal(moment([2011, 0, 2]).format('DDDo'), '2a', '2a');
<ide> assert.equal(moment([2011, 0, 3]).format('DDDo'), '3e', '3e');
<ide> test("format ordinal", function (assert) {
<ide> assert.equal(moment([2011, 0, 31]).format('DDDo'), '31a', '31a');
<ide> });
<ide>
<del>test("format month", function (assert) {
<add>test('format month', function (assert) {
<ide> var expected = 'januari jan_februari feb_mars mar_april apr_maj maj_juni jun_juli jul_augusti aug_september sep_oktober okt_november nov_december dec'.split('_'), i;
<ide> for (i = 0; i < expected.length; i++) {
<ide> assert.equal(moment([2011, i, 1]).format('MMMM MMM'), expected[i], expected[i]);
<ide> }
<ide> });
<ide>
<del>test("format week", function (assert) {
<add>test('format week', function (assert) {
<ide> var expected = 'söndag sön sö_måndag mån må_tisdag tis ti_onsdag ons on_torsdag tor to_fredag fre fr_lördag lör lö'.split('_'), i;
<ide> for (i = 0; i < expected.length; i++) {
<ide> assert.equal(moment([2011, 0, 2 + i]).format('dddd ddd dd'), expected[i], expected[i]);
<ide> }
<ide> });
<ide>
<del>test("from", function (assert) {
<add>test('from', function (assert) {
<ide> var start = moment([2007, 1, 28]);
<ide> assert.equal(start.from(moment([2007, 1, 28]).add({s: 44}), true), 'några sekunder', '44 sekunder = a few seconds');
<ide> assert.equal(start.from(moment([2007, 1, 28]).add({s: 45}), true), 'en minut', '45 seconds = a minute');
<ide> test("from", function (assert) {
<ide> assert.equal(start.from(moment([2007, 1, 28]).add({y: 5}), true), '5 år', '5 years = 5 years');
<ide> });
<ide>
<del>test("suffix", function (assert) {
<add>test('suffix', function (assert) {
<ide> assert.equal(moment(30000).from(0), 'om några sekunder', 'prefix');
<ide> assert.equal(moment(0).from(30000), 'för några sekunder sedan', 'suffix');
<ide> });
<ide>
<del>test("now from now", function (assert) {
<add>test('now from now', function (assert) {
<ide> assert.equal(moment().fromNow(), 'för några sekunder sedan', 'now from now should display as in the past');
<ide> });
<ide>
<del>test("fromNow", function (assert) {
<add>test('fromNow', function (assert) {
<ide> assert.equal(moment().add({s: 30}).fromNow(), 'om några sekunder', 'in a few seconds');
<ide> assert.equal(moment().add({d: 5}).fromNow(), 'om 5 dagar', 'in 5 days');
<ide> });
<ide>
<del>test("calendar day", function (assert) {
<add>test('calendar day', function (assert) {
<ide> var a = moment().hours(2).minutes(0).seconds(0);
<ide>
<ide> assert.equal(moment(a).calendar(), 'Idag 02:00', 'today at the same time');
<ide> test("calendar day", function (assert) {
<ide> assert.equal(moment(a).subtract({d: 1}).calendar(), 'Igår 02:00', 'yesterday at the same time');
<ide> });
<ide>
<del>test("calendar next week", function (assert) {
<add>test('calendar next week', function (assert) {
<ide> var i, m;
<ide> for (i = 2; i < 7; i++) {
<ide> m = moment().add({d: i});
<ide> test("calendar next week", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("calendar last week", function (assert) {
<add>test('calendar last week', function (assert) {
<ide> var i, m;
<ide> for (i = 2; i < 7; i++) {
<ide> m = moment().subtract({d: i});
<ide> test("calendar last week", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("calendar all else", function (assert) {
<add>test('calendar all else', function (assert) {
<ide> var weeksAgo = moment().subtract({w: 1}),
<ide> weeksFromNow = moment().add({w: 1});
<ide>
<ide> test("calendar all else", function (assert) {
<ide> assert.equal(weeksFromNow.calendar(), weeksFromNow.format('L'), 'in 2 weeks');
<ide> });
<ide>
<del>test("weeks year starting sunday", function (assert) {
<add>test('weeks year starting sunday', function (assert) {
<ide> assert.equal(moment([2012, 0, 1]).week(), 52, 'Jan 1 2012 should be week 52');
<ide> assert.equal(moment([2012, 0, 2]).week(), 1, 'Jan 2 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 8]).week(), 1, 'Jan 8 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 9]).week(), 2, 'Jan 9 2012 should be week 2');
<ide> assert.equal(moment([2012, 0, 15]).week(), 2, 'Jan 15 2012 should be week 2');
<ide> });
<ide>
<del>test("weeks year starting monday", function (assert) {
<add>test('weeks year starting monday', function (assert) {
<ide> assert.equal(moment([2007, 0, 1]).week(), 1, 'Jan 1 2007 should be week 1');
<ide> assert.equal(moment([2007, 0, 7]).week(), 1, 'Jan 7 2007 should be week 1');
<ide> assert.equal(moment([2007, 0, 8]).week(), 2, 'Jan 8 2007 should be week 2');
<ide> assert.equal(moment([2007, 0, 14]).week(), 2, 'Jan 14 2007 should be week 2');
<ide> assert.equal(moment([2007, 0, 15]).week(), 3, 'Jan 15 2007 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting tuesday", function (assert) {
<add>test('weeks year starting tuesday', function (assert) {
<ide> assert.equal(moment([2007, 11, 31]).week(), 1, 'Dec 31 2007 should be week 1');
<ide> assert.equal(moment([2008, 0, 1]).week(), 1, 'Jan 1 2008 should be week 1');
<ide> assert.equal(moment([2008, 0, 6]).week(), 1, 'Jan 6 2008 should be week 1');
<ide> test("weeks year starting tuesday", function (assert) {
<ide> assert.equal(moment([2008, 0, 14]).week(), 3, 'Jan 14 2008 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting wednesday", function (assert) {
<add>test('weeks year starting wednesday', function (assert) {
<ide> assert.equal(moment([2002, 11, 30]).week(), 1, 'Dec 30 2002 should be week 1');
<ide> assert.equal(moment([2003, 0, 1]).week(), 1, 'Jan 1 2003 should be week 1');
<ide> assert.equal(moment([2003, 0, 5]).week(), 1, 'Jan 5 2003 should be week 1');
<ide> test("weeks year starting wednesday", function (assert) {
<ide> assert.equal(moment([2003, 0, 13]).week(), 3, 'Jan 13 2003 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting thursday", function (assert) {
<add>test('weeks year starting thursday', function (assert) {
<ide> assert.equal(moment([2008, 11, 29]).week(), 1, 'Dec 29 2008 should be week 1');
<ide> assert.equal(moment([2009, 0, 1]).week(), 1, 'Jan 1 2009 should be week 1');
<ide> assert.equal(moment([2009, 0, 4]).week(), 1, 'Jan 4 2009 should be week 1');
<ide> test("weeks year starting thursday", function (assert) {
<ide> assert.equal(moment([2009, 0, 13]).week(), 3, 'Jan 12 2009 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting friday", function (assert) {
<add>test('weeks year starting friday', function (assert) {
<ide> assert.equal(moment([2009, 11, 28]).week(), 53, 'Dec 28 2009 should be week 53');
<ide> assert.equal(moment([2010, 0, 1]).week(), 53, 'Jan 1 2010 should be week 53');
<ide> assert.equal(moment([2010, 0, 3]).week(), 53, 'Jan 3 2010 should be week 53');
<ide> test("weeks year starting friday", function (assert) {
<ide> assert.equal(moment([2010, 0, 11]).week(), 2, 'Jan 11 2010 should be week 2');
<ide> });
<ide>
<del>test("weeks year starting saturday", function (assert) {
<add>test('weeks year starting saturday', function (assert) {
<ide> assert.equal(moment([2010, 11, 27]).week(), 52, 'Dec 27 2010 should be week 52');
<ide> assert.equal(moment([2011, 0, 1]).week(), 52, 'Jan 1 2011 should be week 52');
<ide> assert.equal(moment([2011, 0, 2]).week(), 52, 'Jan 2 2011 should be week 52');
<ide> test("weeks year starting saturday", function (assert) {
<ide> assert.equal(moment([2011, 0, 10]).week(), 2, 'Jan 10 2011 should be week 2');
<ide> });
<ide>
<del>test("weeks year starting sunday formatted", function (assert) {
<add>test('weeks year starting sunday formatted', function (assert) {
<ide> assert.equal(moment([2012, 0, 1]).format('w ww wo'), '52 52 52a', 'Jan 1 2012 should be week 52');
<ide> assert.equal(moment([2012, 0, 2]).format('w ww wo'), '1 01 1a', 'Jan 2 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 8]).format('w ww wo'), '1 01 1a', 'Jan 8 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 9]).format('w ww wo'), '2 02 2a', 'Jan 9 2012 should be week 2');
<ide> assert.equal(moment([2012, 0, 15]).format('w ww wo'), '2 02 2a', 'Jan 15 2012 should be week 2');
<ide> });
<ide>
<del>test("lenient ordinal parsing", function (assert) {
<add>test('lenient ordinal parsing', function (assert) {
<ide> var i, ordinalStr, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> ordinalStr = moment([2014, 0, i]).format('YYYY MM Do');
<ide> test("lenient ordinal parsing", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("lenient ordinal parsing of number", function (assert) {
<add>test('lenient ordinal parsing of number', function (assert) {
<ide> var i, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> testMoment = moment('2014 01 ' + i, 'YYYY MM Do');
<ide> test("lenient ordinal parsing of number", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("strict ordinal parsing", function (assert) {
<add>test('strict ordinal parsing', function (assert) {
<ide> var i, ordinalStr, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> ordinalStr = moment([2014, 0, i]).format('YYYY MM Do');
<ide><path>src/test/locale/ta.js
<del>import {localeModule, test} from "../qunit";
<del>import {moment} from "../../moment";
<del>localeModule("ta");
<add>import {localeModule, test} from '../qunit';
<add>import {moment} from '../../moment';
<add>localeModule('ta');
<ide>
<del>test("parse", function (assert) {
<add>test('parse', function (assert) {
<ide> var tests = 'ஜனவரி ஜனவரி_பிப்ரவரி பிப்ரவரி_மார்ச் மார்ச்_ஏப்ரல் ஏப்ரல்_மே மே_ஜூன் ஜூன்_ஜூலை ஜூலை_ஆகஸ்ட் ஆகஸ்ட்_செப்டெம்பர் செப்டெம்பர்_அக்டோபர் அக்டோபர்_நவம்பர் நவம்பர்_டிசம்பர் டிசம்பர்'.split('_'), i;
<ide> function equalTest(input, mmm, i) {
<ide> assert.equal(moment(input, mmm).month(), i, input + ' should be month ' + (i + 1));
<ide> test("parse", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("format", function (assert) {
<add>test('format', function (assert) {
<ide> var a = [
<ide> ['dddd, MMMM Do YYYY, h:mm:ss a', 'ஞாயிற்றுக்கிழமை, பிப்ரவரி 14வது 2010, 3:25:50 எற்பாடு'],
<ide> ['ddd, hA', 'ஞாயிறு, 3 எற்பாடு'],
<ide> test("format", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("format ordinal", function (assert) {
<add>test('format ordinal', function (assert) {
<ide> assert.equal(moment([2011, 0, 1]).format('DDDo'), '1வது', '1வது');
<ide> assert.equal(moment([2011, 0, 2]).format('DDDo'), '2வது', '2வது');
<ide> assert.equal(moment([2011, 0, 3]).format('DDDo'), '3வது', '3வது');
<ide> test("format ordinal", function (assert) {
<ide> assert.equal(moment([2011, 0, 31]).format('DDDo'), '31வது', '31வது');
<ide> });
<ide>
<del>test("format month", function (assert) {
<add>test('format month', function (assert) {
<ide> var expected = 'ஜனவரி ஜனவரி_பிப்ரவரி பிப்ரவரி_மார்ச் மார்ச்_ஏப்ரல் ஏப்ரல்_மே மே_ஜூன் ஜூன்_ஜூலை ஜூலை_ஆகஸ்ட் ஆகஸ்ட்_செப்டெம்பர் செப்டெம்பர்_அக்டோபர் அக்டோபர்_நவம்பர் நவம்பர்_டிசம்பர் டிசம்பர்'.split('_'), i;
<ide> for (i = 0; i < expected.length; i++) {
<ide> assert.equal(moment([2011, i, 1]).format('MMMM MMM'), expected[i], expected[i]);
<ide> }
<ide> });
<ide>
<del>test("format week", function (assert) {
<add>test('format week', function (assert) {
<ide> var expected = 'ஞாயிற்றுக்கிழமை ஞாயிறு ஞா_திங்கட்கிழமை திங்கள் தி_செவ்வாய்கிழமை செவ்வாய் செ_புதன்கிழமை புதன் பு_வியாழக்கிழமை வியாழன் வி_வெள்ளிக்கிழமை வெள்ளி வெ_சனிக்கிழமை சனி ச'.split('_'), i;
<ide> for (i = 0; i < expected.length; i++) {
<ide> assert.equal(moment([2011, 0, 2 + i]).format('dddd ddd dd'), expected[i], expected[i]);
<ide> }
<ide> });
<ide>
<del>test("from", function (assert) {
<add>test('from', function (assert) {
<ide> var start = moment([2007, 1, 28]);
<ide> assert.equal(start.from(moment([2007, 1, 28]).add({s: 44}), true), 'ஒரு சில விநாடிகள்', '44 விநாடிகள் = ஒரு சில விநாடிகள்');
<ide> assert.equal(start.from(moment([2007, 1, 28]).add({s: 45}), true), 'ஒரு நிமிடம்', '45 விநாடிகள் = ஒரு நிமிடம்');
<ide> test("from", function (assert) {
<ide> assert.equal(start.from(moment([2007, 1, 28]).add({y: 5}), true), '5 ஆண்டுகள்', '5 ஆண்டுகள் = 5 ஆண்டுகள்');
<ide> });
<ide>
<del>test("suffix", function (assert) {
<add>test('suffix', function (assert) {
<ide> assert.equal(moment(30000).from(0), 'ஒரு சில விநாடிகள் இல்', 'prefix');
<ide> assert.equal(moment(0).from(30000), 'ஒரு சில விநாடிகள் முன்', 'suffix');
<ide> });
<ide>
<del>test("now from now", function (assert) {
<add>test('now from now', function (assert) {
<ide> assert.equal(moment().fromNow(), 'ஒரு சில விநாடிகள் முன்', 'இப்போது இருந்து கடந்த காலத்தில் காட்ட வேண்டும்');
<ide> });
<ide>
<del>test("fromNow", function (assert) {
<add>test('fromNow', function (assert) {
<ide> assert.equal(moment().add({s: 30}).fromNow(), 'ஒரு சில விநாடிகள் இல்', 'ஒரு சில விநாடிகள் இல்');
<ide> assert.equal(moment().add({d: 5}).fromNow(), '5 நாட்கள் இல்', '5 நாட்கள் இல்');
<ide> });
<ide>
<del>test("calendar day", function (assert) {
<add>test('calendar day', function (assert) {
<ide> var a = moment().hours(2).minutes(0).seconds(0);
<ide>
<ide> assert.equal(moment(a).calendar(), 'இன்று 02:00', 'இன்று 02:00');
<ide> test("calendar day", function (assert) {
<ide> assert.equal(moment(a).subtract({d: 1}).calendar(), 'நேற்று 02:00', 'நேற்று 02:00');
<ide> });
<ide>
<del>test("calendar next week", function (assert) {
<add>test('calendar next week', function (assert) {
<ide> var i, m;
<ide> for (i = 2; i < 7; i++) {
<ide> m = moment().add({d: i});
<ide> test("calendar next week", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("calendar last week", function (assert) {
<add>test('calendar last week', function (assert) {
<ide> var i, m;
<ide>
<ide> for (i = 2; i < 7; i++) {
<ide> test("calendar last week", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("calendar all else", function (assert) {
<add>test('calendar all else', function (assert) {
<ide> var weeksAgo = moment().subtract({w: 1}),
<ide> weeksFromNow = moment().add({w: 1});
<ide>
<ide> test("calendar all else", function (assert) {
<ide> assert.equal(weeksFromNow.calendar(), weeksFromNow.format('L'), 'in 2 weeks');
<ide> });
<ide>
<del>test("weeks year starting sunday", function (assert) {
<add>test('weeks year starting sunday', function (assert) {
<ide> assert.equal(moment([2012, 0, 1]).week(), 1, 'Jan 1 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 7]).week(), 1, 'Jan 7 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 8]).week(), 2, 'Jan 8 2012 should be week 2');
<ide> assert.equal(moment([2012, 0, 14]).week(), 2, 'Jan 14 2012 should be week 2');
<ide> assert.equal(moment([2012, 0, 15]).week(), 3, 'Jan 15 2012 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting monday", function (assert) {
<add>test('weeks year starting monday', function (assert) {
<ide> assert.equal(moment([2006, 11, 31]).week(), 1, 'Dec 31 2006 should be week 1');
<ide> assert.equal(moment([2007, 0, 1]).week(), 1, 'Jan 1 2007 should be week 1');
<ide> assert.equal(moment([2007, 0, 6]).week(), 1, 'Jan 6 2007 should be week 1');
<ide> test("weeks year starting monday", function (assert) {
<ide> assert.equal(moment([2007, 0, 14]).week(), 3, 'Jan 14 2007 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting tuesday", function (assert) {
<add>test('weeks year starting tuesday', function (assert) {
<ide> assert.equal(moment([2007, 11, 29]).week(), 52, 'Dec 29 2007 should be week 52');
<ide> assert.equal(moment([2008, 0, 1]).week(), 1, 'Jan 1 2008 should be week 1');
<ide> assert.equal(moment([2008, 0, 5]).week(), 1, 'Jan 5 2008 should be week 1');
<ide> test("weeks year starting tuesday", function (assert) {
<ide> assert.equal(moment([2008, 0, 13]).week(), 3, 'Jan 13 2008 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting wednesday", function (assert) {
<add>test('weeks year starting wednesday', function (assert) {
<ide> assert.equal(moment([2002, 11, 29]).week(), 1, 'Dec 29 2002 should be week 1');
<ide> assert.equal(moment([2003, 0, 1]).week(), 1, 'Jan 1 2003 should be week 1');
<ide> assert.equal(moment([2003, 0, 4]).week(), 1, 'Jan 4 2003 should be week 1');
<ide> test("weeks year starting wednesday", function (assert) {
<ide> assert.equal(moment([2003, 0, 12]).week(), 3, 'Jan 12 2003 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting thursday", function (assert) {
<add>test('weeks year starting thursday', function (assert) {
<ide> assert.equal(moment([2008, 11, 28]).week(), 1, 'Dec 28 2008 should be week 1');
<ide> assert.equal(moment([2009, 0, 1]).week(), 1, 'Jan 1 2009 should be week 1');
<ide> assert.equal(moment([2009, 0, 3]).week(), 1, 'Jan 3 2009 should be week 1');
<ide> test("weeks year starting thursday", function (assert) {
<ide> assert.equal(moment([2009, 0, 11]).week(), 3, 'Jan 11 2009 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting friday", function (assert) {
<add>test('weeks year starting friday', function (assert) {
<ide> assert.equal(moment([2009, 11, 27]).week(), 1, 'Dec 27 2009 should be week 1');
<ide> assert.equal(moment([2010, 0, 1]).week(), 1, 'Jan 1 2010 should be week 1');
<ide> assert.equal(moment([2010, 0, 2]).week(), 1, 'Jan 2 2010 should be week 1');
<ide> test("weeks year starting friday", function (assert) {
<ide> assert.equal(moment([2010, 0, 10]).week(), 3, 'Jan 10 2010 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting saturday", function (assert) {
<add>test('weeks year starting saturday', function (assert) {
<ide> assert.equal(moment([2010, 11, 26]).week(), 1, 'Dec 26 2010 should be week 1');
<ide> assert.equal(moment([2011, 0, 1]).week(), 1, 'Jan 1 2011 should be week 1');
<ide> assert.equal(moment([2011, 0, 2]).week(), 2, 'Jan 2 2011 should be week 2');
<ide> assert.equal(moment([2011, 0, 8]).week(), 2, 'Jan 8 2011 should be week 2');
<ide> assert.equal(moment([2011, 0, 9]).week(), 3, 'Jan 9 2011 should be week 3');
<ide> });
<ide>
<del>test("meridiem", function (assert) {
<add>test('meridiem', function (assert) {
<ide> assert.equal(moment([2011, 2, 23, 0, 30]).format('a'), ' யாமம்', '(after) midnight');
<ide> assert.equal(moment([2011, 2, 23, 2, 30]).format('a'), ' வைகறை', 'before dawn');
<ide> assert.equal(moment([2011, 2, 23, 9, 30]).format('a'), ' காலை', 'morning');
<ide> test("meridiem", function (assert) {
<ide> assert.equal(moment([2011, 2, 23, 23, 30]).format('a'), ' யாமம்', '(before) midnight');
<ide> });
<ide>
<del>test("lenient ordinal parsing", function (assert) {
<add>test('lenient ordinal parsing', function (assert) {
<ide> var i, ordinalStr, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> ordinalStr = moment([2014, 0, i]).format('YYYY MM Do');
<ide> test("lenient ordinal parsing", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("lenient ordinal parsing of number", function (assert) {
<add>test('lenient ordinal parsing of number', function (assert) {
<ide> var i, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> testMoment = moment('2014 01 ' + i, 'YYYY MM Do');
<ide> test("lenient ordinal parsing of number", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("meridiem invariant", function (assert) {
<add>test('meridiem invariant', function (assert) {
<ide> var h, m, t1, t2;
<ide> for (h = 0; h < 24; ++h) {
<ide> for (m = 0; m < 60; m += 15) {
<ide> test("meridiem invariant", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("strict ordinal parsing", function (assert) {
<add>test('strict ordinal parsing', function (assert) {
<ide> var i, ordinalStr, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> ordinalStr = moment([2014, 0, i]).format('YYYY MM Do');
<ide><path>src/test/locale/th.js
<del>import {localeModule, test} from "../qunit";
<del>import {moment} from "../../moment";
<del>localeModule("th");
<add>import {localeModule, test} from '../qunit';
<add>import {moment} from '../../moment';
<add>localeModule('th');
<ide>
<del>test("parse", function (assert) {
<add>test('parse', function (assert) {
<ide> var tests = 'มกราคม มกรา_กุมภาพันธ์ กุมภา_มีนาคม มีนา_เมษายน เมษา_พฤษภาคม พฤษภา_มิถุนายน มิถุนา_กรกฎาคม กรกฎา_สิงหาคม สิงหา_กันยายน กันยา_ตุลาคม ตุลา_พฤศจิกายน พฤศจิกา_ธันวาคม ธันวา'.split('_'), i;
<ide> function equalTest(input, mmm, i) {
<ide> assert.equal(moment(input, mmm).month(), i, input + ' should be month ' + (i + 1));
<ide> test("parse", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("format", function (assert) {
<add>test('format', function (assert) {
<ide> var a = [
<ide> ['dddd, Do MMMM YYYY, h:mm:ss a', 'อาทิตย์, 14 กุมภาพันธ์ 2010, 3:25:50 หลังเที่ยง'],
<ide> ['ddd, h A', 'อาทิตย์, 3 หลังเที่ยง'],
<ide> test("format", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("format month", function (assert) {
<add>test('format month', function (assert) {
<ide> var expected = 'มกราคม มกรา_กุมภาพันธ์ กุมภา_มีนาคม มีนา_เมษายน เมษา_พฤษภาคม พฤษภา_มิถุนายน มิถุนา_กรกฎาคม กรกฎา_สิงหาคม สิงหา_กันยายน กันยา_ตุลาคม ตุลา_พฤศจิกายน พฤศจิกา_ธันวาคม ธันวา'.split('_'), i;
<ide> for (i = 0; i < expected.length; i++) {
<ide> assert.equal(moment([2011, i, 1]).format('MMMM MMM'), expected[i], expected[i]);
<ide> }
<ide> });
<ide>
<del>test("format week", function (assert) {
<add>test('format week', function (assert) {
<ide> var expected = 'อาทิตย์ อาทิตย์ อา._จันทร์ จันทร์ จ._อังคาร อังคาร อ._พุธ พุธ พ._พฤหัสบดี พฤหัส พฤ._ศุกร์ ศุกร์ ศ._เสาร์ เสาร์ ส.'.split('_'), i;
<ide> for (i = 0; i < expected.length; i++) {
<ide> assert.equal(moment([2011, 0, 2 + i]).format('dddd ddd dd'), expected[i], expected[i]);
<ide> }
<ide> });
<ide>
<del>test("from", function (assert) {
<add>test('from', function (assert) {
<ide> var start = moment([2007, 1, 28]);
<ide> assert.equal(start.from(moment([2007, 1, 28]).add({s: 44}), true), 'ไม่กี่วินาที', '44 seconds = a few seconds');
<ide> assert.equal(start.from(moment([2007, 1, 28]).add({s: 45}), true), '1 นาที', '45 seconds = a minute');
<ide> test("from", function (assert) {
<ide> assert.equal(start.from(moment([2007, 1, 28]).add({y: 5}), true), '5 ปี', '5 years = 5 years');
<ide> });
<ide>
<del>test("suffix", function (assert) {
<add>test('suffix', function (assert) {
<ide> assert.equal(moment(30000).from(0), 'อีก ไม่กี่วินาที', 'prefix');
<ide> assert.equal(moment(0).from(30000), 'ไม่กี่วินาทีที่แล้ว', 'suffix');
<ide> });
<ide>
<del>test("now from now", function (assert) {
<add>test('now from now', function (assert) {
<ide> assert.equal(moment().fromNow(), 'ไม่กี่วินาทีที่แล้ว', 'now from now should display as in the past');
<ide> });
<ide>
<del>test("fromNow", function (assert) {
<add>test('fromNow', function (assert) {
<ide> assert.equal(moment().add({s: 30}).fromNow(), 'อีก ไม่กี่วินาที', 'in a few seconds');
<ide> assert.equal(moment().add({d: 5}).fromNow(), 'อีก 5 วัน', 'in 5 days');
<ide> });
<ide>
<del>test("calendar day", function (assert) {
<add>test('calendar day', function (assert) {
<ide> var a = moment().hours(2).minutes(0).seconds(0);
<ide>
<ide> assert.equal(moment(a).calendar(), 'วันนี้ เวลา 2 นาฬิกา 0 นาที', 'today at the same time');
<ide> test("calendar day", function (assert) {
<ide> assert.equal(moment(a).subtract({d: 1}).calendar(), 'เมื่อวานนี้ เวลา 2 นาฬิกา 0 นาที', 'yesterday at the same time');
<ide> });
<ide>
<del>test("calendar next week", function (assert) {
<add>test('calendar next week', function (assert) {
<ide> var i, m;
<ide> for (i = 2; i < 7; i++) {
<ide> m = moment().add({d: i});
<ide> test("calendar next week", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("calendar last week", function (assert) {
<add>test('calendar last week', function (assert) {
<ide> var i, m;
<ide> for (i = 2; i < 7; i++) {
<ide> m = moment().subtract({d: i});
<ide> test("calendar last week", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("calendar all else", function (assert) {
<add>test('calendar all else', function (assert) {
<ide> var weeksAgo = moment().subtract({w: 1}),
<ide> weeksFromNow = moment().add({w: 1});
<ide>
<ide> test("calendar all else", function (assert) {
<ide> assert.equal(weeksFromNow.calendar(), weeksFromNow.format('L'), 'in 2 weeks');
<ide> });
<ide>
<del>test("weeks year starting sunday", function (assert) {
<add>test('weeks year starting sunday', function (assert) {
<ide> assert.equal(moment([2012, 0, 1]).week(), 1, 'Jan 1 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 7]).week(), 1, 'Jan 7 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 8]).week(), 2, 'Jan 8 2012 should be week 2');
<ide> assert.equal(moment([2012, 0, 14]).week(), 2, 'Jan 14 2012 should be week 2');
<ide> assert.equal(moment([2012, 0, 15]).week(), 3, 'Jan 15 2012 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting monday", function (assert) {
<add>test('weeks year starting monday', function (assert) {
<ide> assert.equal(moment([2006, 11, 31]).week(), 1, 'Dec 31 2006 should be week 1');
<ide> assert.equal(moment([2007, 0, 1]).week(), 1, 'Jan 1 2007 should be week 1');
<ide> assert.equal(moment([2007, 0, 6]).week(), 1, 'Jan 6 2007 should be week 1');
<ide> test("weeks year starting monday", function (assert) {
<ide> assert.equal(moment([2007, 0, 14]).week(), 3, 'Jan 14 2007 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting tuesday", function (assert) {
<add>test('weeks year starting tuesday', function (assert) {
<ide> assert.equal(moment([2007, 11, 29]).week(), 52, 'Dec 29 2007 should be week 52');
<ide> assert.equal(moment([2008, 0, 1]).week(), 1, 'Jan 1 2008 should be week 1');
<ide> assert.equal(moment([2008, 0, 5]).week(), 1, 'Jan 5 2008 should be week 1');
<ide> test("weeks year starting tuesday", function (assert) {
<ide> assert.equal(moment([2008, 0, 13]).week(), 3, 'Jan 13 2008 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting wednesday", function (assert) {
<add>test('weeks year starting wednesday', function (assert) {
<ide> assert.equal(moment([2002, 11, 29]).week(), 1, 'Dec 29 2002 should be week 1');
<ide> assert.equal(moment([2003, 0, 1]).week(), 1, 'Jan 1 2003 should be week 1');
<ide> assert.equal(moment([2003, 0, 4]).week(), 1, 'Jan 4 2003 should be week 1');
<ide> test("weeks year starting wednesday", function (assert) {
<ide> assert.equal(moment([2003, 0, 12]).week(), 3, 'Jan 12 2003 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting thursday", function (assert) {
<add>test('weeks year starting thursday', function (assert) {
<ide> assert.equal(moment([2008, 11, 28]).week(), 1, 'Dec 28 2008 should be week 1');
<ide> assert.equal(moment([2009, 0, 1]).week(), 1, 'Jan 1 2009 should be week 1');
<ide> assert.equal(moment([2009, 0, 3]).week(), 1, 'Jan 3 2009 should be week 1');
<ide> test("weeks year starting thursday", function (assert) {
<ide> assert.equal(moment([2009, 0, 11]).week(), 3, 'Jan 11 2009 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting friday", function (assert) {
<add>test('weeks year starting friday', function (assert) {
<ide> assert.equal(moment([2009, 11, 27]).week(), 1, 'Dec 27 2009 should be week 1');
<ide> assert.equal(moment([2010, 0, 1]).week(), 1, 'Jan 1 2010 should be week 1');
<ide> assert.equal(moment([2010, 0, 2]).week(), 1, 'Jan 2 2010 should be week 1');
<ide> test("weeks year starting friday", function (assert) {
<ide> assert.equal(moment([2010, 0, 10]).week(), 3, 'Jan 10 2010 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting saturday", function (assert) {
<add>test('weeks year starting saturday', function (assert) {
<ide> assert.equal(moment([2010, 11, 26]).week(), 1, 'Dec 26 2010 should be week 1');
<ide> assert.equal(moment([2011, 0, 1]).week(), 1, 'Jan 1 2011 should be week 1');
<ide> assert.equal(moment([2011, 0, 2]).week(), 2, 'Jan 2 2011 should be week 2');
<ide> assert.equal(moment([2011, 0, 8]).week(), 2, 'Jan 8 2011 should be week 2');
<ide> assert.equal(moment([2011, 0, 9]).week(), 3, 'Jan 9 2011 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting sunday format", function (assert) {
<add>test('weeks year starting sunday format', function (assert) {
<ide> assert.equal(moment([2012, 0, 1]).format('w ww wo'), '1 01 1', 'Jan 1 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 7]).format('w ww wo'), '1 01 1', 'Jan 7 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 8]).format('w ww wo'), '2 02 2', 'Jan 8 2012 should be week 2');
<ide> assert.equal(moment([2012, 0, 14]).format('w ww wo'), '2 02 2', 'Jan 14 2012 should be week 2');
<ide> assert.equal(moment([2012, 0, 15]).format('w ww wo'), '3 03 3', 'Jan 15 2012 should be week 3');
<ide> });
<ide>
<del>test("lenient ordinal parsing", function (assert) {
<add>test('lenient ordinal parsing', function (assert) {
<ide> var i, ordinalStr, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> ordinalStr = moment([2014, 0, i]).format('YYYY MM Do');
<ide> test("lenient ordinal parsing", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("lenient ordinal parsing of number", function (assert) {
<add>test('lenient ordinal parsing of number', function (assert) {
<ide> var i, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> testMoment = moment('2014 01 ' + i, 'YYYY MM Do');
<ide> test("lenient ordinal parsing of number", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("strict ordinal parsing", function (assert) {
<add>test('strict ordinal parsing', function (assert) {
<ide> var i, ordinalStr, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> ordinalStr = moment([2014, 0, i]).format('YYYY MM Do');
<ide><path>src/test/locale/tl-ph.js
<del>import {localeModule, test} from "../qunit";
<del>import {moment} from "../../moment";
<del>localeModule("tl-ph");
<add>import {localeModule, test} from '../qunit';
<add>import {moment} from '../../moment';
<add>localeModule('tl-ph');
<ide>
<del>test("parse", function (assert) {
<add>test('parse', function (assert) {
<ide> var tests = 'Enero Ene_Pebrero Peb_Marso Mar_Abril Abr_Mayo May_Hunyo Hun_Hulyo Hul_Agosto Ago_Setyembre Set_Oktubre Okt_Nobyembre Nob_Disyembre Dis'.split('_'),
<ide> i;
<ide> function equalTest(input, mmm, i) {
<ide> test("parse", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("format", function (assert) {
<add>test('format', function (assert) {
<ide> var a = [
<ide> ['dddd, MMMM Do YYYY, h:mm:ss a', 'Linggo, Pebrero 14 2010, 3:25:50 pm'],
<ide> ['ddd, hA', 'Lin, 3PM'],
<ide> test("format", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("format ordinal", function (assert) {
<add>test('format ordinal', function (assert) {
<ide> assert.equal(moment([2011, 0, 1]).format('DDDo'), '1', '1');
<ide> assert.equal(moment([2011, 0, 2]).format('DDDo'), '2', '2');
<ide> assert.equal(moment([2011, 0, 3]).format('DDDo'), '3', '3');
<ide> test("format ordinal", function (assert) {
<ide> assert.equal(moment([2011, 0, 31]).format('DDDo'), '31', '31');
<ide> });
<ide>
<del>test("format month", function (assert) {
<add>test('format month', function (assert) {
<ide> var expected = 'Enero Ene_Pebrero Peb_Marso Mar_Abril Abr_Mayo May_Hunyo Hun_Hulyo Hul_Agosto Ago_Setyembre Set_Oktubre Okt_Nobyembre Nob_Disyembre Dis'.split('_'), i;
<ide> for (i = 0; i < expected.length; i++) {
<ide> assert.equal(moment([2011, i, 1]).format('MMMM MMM'), expected[i], expected[i]);
<ide> }
<ide> });
<ide>
<del>test("format week", function (assert) {
<add>test('format week', function (assert) {
<ide> var expected = 'Linggo Lin Li_Lunes Lun Lu_Martes Mar Ma_Miyerkules Miy Mi_Huwebes Huw Hu_Biyernes Biy Bi_Sabado Sab Sab'.split('_'), i;
<ide> for (i = 0; i < expected.length; i++) {
<ide> assert.equal(moment([2011, 0, 2 + i]).format('dddd ddd dd'), expected[i], expected[i]);
<ide> }
<ide> });
<ide>
<del>test("from", function (assert) {
<add>test('from', function (assert) {
<ide> var start = moment([2007, 1, 28]);
<ide> assert.equal(start.from(moment([2007, 1, 28]).add({s: 44}), true), 'ilang segundo', '44 seconds = a few seconds');
<ide> assert.equal(start.from(moment([2007, 1, 28]).add({s: 45}), true), 'isang minuto', '45 seconds = a minute');
<ide> test("from", function (assert) {
<ide> assert.equal(start.from(moment([2007, 1, 28]).add({y: 5}), true), '5 taon', '5 years = 5 years');
<ide> });
<ide>
<del>test("suffix", function (assert) {
<add>test('suffix', function (assert) {
<ide> assert.equal(moment(30000).from(0), 'sa loob ng ilang segundo', 'prefix');
<ide> assert.equal(moment(0).from(30000), 'ilang segundo ang nakalipas', 'suffix');
<ide> });
<ide>
<del>test("fromNow", function (assert) {
<add>test('fromNow', function (assert) {
<ide> assert.equal(moment().add({s: 30}).fromNow(), 'sa loob ng ilang segundo', 'in a few seconds');
<ide> assert.equal(moment().add({d: 5}).fromNow(), 'sa loob ng 5 araw', 'in 5 days');
<ide> });
<ide>
<del>test("same day", function (assert) {
<add>test('same day', function (assert) {
<ide> var a = moment().hours(2).minutes(0).seconds(0);
<ide>
<ide> assert.equal(moment(a).calendar(), 'Ngayon sa 02:00', 'today at the same time');
<ide> test("same day", function (assert) {
<ide> assert.equal(moment(a).subtract({d: 1}).calendar(), 'Kahapon sa 02:00', 'yesterday at the same time');
<ide> });
<ide>
<del>test("same next week", function (assert) {
<add>test('same next week', function (assert) {
<ide> var i, m;
<ide>
<ide> for (i = 2; i < 7; i++) {
<ide> test("same next week", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("same last week", function (assert) {
<add>test('same last week', function (assert) {
<ide> var i, m;
<ide>
<ide> for (i = 2; i < 7; i++) {
<ide> test("same last week", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("same all else", function (assert) {
<add>test('same all else', function (assert) {
<ide> var weeksAgo = moment().subtract({w: 1}),
<ide> weeksFromNow = moment().add({w: 1});
<ide>
<ide> test("same all else", function (assert) {
<ide> assert.equal(weeksFromNow.calendar(), weeksFromNow.format('L'), 'in 2 weeks');
<ide> });
<ide>
<del>test("weeks year starting sunday", function (assert) {
<add>test('weeks year starting sunday', function (assert) {
<ide> assert.equal(moment([2012, 0, 1]).week(), 52, 'Jan 1 2012 should be week 52');
<ide> assert.equal(moment([2012, 0, 2]).week(), 1, 'Jan 2 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 8]).week(), 1, 'Jan 8 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 9]).week(), 2, 'Jan 9 2012 should be week 2');
<ide> assert.equal(moment([2012, 0, 15]).week(), 2, 'Jan 15 2012 should be week 2');
<ide> });
<ide>
<del>test("weeks year starting monday", function (assert) {
<add>test('weeks year starting monday', function (assert) {
<ide> assert.equal(moment([2007, 0, 1]).week(), 1, 'Jan 1 2007 should be week 1');
<ide> assert.equal(moment([2007, 0, 7]).week(), 1, 'Jan 7 2007 should be week 1');
<ide> assert.equal(moment([2007, 0, 8]).week(), 2, 'Jan 8 2007 should be week 2');
<ide> assert.equal(moment([2007, 0, 14]).week(), 2, 'Jan 14 2007 should be week 2');
<ide> assert.equal(moment([2007, 0, 15]).week(), 3, 'Jan 15 2007 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting tuesday", function (assert) {
<add>test('weeks year starting tuesday', function (assert) {
<ide> assert.equal(moment([2007, 11, 31]).week(), 1, 'Dec 31 2007 should be week 1');
<ide> assert.equal(moment([2008, 0, 1]).week(), 1, 'Jan 1 2008 should be week 1');
<ide> assert.equal(moment([2008, 0, 6]).week(), 1, 'Jan 6 2008 should be week 1');
<ide> test("weeks year starting tuesday", function (assert) {
<ide> assert.equal(moment([2008, 0, 14]).week(), 3, 'Jan 14 2008 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting wednesday", function (assert) {
<add>test('weeks year starting wednesday', function (assert) {
<ide> assert.equal(moment([2002, 11, 30]).week(), 1, 'Dec 30 2002 should be week 1');
<ide> assert.equal(moment([2003, 0, 1]).week(), 1, 'Jan 1 2003 should be week 1');
<ide> assert.equal(moment([2003, 0, 5]).week(), 1, 'Jan 5 2003 should be week 1');
<ide> test("weeks year starting wednesday", function (assert) {
<ide> assert.equal(moment([2003, 0, 13]).week(), 3, 'Jan 13 2003 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting thursday", function (assert) {
<add>test('weeks year starting thursday', function (assert) {
<ide> assert.equal(moment([2008, 11, 29]).week(), 1, 'Dec 29 2008 should be week 1');
<ide> assert.equal(moment([2009, 0, 1]).week(), 1, 'Jan 1 2009 should be week 1');
<ide> assert.equal(moment([2009, 0, 4]).week(), 1, 'Jan 4 2009 should be week 1');
<ide> test("weeks year starting thursday", function (assert) {
<ide> assert.equal(moment([2009, 0, 13]).week(), 3, 'Jan 12 2009 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting friday", function (assert) {
<add>test('weeks year starting friday', function (assert) {
<ide> assert.equal(moment([2009, 11, 28]).week(), 53, 'Dec 28 2009 should be week 53');
<ide> assert.equal(moment([2010, 0, 1]).week(), 53, 'Jan 1 2010 should be week 53');
<ide> assert.equal(moment([2010, 0, 3]).week(), 53, 'Jan 3 2010 should be week 53');
<ide> test("weeks year starting friday", function (assert) {
<ide> assert.equal(moment([2010, 0, 11]).week(), 2, 'Jan 11 2010 should be week 2');
<ide> });
<ide>
<del>test("weeks year starting saturday", function (assert) {
<add>test('weeks year starting saturday', function (assert) {
<ide> assert.equal(moment([2010, 11, 27]).week(), 52, 'Dec 27 2010 should be week 52');
<ide> assert.equal(moment([2011, 0, 1]).week(), 52, 'Jan 1 2011 should be week 52');
<ide> assert.equal(moment([2011, 0, 2]).week(), 52, 'Jan 2 2011 should be week 52');
<ide> test("weeks year starting saturday", function (assert) {
<ide> assert.equal(moment([2011, 0, 10]).week(), 2, 'Jan 10 2011 should be week 2');
<ide> });
<ide>
<del>test("weeks year starting sunday formatted", function (assert) {
<add>test('weeks year starting sunday formatted', function (assert) {
<ide> assert.equal(moment([2012, 0, 1]).format('w ww wo'), '52 52 52', 'Jan 1 2012 should be week 52');
<ide> assert.equal(moment([2012, 0, 2]).format('w ww wo'), '1 01 1', 'Jan 2 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 8]).format('w ww wo'), '1 01 1', 'Jan 8 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 9]).format('w ww wo'), '2 02 2', 'Jan 9 2012 should be week 2');
<ide> assert.equal(moment([2012, 0, 15]).format('w ww wo'), '2 02 2', 'Jan 15 2012 should be week 2');
<ide> });
<ide>
<del>test("lenient ordinal parsing", function (assert) {
<add>test('lenient ordinal parsing', function (assert) {
<ide> var i, ordinalStr, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> ordinalStr = moment([2014, 0, i]).format('YYYY MM Do');
<ide> test("lenient ordinal parsing", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("lenient ordinal parsing of number", function (assert) {
<add>test('lenient ordinal parsing of number', function (assert) {
<ide> var i, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> testMoment = moment('2014 01 ' + i, 'YYYY MM Do');
<ide> test("lenient ordinal parsing of number", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("strict ordinal parsing", function (assert) {
<add>test('strict ordinal parsing', function (assert) {
<ide> var i, ordinalStr, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> ordinalStr = moment([2014, 0, i]).format('YYYY MM Do');
<ide><path>src/test/locale/tr.js
<del>import {localeModule, test} from "../qunit";
<del>import {moment} from "../../moment";
<del>localeModule("tr");
<add>import {localeModule, test} from '../qunit';
<add>import {moment} from '../../moment';
<add>localeModule('tr');
<ide>
<del>test("parse", function (assert) {
<add>test('parse', function (assert) {
<ide> var tests = 'Ocak Oca_Şubat Şub_Mart Mar_Nisan Nis_Mayıs May_Haziran Haz_Temmuz Tem_Ağustos Ağu_Eylül Eyl_Ekim Eki_Kasım Kas_Aralık Ara'.split('_'), i;
<ide> function equalTest(input, mmm, i) {
<ide> assert.equal(moment(input, mmm).month(), i, input + ' should be month ' + (i + 1));
<ide> test("parse", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("format", function (assert) {
<add>test('format', function (assert) {
<ide> var a = [
<ide> ['dddd, MMMM Do YYYY, h:mm:ss a', 'Pazar, Şubat 14\'üncü 2010, 3:25:50 pm'],
<ide> ['ddd, hA', 'Paz, 3PM'],
<ide> test("format", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("format ordinal", function (assert) {
<add>test('format ordinal', function (assert) {
<ide> assert.equal(moment([2011, 0, 1]).format('DDDo'), '1\'inci', '1st');
<ide> assert.equal(moment([2011, 0, 2]).format('DDDo'), '2\'nci', '2nd');
<ide> assert.equal(moment([2011, 0, 3]).format('DDDo'), '3\'üncü', '3rd');
<ide> test("format ordinal", function (assert) {
<ide> assert.equal(moment([2011, 0, 31]).format('DDDo'), '31\'inci', '31st');
<ide> });
<ide>
<del>test("format month", function (assert) {
<add>test('format month', function (assert) {
<ide> var expected = 'Ocak Oca_Şubat Şub_Mart Mar_Nisan Nis_Mayıs May_Haziran Haz_Temmuz Tem_Ağustos Ağu_Eylül Eyl_Ekim Eki_Kasım Kas_Aralık Ara'.split('_'), i;
<ide> for (i = 0; i < expected.length; i++) {
<ide> assert.equal(moment([2011, i, 1]).format('MMMM MMM'), expected[i], expected[i]);
<ide> }
<ide> });
<ide>
<del>test("format week", function (assert) {
<add>test('format week', function (assert) {
<ide> var expected = 'Pazar Paz Pz_Pazartesi Pts Pt_Salı Sal Sa_Çarşamba Çar Ça_Perşembe Per Pe_Cuma Cum Cu_Cumartesi Cts Ct'.split('_'), i;
<ide> for (i = 0; i < expected.length; i++) {
<ide> assert.equal(moment([2011, 0, 2 + i]).format('dddd ddd dd'), expected[i], expected[i]);
<ide> }
<ide> });
<ide>
<del>test("from", function (assert) {
<add>test('from', function (assert) {
<ide> var start = moment([2007, 1, 28]);
<ide> assert.equal(start.from(moment([2007, 1, 28]).add({s: 44}), true), 'birkaç saniye', '44 seconds = a few seconds');
<ide> assert.equal(start.from(moment([2007, 1, 28]).add({s: 45}), true), 'bir dakika', '45 seconds = a minute');
<ide> test("from", function (assert) {
<ide> assert.equal(start.from(moment([2007, 1, 28]).add({y: 5}), true), '5 yıl', '5 years = 5 years');
<ide> });
<ide>
<del>test("suffix", function (assert) {
<add>test('suffix', function (assert) {
<ide> assert.equal(moment(30000).from(0), 'birkaç saniye sonra', 'prefix');
<ide> assert.equal(moment(0).from(30000), 'birkaç saniye önce', 'suffix');
<ide> });
<ide>
<del>test("now from now", function (assert) {
<add>test('now from now', function (assert) {
<ide> assert.equal(moment().fromNow(), 'birkaç saniye önce', 'now from now should display as in the past');
<ide> });
<ide>
<del>test("fromNow", function (assert) {
<add>test('fromNow', function (assert) {
<ide> assert.equal(moment().add({s: 30}).fromNow(), 'birkaç saniye sonra', 'in a few seconds');
<ide> assert.equal(moment().add({d: 5}).fromNow(), '5 gün sonra', 'in 5 days');
<ide> });
<ide>
<del>test("calendar day", function (assert) {
<add>test('calendar day', function (assert) {
<ide> var a = moment().hours(2).minutes(0).seconds(0);
<ide>
<ide> assert.equal(moment(a).calendar(), 'bugün saat 02:00', 'today at the same time');
<ide> test("calendar day", function (assert) {
<ide> assert.equal(moment(a).subtract({d: 1}).calendar(), 'dün 02:00', 'yesterday at the same time');
<ide> });
<ide>
<del>test("calendar next week", function (assert) {
<add>test('calendar next week', function (assert) {
<ide> var i, m;
<ide> for (i = 2; i < 7; i++) {
<ide> m = moment().add({d: i});
<ide> test("calendar next week", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("calendar last week", function (assert) {
<add>test('calendar last week', function (assert) {
<ide> var i, m;
<ide> for (i = 2; i < 7; i++) {
<ide> m = moment().subtract({d: i});
<ide> test("calendar last week", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("calendar all else", function (assert) {
<add>test('calendar all else', function (assert) {
<ide> var weeksAgo = moment().subtract({w: 1}),
<ide> weeksFromNow = moment().add({w: 1});
<ide>
<ide> test("calendar all else", function (assert) {
<ide> assert.equal(weeksFromNow.calendar(), weeksFromNow.format('L'), 'in 2 weeks');
<ide> });
<ide>
<del>test("weeks year starting sunday", function (assert) {
<add>test('weeks year starting sunday', function (assert) {
<ide> assert.equal(moment([2011, 11, 26]).week(), 1, 'Dec 26 2011 should be week 1');
<ide> assert.equal(moment([2012, 0, 1]).week(), 1, 'Jan 1 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 2]).week(), 2, 'Jan 2 2012 should be week 2');
<ide> assert.equal(moment([2012, 0, 8]).week(), 2, 'Jan 8 2012 should be week 2');
<ide> assert.equal(moment([2012, 0, 9]).week(), 3, 'Jan 9 2012 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting monday", function (assert) {
<add>test('weeks year starting monday', function (assert) {
<ide> assert.equal(moment([2007, 0, 1]).week(), 1, 'Jan 1 2007 should be week 1');
<ide> assert.equal(moment([2007, 0, 7]).week(), 1, 'Jan 7 2007 should be week 1');
<ide> assert.equal(moment([2007, 0, 8]).week(), 2, 'Jan 8 2007 should be week 2');
<ide> assert.equal(moment([2007, 0, 14]).week(), 2, 'Jan 14 2007 should be week 2');
<ide> assert.equal(moment([2007, 0, 15]).week(), 3, 'Jan 15 2007 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting tuesday", function (assert) {
<add>test('weeks year starting tuesday', function (assert) {
<ide> assert.equal(moment([2007, 11, 31]).week(), 1, 'Dec 31 2007 should be week 1');
<ide> assert.equal(moment([2008, 0, 1]).week(), 1, 'Jan 1 2008 should be week 1');
<ide> assert.equal(moment([2008, 0, 6]).week(), 1, 'Jan 6 2008 should be week 1');
<ide> test("weeks year starting tuesday", function (assert) {
<ide> assert.equal(moment([2008, 0, 14]).week(), 3, 'Jan 14 2008 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting wednesday", function (assert) {
<add>test('weeks year starting wednesday', function (assert) {
<ide> assert.equal(moment([2002, 11, 30]).week(), 1, 'Dec 30 2002 should be week 1');
<ide> assert.equal(moment([2003, 0, 1]).week(), 1, 'Jan 1 2003 should be week 1');
<ide> assert.equal(moment([2003, 0, 5]).week(), 1, 'Jan 5 2003 should be week 1');
<ide> test("weeks year starting wednesday", function (assert) {
<ide> assert.equal(moment([2003, 0, 13]).week(), 3, 'Jan 13 2003 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting thursday", function (assert) {
<add>test('weeks year starting thursday', function (assert) {
<ide> assert.equal(moment([2008, 11, 29]).week(), 1, 'Dec 29 2008 should be week 1');
<ide> assert.equal(moment([2009, 0, 1]).week(), 1, 'Jan 1 2009 should be week 1');
<ide> assert.equal(moment([2009, 0, 4]).week(), 1, 'Jan 4 2009 should be week 1');
<ide> test("weeks year starting thursday", function (assert) {
<ide> assert.equal(moment([2009, 0, 12]).week(), 3, 'Jan 12 2009 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting friday", function (assert) {
<add>test('weeks year starting friday', function (assert) {
<ide> assert.equal(moment([2009, 11, 28]).week(), 1, 'Dec 28 2009 should be week 1');
<ide> assert.equal(moment([2010, 0, 1]).week(), 1, 'Jan 1 2010 should be week 1');
<ide> assert.equal(moment([2010, 0, 3]).week(), 1, 'Jan 3 2010 should be week 1');
<ide> test("weeks year starting friday", function (assert) {
<ide> assert.equal(moment([2010, 0, 11]).week(), 3, 'Jan 11 2010 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting saturday", function (assert) {
<add>test('weeks year starting saturday', function (assert) {
<ide> assert.equal(moment([2010, 11, 27]).week(), 1, 'Dec 27 2010 should be week 1');
<ide> assert.equal(moment([2011, 0, 1]).week(), 1, 'Jan 1 2011 should be week 1');
<ide> assert.equal(moment([2011, 0, 2]).week(), 1, 'Jan 2 2011 should be week 1');
<ide> test("weeks year starting saturday", function (assert) {
<ide> assert.equal(moment([2011, 0, 10]).week(), 3, 'Jan 10 2011 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting sunday formatted", function (assert) {
<add>test('weeks year starting sunday formatted', function (assert) {
<ide> assert.equal(moment([2011, 11, 26]).format('w ww wo'), '1 01 1\'inci', 'Dec 26 2011 should be week 1');
<ide> assert.equal(moment([2012, 0, 1]).format('w ww wo'), '1 01 1\'inci', 'Jan 1 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 2]).format('w ww wo'), '2 02 2\'nci', 'Jan 2 2012 should be week 2');
<ide> assert.equal(moment([2012, 0, 8]).format('w ww wo'), '2 02 2\'nci', 'Jan 8 2012 should be week 2');
<ide> assert.equal(moment([2012, 0, 9]).format('w ww wo'), '3 03 3\'üncü', 'Jan 9 2012 should be week 3');
<ide> });
<ide>
<del>test("lenient ordinal parsing", function (assert) {
<add>test('lenient ordinal parsing', function (assert) {
<ide> var i, ordinalStr, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> ordinalStr = moment([2014, 0, i]).format('YYYY MM Do');
<ide> test("lenient ordinal parsing", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("lenient ordinal parsing of number", function (assert) {
<add>test('lenient ordinal parsing of number', function (assert) {
<ide> var i, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> testMoment = moment('2014 01 ' + i, 'YYYY MM Do');
<ide> test("lenient ordinal parsing of number", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("strict ordinal parsing", function (assert) {
<add>test('strict ordinal parsing', function (assert) {
<ide> var i, ordinalStr, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> ordinalStr = moment([2014, 0, i]).format('YYYY MM Do');
<ide><path>src/test/locale/tzm-latn.js
<del>import {localeModule, test} from "../qunit";
<del>import {moment} from "../../moment";
<del>localeModule("tzm-latn");
<add>import {localeModule, test} from '../qunit';
<add>import {moment} from '../../moment';
<add>localeModule('tzm-latn');
<ide>
<del>test("parse", function (assert) {
<add>test('parse', function (assert) {
<ide> var tests = 'innayr innayr_brˤayrˤ brˤayrˤ_marˤsˤ marˤsˤ_ibrir ibrir_mayyw mayyw_ywnyw ywnyw_ywlywz ywlywz_ɣwšt ɣwšt_šwtanbir šwtanbir_ktˤwbrˤ ktˤwbrˤ_nwwanbir nwwanbir_dwjnbir dwjnbir'.split('_'), i;
<ide> function equalTest(input, mmm, i) {
<ide> assert.equal(moment(input, mmm).month(), i, input + ' should be month ' + (i + 1));
<ide> test("parse", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("format", function (assert) {
<add>test('format', function (assert) {
<ide> var a = [
<ide> ['dddd, MMMM Do YYYY, h:mm:ss a', 'asamas, brˤayrˤ 14 2010, 3:25:50 pm'],
<ide> ['ddd, hA', 'asamas, 3PM'],
<ide> test("format", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("format ordinal", function (assert) {
<add>test('format ordinal', function (assert) {
<ide> assert.equal(moment([2011, 0, 1]).format('DDDo'), '1', '1');
<ide> assert.equal(moment([2011, 0, 2]).format('DDDo'), '2', '2');
<ide> assert.equal(moment([2011, 0, 3]).format('DDDo'), '3', '3');
<ide> test("format ordinal", function (assert) {
<ide> assert.equal(moment([2011, 0, 31]).format('DDDo'), '31', '31');
<ide> });
<ide>
<del>test("format month", function (assert) {
<add>test('format month', function (assert) {
<ide> var expected = 'innayr innayr_brˤayrˤ brˤayrˤ_marˤsˤ marˤsˤ_ibrir ibrir_mayyw mayyw_ywnyw ywnyw_ywlywz ywlywz_ɣwšt ɣwšt_šwtanbir šwtanbir_ktˤwbrˤ ktˤwbrˤ_nwwanbir nwwanbir_dwjnbir dwjnbir'.split('_'), i;
<ide> for (i = 0; i < expected.length; i++) {
<ide> assert.equal(moment([2011, i, 1]).format('MMMM MMM'), expected[i], expected[i]);
<ide> }
<ide> });
<ide>
<del>test("format week", function (assert) {
<add>test('format week', function (assert) {
<ide> var expected = 'asamas asamas asamas_aynas aynas aynas_asinas asinas asinas_akras akras akras_akwas akwas akwas_asimwas asimwas asimwas_asiḍyas asiḍyas asiḍyas'.split('_'), i;
<ide> for (i = 0; i < expected.length; i++) {
<ide> assert.equal(moment([2011, 0, 2 + i]).format('dddd ddd dd'), expected[i], expected[i]);
<ide> }
<ide> });
<ide>
<del>test("from", function (assert) {
<add>test('from', function (assert) {
<ide> var start = moment([2007, 1, 28]);
<ide> assert.equal(start.from(moment([2007, 1, 28]).add({s: 44}), true), 'imik', '44 seconds = a few seconds');
<ide> assert.equal(start.from(moment([2007, 1, 28]).add({s: 45}), true), 'minuḍ', '45 seconds = a minute');
<ide> test("from", function (assert) {
<ide> assert.equal(start.from(moment([2007, 1, 28]).add({y: 5}), true), '5 isgasn', '5 years = 5 years');
<ide> });
<ide>
<del>test("suffix", function (assert) {
<add>test('suffix', function (assert) {
<ide> assert.equal(moment(30000).from(0), 'dadkh s yan imik', 'prefix');
<ide> assert.equal(moment(0).from(30000), 'yan imik', 'suffix');
<ide> });
<ide>
<del>test("now from now", function (assert) {
<add>test('now from now', function (assert) {
<ide> assert.equal(moment().fromNow(), 'yan imik', 'now from now should display as in the past');
<ide> });
<ide>
<del>test("fromNow", function (assert) {
<add>test('fromNow', function (assert) {
<ide> assert.equal(moment().add({s: 30}).fromNow(), 'dadkh s yan imik', 'in a few seconds');
<ide> assert.equal(moment().add({d: 5}).fromNow(), 'dadkh s yan 5 ossan', 'in 5 days');
<ide> });
<ide>
<del>test("calendar day", function (assert) {
<add>test('calendar day', function (assert) {
<ide> var a = moment().hours(2).minutes(0).seconds(0);
<ide>
<ide> assert.equal(moment(a).calendar(), 'asdkh g 02:00', 'today at the same time');
<ide> test("calendar day", function (assert) {
<ide> assert.equal(moment(a).subtract({d: 1}).calendar(), 'assant g 02:00', 'yesterday at the same time');
<ide> });
<ide>
<del>test("calendar next week", function (assert) {
<add>test('calendar next week', function (assert) {
<ide> var i, m;
<ide> for (i = 2; i < 7; i++) {
<ide> m = moment().add({d: i});
<ide> test("calendar next week", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("calendar last week", function (assert) {
<add>test('calendar last week', function (assert) {
<ide> var i, m;
<ide> for (i = 2; i < 7; i++) {
<ide> m = moment().subtract({d: i});
<ide> test("calendar last week", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("calendar all else", function (assert) {
<add>test('calendar all else', function (assert) {
<ide> var weeksAgo = moment().subtract({w: 1}),
<ide> weeksFromNow = moment().add({w: 1});
<ide>
<ide> test("calendar all else", function (assert) {
<ide> assert.equal(weeksFromNow.calendar(), weeksFromNow.format('L'), 'in 2 weeks');
<ide> });
<ide>
<del>test("weeks year starting sunday", function (assert) {
<add>test('weeks year starting sunday', function (assert) {
<ide> assert.equal(moment([2011, 11, 31]).week(), 1, 'Dec 31 2011 should be week 1');
<ide> assert.equal(moment([2012, 0, 6]).week(), 1, 'Jan 6 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 7]).week(), 2, 'Jan 7 2012 should be week 2');
<ide> assert.equal(moment([2012, 0, 13]).week(), 2, 'Jan 13 2012 should be week 2');
<ide> assert.equal(moment([2012, 0, 14]).week(), 3, 'Jan 14 2012 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting monday", function (assert) {
<add>test('weeks year starting monday', function (assert) {
<ide> assert.equal(moment([2006, 11, 30]).week(), 1, 'Dec 30 2006 should be week 1');
<ide> assert.equal(moment([2007, 0, 5]).week(), 1, 'Jan 5 2007 should be week 1');
<ide> assert.equal(moment([2007, 0, 6]).week(), 2, 'Jan 6 2007 should be week 2');
<ide> assert.equal(moment([2007, 0, 12]).week(), 2, 'Jan 12 2007 should be week 2');
<ide> assert.equal(moment([2007, 0, 13]).week(), 3, 'Jan 13 2007 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting tuesday", function (assert) {
<add>test('weeks year starting tuesday', function (assert) {
<ide> assert.equal(moment([2007, 11, 29]).week(), 1, 'Dec 29 2007 should be week 1');
<ide> assert.equal(moment([2008, 0, 1]).week(), 1, 'Jan 1 2008 should be week 1');
<ide> assert.equal(moment([2008, 0, 4]).week(), 1, 'Jan 4 2008 should be week 1');
<ide> test("weeks year starting tuesday", function (assert) {
<ide> assert.equal(moment([2008, 0, 12]).week(), 3, 'Jan 12 2008 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting wednesday", function (assert) {
<add>test('weeks year starting wednesday', function (assert) {
<ide> assert.equal(moment([2002, 11, 28]).week(), 1, 'Dec 28 2002 should be week 1');
<ide> assert.equal(moment([2003, 0, 1]).week(), 1, 'Jan 1 2003 should be week 1');
<ide> assert.equal(moment([2003, 0, 3]).week(), 1, 'Jan 3 2003 should be week 1');
<ide> test("weeks year starting wednesday", function (assert) {
<ide> assert.equal(moment([2003, 0, 11]).week(), 3, 'Jan 11 2003 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting thursday", function (assert) {
<add>test('weeks year starting thursday', function (assert) {
<ide> assert.equal(moment([2008, 11, 27]).week(), 1, 'Dec 27 2008 should be week 1');
<ide> assert.equal(moment([2009, 0, 1]).week(), 1, 'Jan 1 2009 should be week 1');
<ide> assert.equal(moment([2009, 0, 2]).week(), 1, 'Jan 2 2009 should be week 1');
<ide> test("weeks year starting thursday", function (assert) {
<ide> assert.equal(moment([2009, 0, 10]).week(), 3, 'Jan 10 2009 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting friday", function (assert) {
<add>test('weeks year starting friday', function (assert) {
<ide> assert.equal(moment([2009, 11, 26]).week(), 1, 'Dec 26 2009 should be week 1');
<ide> assert.equal(moment([2010, 0, 1]).week(), 1, 'Jan 1 2010 should be week 1');
<ide> assert.equal(moment([2010, 0, 2]).week(), 2, 'Jan 2 2010 should be week 2');
<ide> assert.equal(moment([2010, 0, 8]).week(), 2, 'Jan 8 2010 should be week 2');
<ide> assert.equal(moment([2010, 0, 9]).week(), 3, 'Jan 9 2010 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting saturday", function (assert) {
<add>test('weeks year starting saturday', function (assert) {
<ide> assert.equal(moment([2011, 0, 1]).week(), 1, 'Jan 1 2011 should be week 1');
<ide> assert.equal(moment([2011, 0, 7]).week(), 1, 'Jan 7 2011 should be week 1');
<ide> assert.equal(moment([2011, 0, 8]).week(), 2, 'Jan 8 2011 should be week 2');
<ide> assert.equal(moment([2011, 0, 14]).week(), 2, 'Jan 14 2011 should be week 2');
<ide> assert.equal(moment([2011, 0, 15]).week(), 3, 'Jan 15 2011 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting sunday formatted", function (assert) {
<add>test('weeks year starting sunday formatted', function (assert) {
<ide> assert.equal(moment([2011, 11, 31]).format('w ww wo'), '1 01 1', 'Dec 31 2011 should be week 1');
<ide> assert.equal(moment([2012, 0, 6]).format('w ww wo'), '1 01 1', 'Jan 6 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 7]).format('w ww wo'), '2 02 2', 'Jan 7 2012 should be week 2');
<ide> assert.equal(moment([2012, 0, 13]).format('w ww wo'), '2 02 2', 'Jan 13 2012 should be week 2');
<ide> assert.equal(moment([2012, 0, 14]).format('w ww wo'), '3 03 3', 'Jan 14 2012 should be week 3');
<ide> });
<ide>
<del>test("lenient ordinal parsing", function (assert) {
<add>test('lenient ordinal parsing', function (assert) {
<ide> var i, ordinalStr, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> ordinalStr = moment([2014, 0, i]).format('YYYY MM Do');
<ide> test("lenient ordinal parsing", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("lenient ordinal parsing of number", function (assert) {
<add>test('lenient ordinal parsing of number', function (assert) {
<ide> var i, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> testMoment = moment('2014 01 ' + i, 'YYYY MM Do');
<ide> test("lenient ordinal parsing of number", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("strict ordinal parsing", function (assert) {
<add>test('strict ordinal parsing', function (assert) {
<ide> var i, ordinalStr, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> ordinalStr = moment([2014, 0, i]).format('YYYY MM Do');
<ide><path>src/test/locale/tzm.js
<del>import {localeModule, test} from "../qunit";
<del>import {moment} from "../../moment";
<del>localeModule("tzm");
<add>import {localeModule, test} from '../qunit';
<add>import {moment} from '../../moment';
<add>localeModule('tzm');
<ide>
<del>test("parse", function (assert) {
<add>test('parse', function (assert) {
<ide> var tests = 'ⵉⵏⵏⴰⵢⵔ ⵉⵏⵏⴰⵢⵔ_ⴱⵕⴰⵢⵕ ⴱⵕⴰⵢⵕ_ⵎⴰⵕⵚ ⵎⴰⵕⵚ_ⵉⴱⵔⵉⵔ ⵉⴱⵔⵉⵔ_ⵎⴰⵢⵢⵓ ⵎⴰⵢⵢⵓ_ⵢⵓⵏⵢⵓ ⵢⵓⵏⵢⵓ_ⵢⵓⵍⵢⵓⵣ ⵢⵓⵍⵢⵓⵣ_ⵖⵓⵛⵜ ⵖⵓⵛⵜ_ⵛⵓⵜⴰⵏⴱⵉⵔ ⵛⵓⵜⴰⵏⴱⵉⵔ_ⴽⵟⵓⴱⵕ ⴽⵟⵓⴱⵕ_ⵏⵓⵡⴰⵏⴱⵉⵔ ⵏⵓⵡⴰⵏⴱⵉⵔ_ⴷⵓⵊⵏⴱⵉⵔ ⴷⵓⵊⵏⴱⵉⵔ'.split('_'), i;
<ide> function equalTest(input, mmm, i) {
<ide> assert.equal(moment(input, mmm).month(), i, input + ' should be month ' + (i + 1));
<ide> test("parse", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("format", function (assert) {
<add>test('format', function (assert) {
<ide> var a = [
<ide> ['dddd, MMMM Do YYYY, h:mm:ss a', 'ⴰⵙⴰⵎⴰⵙ, ⴱⵕⴰⵢⵕ 14 2010, 3:25:50 pm'],
<ide> ['ddd, hA', 'ⴰⵙⴰⵎⴰⵙ, 3PM'],
<ide> test("format", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("format ordinal", function (assert) {
<add>test('format ordinal', function (assert) {
<ide> assert.equal(moment([2011, 0, 1]).format('DDDo'), '1', '1');
<ide> assert.equal(moment([2011, 0, 2]).format('DDDo'), '2', '2');
<ide> assert.equal(moment([2011, 0, 3]).format('DDDo'), '3', '3');
<ide> test("format ordinal", function (assert) {
<ide> assert.equal(moment([2011, 0, 31]).format('DDDo'), '31', '31');
<ide> });
<ide>
<del>test("format month", function (assert) {
<add>test('format month', function (assert) {
<ide> var expected = 'ⵉⵏⵏⴰⵢⵔ ⵉⵏⵏⴰⵢⵔ_ⴱⵕⴰⵢⵕ ⴱⵕⴰⵢⵕ_ⵎⴰⵕⵚ ⵎⴰⵕⵚ_ⵉⴱⵔⵉⵔ ⵉⴱⵔⵉⵔ_ⵎⴰⵢⵢⵓ ⵎⴰⵢⵢⵓ_ⵢⵓⵏⵢⵓ ⵢⵓⵏⵢⵓ_ⵢⵓⵍⵢⵓⵣ ⵢⵓⵍⵢⵓⵣ_ⵖⵓⵛⵜ ⵖⵓⵛⵜ_ⵛⵓⵜⴰⵏⴱⵉⵔ ⵛⵓⵜⴰⵏⴱⵉⵔ_ⴽⵟⵓⴱⵕ ⴽⵟⵓⴱⵕ_ⵏⵓⵡⴰⵏⴱⵉⵔ ⵏⵓⵡⴰⵏⴱⵉⵔ_ⴷⵓⵊⵏⴱⵉⵔ ⴷⵓⵊⵏⴱⵉⵔ'.split('_'), i;
<ide> for (i = 0; i < expected.length; i++) {
<ide> assert.equal(moment([2011, i, 1]).format('MMMM MMM'), expected[i], expected[i]);
<ide> }
<ide> });
<ide>
<del>test("format week", function (assert) {
<add>test('format week', function (assert) {
<ide> var expected = 'ⴰⵙⴰⵎⴰⵙ ⴰⵙⴰⵎⴰⵙ ⴰⵙⴰⵎⴰⵙ_ⴰⵢⵏⴰⵙ ⴰⵢⵏⴰⵙ ⴰⵢⵏⴰⵙ_ⴰⵙⵉⵏⴰⵙ ⴰⵙⵉⵏⴰⵙ ⴰⵙⵉⵏⴰⵙ_ⴰⴽⵔⴰⵙ ⴰⴽⵔⴰⵙ ⴰⴽⵔⴰⵙ_ⴰⴽⵡⴰⵙ ⴰⴽⵡⴰⵙ ⴰⴽⵡⴰⵙ_ⴰⵙⵉⵎⵡⴰⵙ ⴰⵙⵉⵎⵡⴰⵙ ⴰⵙⵉⵎⵡⴰⵙ_ⴰⵙⵉⴹⵢⴰⵙ ⴰⵙⵉⴹⵢⴰⵙ ⴰⵙⵉⴹⵢⴰⵙ'.split('_'), i;
<ide> for (i = 0; i < expected.length; i++) {
<ide> assert.equal(moment([2011, 0, 2 + i]).format('dddd ddd dd'), expected[i], expected[i]);
<ide> }
<ide> });
<ide>
<del>test("from", function (assert) {
<add>test('from', function (assert) {
<ide> var start = moment([2007, 1, 28]);
<ide> assert.equal(start.from(moment([2007, 1, 28]).add({s: 44}), true), 'ⵉⵎⵉⴽ', '44 seconds = a few seconds');
<ide> assert.equal(start.from(moment([2007, 1, 28]).add({s: 45}), true), 'ⵎⵉⵏⵓⴺ', '45 seconds = a minute');
<ide> test("from", function (assert) {
<ide> assert.equal(start.from(moment([2007, 1, 28]).add({y: 5}), true), '5 ⵉⵙⴳⴰⵙⵏ', '5 years = 5 years');
<ide> });
<ide>
<del>test("suffix", function (assert) {
<add>test('suffix', function (assert) {
<ide> assert.equal(moment(30000).from(0), 'ⴷⴰⴷⵅ ⵙ ⵢⴰⵏ ⵉⵎⵉⴽ', 'prefix');
<ide> assert.equal(moment(0).from(30000), 'ⵢⴰⵏ ⵉⵎⵉⴽ', 'suffix');
<ide> });
<ide>
<del>test("now from now", function (assert) {
<add>test('now from now', function (assert) {
<ide> assert.equal(moment().fromNow(), 'ⵢⴰⵏ ⵉⵎⵉⴽ', 'now from now should display as in the past');
<ide> });
<ide>
<del>test("fromNow", function (assert) {
<add>test('fromNow', function (assert) {
<ide> assert.equal(moment().add({s: 30}).fromNow(), 'ⴷⴰⴷⵅ ⵙ ⵢⴰⵏ ⵉⵎⵉⴽ', 'in a few seconds');
<ide> assert.equal(moment().add({d: 5}).fromNow(), 'ⴷⴰⴷⵅ ⵙ ⵢⴰⵏ 5 oⵙⵙⴰⵏ', 'in 5 days');
<ide> });
<ide>
<del>test("calendar day", function (assert) {
<add>test('calendar day', function (assert) {
<ide> var a = moment().hours(2).minutes(0).seconds(0);
<ide>
<ide> assert.equal(moment(a).calendar(), 'ⴰⵙⴷⵅ ⴴ 02:00', 'today at the same time');
<ide> test("calendar day", function (assert) {
<ide> assert.equal(moment(a).subtract({d: 1}).calendar(), 'ⴰⵚⴰⵏⵜ ⴴ 02:00', 'yesterday at the same time');
<ide> });
<ide>
<del>test("calendar next week", function (assert) {
<add>test('calendar next week', function (assert) {
<ide> var i, m;
<ide> for (i = 2; i < 7; i++) {
<ide> m = moment().add({d: i});
<ide> test("calendar next week", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("calendar last week", function (assert) {
<add>test('calendar last week', function (assert) {
<ide> var i, m;
<ide> for (i = 2; i < 7; i++) {
<ide> m = moment().subtract({d: i});
<ide> test("calendar last week", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("calendar all else", function (assert) {
<add>test('calendar all else', function (assert) {
<ide> var weeksAgo = moment().subtract({w: 1}),
<ide> weeksFromNow = moment().add({w: 1});
<ide>
<ide> test("calendar all else", function (assert) {
<ide> assert.equal(weeksFromNow.calendar(), weeksFromNow.format('L'), 'in 2 weeks');
<ide> });
<ide>
<del>test("weeks year starting sunday", function (assert) {
<add>test('weeks year starting sunday', function (assert) {
<ide> assert.equal(moment([2011, 11, 31]).week(), 1, 'Dec 31 2011 should be week 1');
<ide> assert.equal(moment([2012, 0, 6]).week(), 1, 'Jan 6 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 7]).week(), 2, 'Jan 7 2012 should be week 2');
<ide> assert.equal(moment([2012, 0, 13]).week(), 2, 'Jan 13 2012 should be week 2');
<ide> assert.equal(moment([2012, 0, 14]).week(), 3, 'Jan 14 2012 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting monday", function (assert) {
<add>test('weeks year starting monday', function (assert) {
<ide> assert.equal(moment([2006, 11, 30]).week(), 1, 'Dec 30 2006 should be week 1');
<ide> assert.equal(moment([2007, 0, 5]).week(), 1, 'Jan 5 2007 should be week 1');
<ide> assert.equal(moment([2007, 0, 6]).week(), 2, 'Jan 6 2007 should be week 2');
<ide> assert.equal(moment([2007, 0, 12]).week(), 2, 'Jan 12 2007 should be week 2');
<ide> assert.equal(moment([2007, 0, 13]).week(), 3, 'Jan 13 2007 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting tuesday", function (assert) {
<add>test('weeks year starting tuesday', function (assert) {
<ide> assert.equal(moment([2007, 11, 29]).week(), 1, 'Dec 29 2007 should be week 1');
<ide> assert.equal(moment([2008, 0, 1]).week(), 1, 'Jan 1 2008 should be week 1');
<ide> assert.equal(moment([2008, 0, 4]).week(), 1, 'Jan 4 2008 should be week 1');
<ide> test("weeks year starting tuesday", function (assert) {
<ide> assert.equal(moment([2008, 0, 12]).week(), 3, 'Jan 12 2008 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting wednesday", function (assert) {
<add>test('weeks year starting wednesday', function (assert) {
<ide> assert.equal(moment([2002, 11, 28]).week(), 1, 'Dec 28 2002 should be week 1');
<ide> assert.equal(moment([2003, 0, 1]).week(), 1, 'Jan 1 2003 should be week 1');
<ide> assert.equal(moment([2003, 0, 3]).week(), 1, 'Jan 3 2003 should be week 1');
<ide> test("weeks year starting wednesday", function (assert) {
<ide> assert.equal(moment([2003, 0, 11]).week(), 3, 'Jan 11 2003 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting thursday", function (assert) {
<add>test('weeks year starting thursday', function (assert) {
<ide> assert.equal(moment([2008, 11, 27]).week(), 1, 'Dec 27 2008 should be week 1');
<ide> assert.equal(moment([2009, 0, 1]).week(), 1, 'Jan 1 2009 should be week 1');
<ide> assert.equal(moment([2009, 0, 2]).week(), 1, 'Jan 2 2009 should be week 1');
<ide> test("weeks year starting thursday", function (assert) {
<ide> assert.equal(moment([2009, 0, 10]).week(), 3, 'Jan 10 2009 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting friday", function (assert) {
<add>test('weeks year starting friday', function (assert) {
<ide> assert.equal(moment([2009, 11, 26]).week(), 1, 'Dec 26 2009 should be week 1');
<ide> assert.equal(moment([2010, 0, 1]).week(), 1, 'Jan 1 2010 should be week 1');
<ide> assert.equal(moment([2010, 0, 2]).week(), 2, 'Jan 2 2010 should be week 2');
<ide> assert.equal(moment([2010, 0, 8]).week(), 2, 'Jan 8 2010 should be week 2');
<ide> assert.equal(moment([2010, 0, 9]).week(), 3, 'Jan 9 2010 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting saturday", function (assert) {
<add>test('weeks year starting saturday', function (assert) {
<ide> assert.equal(moment([2011, 0, 1]).week(), 1, 'Jan 1 2011 should be week 1');
<ide> assert.equal(moment([2011, 0, 7]).week(), 1, 'Jan 7 2011 should be week 1');
<ide> assert.equal(moment([2011, 0, 8]).week(), 2, 'Jan 8 2011 should be week 2');
<ide> assert.equal(moment([2011, 0, 14]).week(), 2, 'Jan 14 2011 should be week 2');
<ide> assert.equal(moment([2011, 0, 15]).week(), 3, 'Jan 15 2011 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting sunday formatted", function (assert) {
<add>test('weeks year starting sunday formatted', function (assert) {
<ide> assert.equal(moment([2011, 11, 31]).format('w ww wo'), '1 01 1', 'Dec 31 2011 should be week 1');
<ide> assert.equal(moment([2012, 0, 6]).format('w ww wo'), '1 01 1', 'Jan 6 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 7]).format('w ww wo'), '2 02 2', 'Jan 7 2012 should be week 2');
<ide> assert.equal(moment([2012, 0, 13]).format('w ww wo'), '2 02 2', 'Jan 13 2012 should be week 2');
<ide> assert.equal(moment([2012, 0, 14]).format('w ww wo'), '3 03 3', 'Jan 14 2012 should be week 3');
<ide> });
<ide>
<del>test("lenient ordinal parsing", function (assert) {
<add>test('lenient ordinal parsing', function (assert) {
<ide> var i, ordinalStr, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> ordinalStr = moment([2014, 0, i]).format('YYYY MM Do');
<ide> test("lenient ordinal parsing", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("lenient ordinal parsing of number", function (assert) {
<add>test('lenient ordinal parsing of number', function (assert) {
<ide> var i, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> testMoment = moment('2014 01 ' + i, 'YYYY MM Do');
<ide> test("lenient ordinal parsing of number", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("strict ordinal parsing", function (assert) {
<add>test('strict ordinal parsing', function (assert) {
<ide> var i, ordinalStr, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> ordinalStr = moment([2014, 0, i]).format('YYYY MM Do');
<ide><path>src/test/locale/uk.js
<del>import {localeModule, test} from "../qunit";
<del>import {moment} from "../../moment";
<del>localeModule("uk");
<add>import {localeModule, test} from '../qunit';
<add>import {moment} from '../../moment';
<add>localeModule('uk');
<ide>
<del>test("parse", function (assert) {
<add>test('parse', function (assert) {
<ide> var tests = 'січень січ_лютий лют_березень бер_квітень квіт_травень трав_червень черв_липень лип_серпень серп_вересень вер_жовтень жовт_листопад лист_грудень груд'.split('_'), i;
<ide> function equalTest(input, mmm, i) {
<ide> assert.equal(moment(input, mmm).month(), i, input + ' should be month ' + (i + 1));
<ide> test("parse", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("format", function (assert) {
<add>test('format', function (assert) {
<ide> var a = [
<ide> ['dddd, Do MMMM YYYY, HH:mm:ss', 'неділя, 14-го лютого 2010, 15:25:50'],
<ide> ['ddd, h A', 'нд, 3 дня'],
<ide> test("format", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("format meridiem", function (assert) {
<add>test('format meridiem', function (assert) {
<ide> assert.equal(moment([2012, 11, 28, 0, 0]).format('A'), 'ночі', 'night');
<ide> assert.equal(moment([2012, 11, 28, 3, 59]).format('A'), 'ночі', 'night');
<ide> assert.equal(moment([2012, 11, 28, 4, 0]).format('A'), 'ранку', 'morning');
<ide> test("format meridiem", function (assert) {
<ide> assert.equal(moment([2012, 11, 28, 23, 59]).format('A'), 'вечора', 'evening');
<ide> });
<ide>
<del>test("format ordinal", function (assert) {
<add>test('format ordinal', function (assert) {
<ide> assert.equal(moment([2011, 0, 1]).format('DDDo'), '1-й', '1-й');
<ide> assert.equal(moment([2011, 0, 2]).format('DDDo'), '2-й', '2-й');
<ide> assert.equal(moment([2011, 0, 3]).format('DDDo'), '3-й', '3-й');
<ide> test("format ordinal", function (assert) {
<ide> assert.equal(moment([2011, 0, 31]).format('DDDo'), '31-й', '31-й');
<ide> });
<ide>
<del>test("format month", function (assert) {
<add>test('format month', function (assert) {
<ide> var expected = 'січень січ_лютий лют_березень бер_квітень квіт_травень трав_червень черв_липень лип_серпень серп_вересень вер_жовтень жовт_листопад лист_грудень груд'.split('_'), i;
<ide> for (i = 0; i < expected.length; i++) {
<ide> assert.equal(moment([2011, i, 1]).format('MMMM MMM'), expected[i], expected[i]);
<ide> }
<ide> });
<ide>
<del>test("format month case", function (assert) {
<add>test('format month case', function (assert) {
<ide> var months = {
<ide> 'nominative': 'січень_лютий_березень_квітень_травень_червень_липень_серпень_вересень_жовтень_листопад_грудень'.split('_'),
<ide> 'accusative': 'січня_лютого_березня_квітня_травня_червня_липня_серпня_вересня_жовтня_листопада_грудня'.split('_')
<ide> test("format month case", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("format week", function (assert) {
<add>test('format week', function (assert) {
<ide> var expected = 'неділя нд нд_понеділок пн пн_вівторок вт вт_середа ср ср_четвер чт чт_п’ятниця пт пт_субота сб сб'.split('_'), i;
<ide> for (i = 0; i < expected.length; i++) {
<ide> assert.equal(moment([2011, 0, 2 + i]).format('dddd ddd dd'), expected[i], expected[i]);
<ide> }
<ide> });
<ide>
<del>test("from", function (assert) {
<add>test('from', function (assert) {
<ide> var start = moment([2007, 1, 28]);
<ide> assert.equal(start.from(moment([2007, 1, 28]).add({s: 44}), true), 'декілька секунд', '44 seconds = seconds');
<ide> assert.equal(start.from(moment([2007, 1, 28]).add({s: 45}), true), 'хвилина', '45 seconds = a minute');
<ide> test("from", function (assert) {
<ide> assert.equal(start.from(moment([2007, 1, 28]).add({y: 5}), true), '5 років', '5 years = 5 years');
<ide> });
<ide>
<del>test("suffix", function (assert) {
<add>test('suffix', function (assert) {
<ide> assert.equal(moment(30000).from(0), 'за декілька секунд', 'prefix');
<ide> assert.equal(moment(0).from(30000), 'декілька секунд тому', 'suffix');
<ide> });
<ide>
<del>test("fromNow", function (assert) {
<add>test('fromNow', function (assert) {
<ide> assert.equal(moment().add({s: 30}).fromNow(), 'за декілька секунд', 'in seconds');
<ide> assert.equal(moment().add({d: 5}).fromNow(), 'за 5 днів', 'in 5 days');
<ide> });
<ide>
<del>test("calendar day", function (assert) {
<add>test('calendar day', function (assert) {
<ide> var a = moment().hours(2).minutes(0).seconds(0);
<ide>
<ide> assert.equal(moment(a).calendar(), 'Сьогодні о 02:00', 'today at the same time');
<ide> test("calendar day", function (assert) {
<ide> assert.equal(moment(a).add({h: 9}).calendar(), 'Сьогодні об 11:00', 'same day at 11 o\'clock');
<ide> });
<ide>
<del>test("calendar next week", function (assert) {
<add>test('calendar next week', function (assert) {
<ide> var i, m;
<ide> for (i = 2; i < 7; i++) {
<ide> m = moment().add({d: i});
<ide> test("calendar next week", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("calendar last week", function (assert) {
<add>test('calendar last week', function (assert) {
<ide> var i, m;
<ide>
<ide> function makeFormat(d) {
<ide> test("calendar last week", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("calendar all else", function (assert) {
<add>test('calendar all else', function (assert) {
<ide> var weeksAgo = moment().subtract({w: 1}),
<ide> weeksFromNow = moment().add({w: 1});
<ide>
<ide> test("calendar all else", function (assert) {
<ide> assert.equal(weeksFromNow.calendar(), weeksFromNow.format('L'), 'in 2 weeks');
<ide> });
<ide>
<del>test("weeks year starting sunday", function (assert) {
<add>test('weeks year starting sunday', function (assert) {
<ide> assert.equal(moment([2011, 11, 26]).week(), 1, 'Dec 26 2011 should be week 1');
<ide> assert.equal(moment([2012, 0, 1]).week(), 1, 'Jan 1 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 2]).week(), 2, 'Jan 2 2012 should be week 2');
<ide> assert.equal(moment([2012, 0, 8]).week(), 2, 'Jan 8 2012 should be week 2');
<ide> assert.equal(moment([2012, 0, 9]).week(), 3, 'Jan 9 2012 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting monday", function (assert) {
<add>test('weeks year starting monday', function (assert) {
<ide> assert.equal(moment([2007, 0, 1]).week(), 1, 'Jan 1 2007 should be week 1');
<ide> assert.equal(moment([2007, 0, 7]).week(), 1, 'Jan 7 2007 should be week 1');
<ide> assert.equal(moment([2007, 0, 8]).week(), 2, 'Jan 8 2007 should be week 2');
<ide> assert.equal(moment([2007, 0, 14]).week(), 2, 'Jan 14 2007 should be week 2');
<ide> assert.equal(moment([2007, 0, 15]).week(), 3, 'Jan 15 2007 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting tuesday", function (assert) {
<add>test('weeks year starting tuesday', function (assert) {
<ide> assert.equal(moment([2007, 11, 31]).week(), 1, 'Dec 31 2007 should be week 1');
<ide> assert.equal(moment([2008, 0, 1]).week(), 1, 'Jan 1 2008 should be week 1');
<ide> assert.equal(moment([2008, 0, 6]).week(), 1, 'Jan 6 2008 should be week 1');
<ide> test("weeks year starting tuesday", function (assert) {
<ide> assert.equal(moment([2008, 0, 14]).week(), 3, 'Jan 14 2008 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting wednesday", function (assert) {
<add>test('weeks year starting wednesday', function (assert) {
<ide> assert.equal(moment([2002, 11, 30]).week(), 1, 'Dec 30 2002 should be week 1');
<ide> assert.equal(moment([2003, 0, 1]).week(), 1, 'Jan 1 2003 should be week 1');
<ide> assert.equal(moment([2003, 0, 5]).week(), 1, 'Jan 5 2003 should be week 1');
<ide> test("weeks year starting wednesday", function (assert) {
<ide> assert.equal(moment([2003, 0, 13]).week(), 3, 'Jan 13 2003 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting thursday", function (assert) {
<add>test('weeks year starting thursday', function (assert) {
<ide> assert.equal(moment([2008, 11, 29]).week(), 1, 'Dec 29 2008 should be week 1');
<ide> assert.equal(moment([2009, 0, 1]).week(), 1, 'Jan 1 2009 should be week 1');
<ide> assert.equal(moment([2009, 0, 4]).week(), 1, 'Jan 4 2009 should be week 1');
<ide> test("weeks year starting thursday", function (assert) {
<ide> assert.equal(moment([2009, 0, 12]).week(), 3, 'Jan 12 2009 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting friday", function (assert) {
<add>test('weeks year starting friday', function (assert) {
<ide> assert.equal(moment([2009, 11, 28]).week(), 1, 'Dec 28 2009 should be week 1');
<ide> assert.equal(moment([2010, 0, 1]).week(), 1, 'Jan 1 2010 should be week 1');
<ide> assert.equal(moment([2010, 0, 3]).week(), 1, 'Jan 3 2010 should be week 1');
<ide> test("weeks year starting friday", function (assert) {
<ide> assert.equal(moment([2010, 0, 11]).week(), 3, 'Jan 11 2010 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting saturday", function (assert) {
<add>test('weeks year starting saturday', function (assert) {
<ide> assert.equal(moment([2010, 11, 27]).week(), 1, 'Dec 27 2010 should be week 1');
<ide> assert.equal(moment([2011, 0, 1]).week(), 1, 'Jan 1 2011 should be week 1');
<ide> assert.equal(moment([2011, 0, 2]).week(), 1, 'Jan 2 2011 should be week 1');
<ide> test("weeks year starting saturday", function (assert) {
<ide> assert.equal(moment([2011, 0, 10]).week(), 3, 'Jan 10 2011 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting sunday formatted", function (assert) {
<add>test('weeks year starting sunday formatted', function (assert) {
<ide> assert.equal(moment([2011, 11, 26]).format('w ww wo'), '1 01 1-й', 'Dec 26 2011 should be week 1');
<ide> assert.equal(moment([2012, 0, 1]).format('w ww wo'), '1 01 1-й', 'Jan 1 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 2]).format('w ww wo'), '2 02 2-й', 'Jan 2 2012 should be week 2');
<ide> assert.equal(moment([2012, 0, 8]).format('w ww wo'), '2 02 2-й', 'Jan 8 2012 should be week 2');
<ide> assert.equal(moment([2012, 0, 9]).format('w ww wo'), '3 03 3-й', 'Jan 9 2012 should be week 3');
<ide> });
<ide>
<del>test("lenient ordinal parsing", function (assert) {
<add>test('lenient ordinal parsing', function (assert) {
<ide> var i, ordinalStr, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> ordinalStr = moment([2014, 0, i]).format('YYYY MM Do');
<ide> test("lenient ordinal parsing", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("lenient ordinal parsing of number", function (assert) {
<add>test('lenient ordinal parsing of number', function (assert) {
<ide> var i, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> testMoment = moment('2014 01 ' + i, 'YYYY MM Do');
<ide> test("lenient ordinal parsing of number", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("strict ordinal parsing", function (assert) {
<add>test('strict ordinal parsing', function (assert) {
<ide> var i, ordinalStr, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> ordinalStr = moment([2014, 0, i]).format('YYYY MM Do');
<ide><path>src/test/locale/uz.js
<del>import {localeModule, test} from "../qunit";
<del>import {moment} from "../../moment";
<del>localeModule("uz");
<add>import {localeModule, test} from '../qunit';
<add>import {moment} from '../../moment';
<add>localeModule('uz');
<ide>
<del>test("parse", function (assert) {
<add>test('parse', function (assert) {
<ide> var tests = 'январь янв_февраль фев_март мар_апрель апр_май май_июнь июнь_июль июль_август авг_сентябрь сен_октябрь окт_ноябрь ноя_декабрь дек'.split('_'), i;
<ide> function equalTest(input, mmm, i) {
<ide> assert.equal(moment(input, mmm).month(), i, input + ' should be month ' + (i + 1));
<ide> test("parse", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("format", function (assert) {
<add>test('format', function (assert) {
<ide> var a = [
<ide> ['dddd, Do-MMMM YYYY, h:mm:ss', 'Якшанба, 14-февраль 2010, 3:25:50'],
<ide> ['ddd, h:mm', 'Якш, 3:25'],
<ide> test("format", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("format ordinal", function (assert) {
<add>test('format ordinal', function (assert) {
<ide> assert.equal(moment([2011, 0, 1]).format('DDDo'), '1', '1');
<ide> assert.equal(moment([2011, 0, 2]).format('DDDo'), '2', '2');
<ide> assert.equal(moment([2011, 0, 3]).format('DDDo'), '3', '3');
<ide> test("format ordinal", function (assert) {
<ide> assert.equal(moment([2011, 0, 31]).format('DDDo'), '31', '31');
<ide> });
<ide>
<del>test("format month", function (assert) {
<add>test('format month', function (assert) {
<ide> var expected = 'январь янв_февраль фев_март мар_апрель апр_май май_июнь июн_июль июл_август авг_сентябрь сен_октябрь окт_ноябрь ноя_декабрь дек'.split('_'), i;
<ide> for (i = 0; i < expected.length; i++) {
<ide> assert.equal(moment([2011, i, 1]).format('MMMM MMM'), expected[i], expected[i]);
<ide> }
<ide> });
<ide>
<del>test("format week", function (assert) {
<add>test('format week', function (assert) {
<ide> var expected = 'Якшанба Якш Як_Душанба Душ Ду_Сешанба Сеш Се_Чоршанба Чор Чо_Пайшанба Пай Па_Жума Жум Жу_Шанба Шан Ша'.split('_'), i;
<ide> for (i = 0; i < expected.length; i++) {
<ide> assert.equal(moment([2011, 0, 2 + i]).format('dddd ddd dd'), expected[i], expected[i]);
<ide> }
<ide> });
<ide>
<del>test("from", function (assert) {
<add>test('from', function (assert) {
<ide> var start = moment([2007, 1, 28]);
<ide> assert.equal(start.from(moment([2007, 1, 28]).add({s: 44}), true), 'фурсат', '44 секунд = фурсат');
<ide> assert.equal(start.from(moment([2007, 1, 28]).add({s: 45}), true), 'бир дакика', '45 секунд = бир дакика');
<ide> test("from", function (assert) {
<ide> assert.equal(start.from(moment([2007, 1, 28]).add({y: 5}), true), '5 йил', '5 йил = 5 йил');
<ide> });
<ide>
<del>test("suffix", function (assert) {
<add>test('suffix', function (assert) {
<ide> assert.equal(moment(30000).from(0), 'Якин фурсат ичида', 'prefix');
<ide> assert.equal(moment(0).from(30000), 'Бир неча фурсат олдин', 'suffix');
<ide> });
<ide>
<del>test("now from now", function (assert) {
<add>test('now from now', function (assert) {
<ide> assert.equal(moment().fromNow(), 'Бир неча фурсат олдин', 'now from now should display as in the past');
<ide> });
<ide>
<del>test("fromNow", function (assert) {
<add>test('fromNow', function (assert) {
<ide> assert.equal(moment().add({s: 30}).fromNow(), 'Якин фурсат ичида', 'in a few seconds');
<ide> assert.equal(moment().add({d: 5}).fromNow(), 'Якин 5 кун ичида', 'in 5 days');
<ide> });
<ide>
<del>test("calendar day", function (assert) {
<add>test('calendar day', function (assert) {
<ide> var a = moment().hours(2).minutes(0).seconds(0);
<ide>
<ide> assert.equal(moment(a).calendar(), 'Бугун соат 02:00 да', 'today at the same time');
<ide> test("calendar day", function (assert) {
<ide> assert.equal(moment(a).subtract({d: 1}).calendar(), 'Кеча соат 02:00 да', 'yesterday at the same time');
<ide> });
<ide>
<del>test("calendar next week", function (assert) {
<add>test('calendar next week', function (assert) {
<ide> var i, m;
<ide> for (i = 2; i < 7; i++) {
<ide> m = moment().add({d: i});
<ide> test("calendar next week", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("calendar last week", function (assert) {
<add>test('calendar last week', function (assert) {
<ide> var i, m;
<ide>
<ide> for (i = 2; i < 7; i++) {
<ide> test("calendar last week", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("calendar all else", function (assert) {
<add>test('calendar all else', function (assert) {
<ide> var weeksAgo = moment().subtract({w: 1}),
<ide> weeksFromNow = moment().add({w: 1});
<ide>
<ide> test("calendar all else", function (assert) {
<ide> assert.equal(weeksFromNow.calendar(), weeksFromNow.format('L'), 'in 2 weeks');
<ide> });
<ide>
<del>test("weeks year starting sunday", function (assert) {
<add>test('weeks year starting sunday', function (assert) {
<ide> assert.equal(moment([2012, 0, 1]).week(), 1, 'Jan 1 2012 should be week 52');
<ide> assert.equal(moment([2012, 0, 2]).week(), 2, 'Jan 2 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 8]).week(), 2, 'Jan 8 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 9]).week(), 3, 'Jan 9 2012 should be week 2');
<ide> assert.equal(moment([2012, 0, 15]).week(), 3, 'Jan 15 2012 should be week 2');
<ide> });
<ide>
<del>test("weeks year starting monday", function (assert) {
<add>test('weeks year starting monday', function (assert) {
<ide> assert.equal(moment([2007, 0, 1]).week(), 1, 'Jan 1 2007 should be week 1');
<ide> assert.equal(moment([2007, 0, 7]).week(), 1, 'Jan 7 2007 should be week 1');
<ide> assert.equal(moment([2007, 0, 8]).week(), 2, 'Jan 8 2007 should be week 2');
<ide> assert.equal(moment([2007, 0, 14]).week(), 2, 'Jan 14 2007 should be week 2');
<ide> assert.equal(moment([2007, 0, 15]).week(), 3, 'Jan 15 2007 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting tuesday", function (assert) {
<add>test('weeks year starting tuesday', function (assert) {
<ide> assert.equal(moment([2007, 11, 31]).week(), 1, 'Dec 31 2007 should be week 1');
<ide> assert.equal(moment([2008, 0, 1]).week(), 1, 'Jan 1 2008 should be week 1');
<ide> assert.equal(moment([2008, 0, 6]).week(), 1, 'Jan 6 2008 should be week 1');
<ide> test("weeks year starting tuesday", function (assert) {
<ide> assert.equal(moment([2008, 0, 14]).week(), 3, 'Jan 14 2008 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting wednesday", function (assert) {
<add>test('weeks year starting wednesday', function (assert) {
<ide> assert.equal(moment([2002, 11, 30]).week(), 1, 'Dec 30 2002 should be week 1');
<ide> assert.equal(moment([2003, 0, 1]).week(), 1, 'Jan 1 2003 should be week 1');
<ide> assert.equal(moment([2003, 0, 5]).week(), 1, 'Jan 5 2003 should be week 1');
<ide> test("weeks year starting wednesday", function (assert) {
<ide> assert.equal(moment([2003, 0, 13]).week(), 3, 'Jan 13 2003 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting thursday", function (assert) {
<add>test('weeks year starting thursday', function (assert) {
<ide> assert.equal(moment([2008, 11, 29]).week(), 1, 'Dec 29 2008 should be week 1');
<ide> assert.equal(moment([2009, 0, 1]).week(), 1, 'Jan 1 2009 should be week 1');
<ide> assert.equal(moment([2009, 0, 4]).week(), 1, 'Jan 4 2009 should be week 1');
<ide> test("weeks year starting thursday", function (assert) {
<ide> assert.equal(moment([2009, 0, 13]).week(), 3, 'Jan 12 2009 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting friday", function (assert) {
<add>test('weeks year starting friday', function (assert) {
<ide> assert.equal(moment([2009, 11, 28]).week(), 1, 'Dec 28 2009 should be week 53');
<ide> assert.equal(moment([2010, 0, 1]).week(), 1, 'Jan 1 2010 should be week 53');
<ide> assert.equal(moment([2010, 0, 3]).week(), 1, 'Jan 3 2010 should be week 53');
<ide> test("weeks year starting friday", function (assert) {
<ide> assert.equal(moment([2010, 0, 11]).week(), 3, 'Jan 11 2010 should be week 2');
<ide> });
<ide>
<del>test("weeks year starting saturday", function (assert) {
<add>test('weeks year starting saturday', function (assert) {
<ide> assert.equal(moment([2010, 11, 27]).week(), 1, 'Dec 27 2010 should be week 52');
<ide> assert.equal(moment([2011, 0, 1]).week(), 1, 'Jan 1 2011 should be week 52');
<ide> assert.equal(moment([2011, 0, 2]).week(), 1, 'Jan 2 2011 should be week 52');
<ide> test("weeks year starting saturday", function (assert) {
<ide> assert.equal(moment([2011, 0, 10]).week(), 3, 'Jan 10 2011 should be week 2');
<ide> });
<ide>
<del>test("weeks year starting sunday formatted", function (assert) {
<add>test('weeks year starting sunday formatted', function (assert) {
<ide> assert.equal(moment([2012, 0, 1]).format('w ww wo'), '1 01 1', 'Jan 1 2012 should be week 52');
<ide> assert.equal(moment([2012, 0, 2]).format('w ww wo'), '2 02 2', 'Jan 2 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 8]).format('w ww wo'), '2 02 2', 'Jan 8 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 9]).format('w ww wo'), '3 03 3', 'Jan 9 2012 should be week 2');
<ide> assert.equal(moment([2012, 0, 15]).format('w ww wo'), '3 03 3', 'Jan 15 2012 should be week 2');
<ide> });
<ide>
<del>test("lenient ordinal parsing", function (assert) {
<add>test('lenient ordinal parsing', function (assert) {
<ide> var i, ordinalStr, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> ordinalStr = moment([2014, 0, i]).format('YYYY MM Do');
<ide> test("lenient ordinal parsing", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("lenient ordinal parsing of number", function (assert) {
<add>test('lenient ordinal parsing of number', function (assert) {
<ide> var i, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> testMoment = moment('2014 01 ' + i, 'YYYY MM Do');
<ide> test("lenient ordinal parsing of number", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("strict ordinal parsing", function (assert) {
<add>test('strict ordinal parsing', function (assert) {
<ide> var i, ordinalStr, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> ordinalStr = moment([2014, 0, i]).format('YYYY MM Do');
<ide><path>src/test/locale/vi.js
<del>import {localeModule, test} from "../qunit";
<del>import {moment} from "../../moment";
<del>localeModule("vi");
<add>import {localeModule, test} from '../qunit';
<add>import {moment} from '../../moment';
<add>localeModule('vi');
<ide>
<del>test("parse", function (assert) {
<add>test('parse', function (assert) {
<ide> var i,
<ide> tests = 'tháng 1,Th01_tháng 2,Th02_tháng 3,Th03_tháng 4,Th04_tháng 5,Th05_tháng 6,Th06_tháng 7,Th07_tháng 8,Th08_tháng 9,Th09_tháng 10,Th10_tháng 11,Th11_tháng 12,Th12'.split('_');
<ide>
<ide> test("parse", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("format", function (assert) {
<add>test('format', function (assert) {
<ide> var a = [
<ide> ['dddd, MMMM Do YYYY, h:mm:ss a', 'chủ nhật, tháng 2 14 2010, 3:25:50 pm'],
<ide> ['ddd, hA', 'CN, 3PM'],
<ide> test("format", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("format ordinal", function (assert) {
<add>test('format ordinal', function (assert) {
<ide> assert.equal(moment([2011, 0, 1]).format('DDDo'), '1', '1');
<ide> assert.equal(moment([2011, 0, 2]).format('DDDo'), '2', '2');
<ide> assert.equal(moment([2011, 0, 3]).format('DDDo'), '3', '3');
<ide> test("format ordinal", function (assert) {
<ide> assert.equal(moment([2011, 0, 31]).format('DDDo'), '31', '31');
<ide> });
<ide>
<del>test("format month", function (assert) {
<add>test('format month', function (assert) {
<ide> var i,
<ide> expected = 'tháng 1,Th01_tháng 2,Th02_tháng 3,Th03_tháng 4,Th04_tháng 5,Th05_tháng 6,Th06_tháng 7,Th07_tháng 8,Th08_tháng 9,Th09_tháng 10,Th10_tháng 11,Th11_tháng 12,Th12'.split('_');
<ide>
<ide> test("format month", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("format week", function (assert) {
<add>test('format week', function (assert) {
<ide> var i,
<ide> expected = 'chủ nhật CN CN_thứ hai T2 T2_thứ ba T3 T3_thứ tư T4 T4_thứ năm T5 T5_thứ sáu T6 T6_thứ bảy T7 T7'.split('_');
<ide>
<ide> test("format week", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("from", function (assert) {
<add>test('from', function (assert) {
<ide> var start = moment([2007, 1, 28]);
<ide>
<ide> assert.equal(start.from(moment([2007, 1, 28]).add({s: 44}), true), 'vài giây', '44 seconds = a few seconds');
<ide> test("from", function (assert) {
<ide> assert.equal(start.from(moment([2007, 1, 28]).add({y: 5}), true), '5 năm', '5 years = 5 years');
<ide> });
<ide>
<del>test("suffix", function (assert) {
<add>test('suffix', function (assert) {
<ide> assert.equal(moment(30000).from(0), 'vài giây tới', 'prefix');
<ide> assert.equal(moment(0).from(30000), 'vài giây trước', 'suffix');
<ide> });
<ide>
<del>test("now from now", function (assert) {
<add>test('now from now', function (assert) {
<ide> assert.equal(moment().fromNow(), 'vài giây trước', 'now from now should display as in the past');
<ide> });
<ide>
<del>test("fromNow", function (assert) {
<add>test('fromNow', function (assert) {
<ide> assert.equal(moment().add({s: 30}).fromNow(), 'vài giây tới', 'in a few seconds');
<ide> assert.equal(moment().add({d: 5}).fromNow(), '5 ngày tới', 'in 5 days');
<ide> });
<ide>
<del>test("calendar day", function (assert) {
<add>test('calendar day', function (assert) {
<ide> var a = moment().hours(2).minutes(0).seconds(0);
<ide>
<ide> assert.equal(moment(a).calendar(), 'Hôm nay lúc 02:00', 'today at the same time');
<ide> test("calendar day", function (assert) {
<ide> assert.equal(moment(a).subtract({d: 1}).calendar(), 'Hôm qua lúc 02:00', 'yesterday at the same time');
<ide> });
<ide>
<del>test("calendar next week", function (assert) {
<add>test('calendar next week', function (assert) {
<ide> var i, m;
<ide>
<ide> for (i = 2; i < 7; i++) {
<ide> test("calendar next week", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("calendar last week", function (assert) {
<add>test('calendar last week', function (assert) {
<ide> var i, m;
<ide>
<ide> for (i = 2; i < 7; i++) {
<ide> test("calendar last week", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("calendar all else", function (assert) {
<add>test('calendar all else', function (assert) {
<ide> var weeksAgo = moment().subtract({w: 1}),
<ide> weeksFromNow = moment().add({w: 1});
<ide>
<ide> test("calendar all else", function (assert) {
<ide> assert.equal(weeksFromNow.calendar(), weeksFromNow.format('L'), 'in 2 weeks');
<ide> });
<ide>
<del>test("weeks year starting sunday", function (assert) {
<add>test('weeks year starting sunday', function (assert) {
<ide> assert.equal(moment([2012, 0, 1]).week(), 52, 'Jan 1 2012 should be week 52');
<ide> assert.equal(moment([2012, 0, 2]).week(), 1, 'Jan 2 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 8]).week(), 1, 'Jan 8 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 9]).week(), 2, 'Jan 9 2012 should be week 2');
<ide> assert.equal(moment([2012, 0, 15]).week(), 2, 'Jan 15 2012 should be week 2');
<ide> });
<ide>
<del>test("weeks year starting monday", function (assert) {
<add>test('weeks year starting monday', function (assert) {
<ide> assert.equal(moment([2007, 0, 1]).week(), 1, 'Jan 1 2007 should be week 1');
<ide> assert.equal(moment([2007, 0, 7]).week(), 1, 'Jan 7 2007 should be week 1');
<ide> assert.equal(moment([2007, 0, 8]).week(), 2, 'Jan 8 2007 should be week 2');
<ide> assert.equal(moment([2007, 0, 14]).week(), 2, 'Jan 14 2007 should be week 2');
<ide> assert.equal(moment([2007, 0, 15]).week(), 3, 'Jan 15 2007 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting tuesday", function (assert) {
<add>test('weeks year starting tuesday', function (assert) {
<ide> assert.equal(moment([2007, 11, 31]).week(), 1, 'Dec 31 2007 should be week 1');
<ide> assert.equal(moment([2008, 0, 1]).week(), 1, 'Jan 1 2008 should be week 1');
<ide> assert.equal(moment([2008, 0, 6]).week(), 1, 'Jan 6 2008 should be week 1');
<ide> test("weeks year starting tuesday", function (assert) {
<ide> assert.equal(moment([2008, 0, 14]).week(), 3, 'Jan 14 2008 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting wednesday", function (assert) {
<add>test('weeks year starting wednesday', function (assert) {
<ide> assert.equal(moment([2002, 11, 30]).week(), 1, 'Dec 30 2002 should be week 1');
<ide> assert.equal(moment([2003, 0, 1]).week(), 1, 'Jan 1 2003 should be week 1');
<ide> assert.equal(moment([2003, 0, 5]).week(), 1, 'Jan 5 2003 should be week 1');
<ide> test("weeks year starting wednesday", function (assert) {
<ide> assert.equal(moment([2003, 0, 13]).week(), 3, 'Jan 13 2003 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting thursday", function (assert) {
<add>test('weeks year starting thursday', function (assert) {
<ide> assert.equal(moment([2008, 11, 29]).week(), 1, 'Dec 29 2008 should be week 1');
<ide> assert.equal(moment([2009, 0, 1]).week(), 1, 'Jan 1 2009 should be week 1');
<ide> assert.equal(moment([2009, 0, 4]).week(), 1, 'Jan 4 2009 should be week 1');
<ide> test("weeks year starting thursday", function (assert) {
<ide> assert.equal(moment([2009, 0, 13]).week(), 3, 'Jan 12 2009 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting friday", function (assert) {
<add>test('weeks year starting friday', function (assert) {
<ide> assert.equal(moment([2009, 11, 28]).week(), 53, 'Dec 28 2009 should be week 53');
<ide> assert.equal(moment([2010, 0, 1]).week(), 53, 'Jan 1 2010 should be week 53');
<ide> assert.equal(moment([2010, 0, 3]).week(), 53, 'Jan 3 2010 should be week 53');
<ide> test("weeks year starting friday", function (assert) {
<ide> assert.equal(moment([2010, 0, 11]).week(), 2, 'Jan 11 2010 should be week 2');
<ide> });
<ide>
<del>test("weeks year starting saturday", function (assert) {
<add>test('weeks year starting saturday', function (assert) {
<ide> assert.equal(moment([2010, 11, 27]).week(), 52, 'Dec 27 2010 should be week 52');
<ide> assert.equal(moment([2011, 0, 1]).week(), 52, 'Jan 1 2011 should be week 52');
<ide> assert.equal(moment([2011, 0, 2]).week(), 52, 'Jan 2 2011 should be week 52');
<ide> test("weeks year starting saturday", function (assert) {
<ide> assert.equal(moment([2011, 0, 10]).week(), 2, 'Jan 10 2011 should be week 2');
<ide> });
<ide>
<del>test("weeks year starting sunday formatted", function (assert) {
<add>test('weeks year starting sunday formatted', function (assert) {
<ide> assert.equal(moment([2012, 0, 1]).format('w ww wo'), '52 52 52', 'Jan 1 2012 should be week 52');
<ide> assert.equal(moment([2012, 0, 2]).format('w ww wo'), '1 01 1', 'Jan 2 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 8]).format('w ww wo'), '1 01 1', 'Jan 8 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 9]).format('w ww wo'), '2 02 2', 'Jan 9 2012 should be week 2');
<ide> assert.equal(moment([2012, 0, 15]).format('w ww wo'), '2 02 2', 'Jan 15 2012 should be week 2');
<ide> });
<ide>
<del>test("lenient ordinal parsing", function (assert) {
<add>test('lenient ordinal parsing', function (assert) {
<ide> var i, ordinalStr, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> ordinalStr = moment([2014, 0, i]).format('YYYY MM Do');
<ide> test("lenient ordinal parsing", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("lenient ordinal parsing of number", function (assert) {
<add>test('lenient ordinal parsing of number', function (assert) {
<ide> var i, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> testMoment = moment('2014 01 ' + i, 'YYYY MM Do');
<ide> test("lenient ordinal parsing of number", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("strict ordinal parsing", function (assert) {
<add>test('strict ordinal parsing', function (assert) {
<ide> var i, ordinalStr, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> ordinalStr = moment([2014, 0, i]).format('YYYY MM Do');
<ide><path>src/test/locale/zh-cn.js
<del>import {localeModule, test} from "../qunit";
<del>import {moment} from "../../moment";
<del>localeModule("zh-cn");
<add>import {localeModule, test} from '../qunit';
<add>import {moment} from '../../moment';
<add>localeModule('zh-cn');
<ide>
<del>test("parse", function (assert) {
<add>test('parse', function (assert) {
<ide> var tests = '一月 1月_二月 2月_三月 3月_四月 4月_五月 5月_六月 6月_七月 7月_八月 8月_九月 9月_十月 10月_十一月 11月_十二月 12月'.split('_'), i;
<ide>
<ide> function equalTest(input, mmm, i) {
<ide> test("parse", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("format", function (assert) {
<add>test('format', function (assert) {
<ide> var a = [
<ide> ['dddd, MMMM Do YYYY, a h:mm:ss', '星期日, 二月 14日 2010, 下午 3:25:50'],
<ide> ['ddd, Ah', '周日, 下午3'],
<ide> test("format", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("format month", function (assert) {
<add>test('format month', function (assert) {
<ide> var expected = '一月 1月_二月 2月_三月 3月_四月 4月_五月 5月_六月 6月_七月 7月_八月 8月_九月 9月_十月 10月_十一月 11月_十二月 12月'.split('_'), i;
<ide>
<ide> for (i = 0; i < expected.length; i++) {
<ide> assert.equal(moment([2011, i, 1]).format('MMMM MMM'), expected[i], expected[i]);
<ide> }
<ide> });
<ide>
<del>test("format week", function (assert) {
<add>test('format week', function (assert) {
<ide> var expected = '星期日 周日 日_星期一 周一 一_星期二 周二 二_星期三 周三 三_星期四 周四 四_星期五 周五 五_星期六 周六 六'.split('_'), i;
<ide>
<ide> for (i = 0; i < expected.length; i++) {
<ide> assert.equal(moment([2011, 0, 2 + i]).format('dddd ddd dd'), expected[i], expected[i]);
<ide> }
<ide> });
<ide>
<del>test("from", function (assert) {
<add>test('from', function (assert) {
<ide> var start = moment([2007, 1, 28]);
<ide> assert.equal(start.from(moment([2007, 1, 28]).add({s: 44}), true), '几秒', '44 seconds = a few seconds');
<ide> assert.equal(start.from(moment([2007, 1, 28]).add({s: 45}), true), '1分钟', '45 seconds = a minute');
<ide> test("from", function (assert) {
<ide> assert.equal(start.from(moment([2007, 1, 28]).add({y: 5}), true), '5年', '5 years = 5 years');
<ide> });
<ide>
<del>test("suffix", function (assert) {
<add>test('suffix', function (assert) {
<ide> assert.equal(moment(30000).from(0), '几秒内', 'prefix');
<ide> assert.equal(moment(0).from(30000), '几秒前', 'suffix');
<ide> });
<ide>
<del>test("now from now", function (assert) {
<add>test('now from now', function (assert) {
<ide> assert.equal(moment().fromNow(), '几秒前', 'now from now should display as in the past');
<ide> });
<ide>
<del>test("fromNow", function (assert) {
<add>test('fromNow', function (assert) {
<ide> assert.equal(moment().add({s: 30}).fromNow(), '几秒内', 'in a few seconds');
<ide> assert.equal(moment().add({d: 5}).fromNow(), '5天内', 'in 5 days');
<ide> });
<ide>
<del>test("calendar day", function (assert) {
<add>test('calendar day', function (assert) {
<ide> var a = moment().hours(2).minutes(0).seconds(0);
<ide>
<ide> assert.equal(moment(a).calendar(), '今天凌晨2点整', 'today at the same time');
<ide> test("calendar day", function (assert) {
<ide> assert.equal(moment(a).subtract({d: 1}).calendar(), '昨天凌晨2点整', 'yesterday at the same time');
<ide> });
<ide>
<del>test("calendar current week", function (assert) {
<add>test('calendar current week', function (assert) {
<ide> var i, m,
<ide> today = moment().startOf('day');
<ide>
<ide> test("calendar current week", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("calendar next week", function (assert) {
<add>test('calendar next week', function (assert) {
<ide> var i, m,
<ide> today = moment().startOf('day');
<ide>
<ide> test("calendar next week", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("calendar last week", function (assert) {
<add>test('calendar last week', function (assert) {
<ide> var i, m,
<ide> today = moment().startOf('day');
<ide>
<ide> test("calendar last week", function (assert) {
<ide> assert.equal(42, 42);
<ide> });
<ide>
<del>test("calendar all else", function (assert) {
<add>test('calendar all else', function (assert) {
<ide> var weeksAgo = moment().subtract({w: 1}),
<ide> weeksFromNow = moment().add({w: 1});
<ide>
<ide> test("calendar all else", function (assert) {
<ide> assert.equal(weeksFromNow.calendar(), weeksFromNow.format('LL'), 'in 2 weeks');
<ide> });
<ide>
<del>test("meridiem", function (assert) {
<add>test('meridiem', function (assert) {
<ide> assert.equal(moment([2011, 2, 23, 0, 0]).format('A'), '凌晨', 'before dawn');
<ide> assert.equal(moment([2011, 2, 23, 6, 0]).format('A'), '早上', 'morning');
<ide> assert.equal(moment([2011, 2, 23, 9, 0]).format('A'), '上午', 'before noon');
<ide> test("meridiem", function (assert) {
<ide> assert.equal(moment([2011, 2, 23, 18, 0]).format('A'), '晚上', 'night');
<ide> });
<ide>
<del>test("weeks year starting sunday", function (assert) {
<add>test('weeks year starting sunday', function (assert) {
<ide> assert.equal(moment([2012, 0, 1]).week(), 52, 'Jan 1 2012 should be week 52');
<ide> assert.equal(moment([2012, 0, 2]).week(), 1, 'Jan 2 2012 should be week 52');
<ide> assert.equal(moment([2012, 0, 7]).week(), 1, 'Jan 7 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 14]).week(), 2, 'Jan 14 2012 should be week 2');
<ide> });
<ide>
<del>test("weeks year starting monday", function (assert) {
<add>test('weeks year starting monday', function (assert) {
<ide> assert.equal(moment([2006, 11, 31]).week(), 52, 'Dec 31 2006 should be week 52');
<ide> assert.equal(moment([2007, 0, 1]).week(), 1, 'Jan 1 2007 should be week 1');
<ide> assert.equal(moment([2007, 0, 6]).week(), 1, 'Jan 6 2007 should be week 1');
<ide> test("weeks year starting monday", function (assert) {
<ide> assert.equal(moment([2007, 0, 14]).week(), 2, 'Jan 14 2007 should be week 2');
<ide> });
<ide>
<del>test("weeks year starting tuesday", function (assert) {
<add>test('weeks year starting tuesday', function (assert) {
<ide> assert.equal(moment([2007, 11, 29]).week(), 52, 'Dec 29 2007 should be week 52');
<ide> assert.equal(moment([2008, 0, 1]).week(), 1, 'Jan 1 2008 should be week 1');
<ide> assert.equal(moment([2008, 0, 5]).week(), 1, 'Jan 5 2008 should be week 1');
<ide> test("weeks year starting tuesday", function (assert) {
<ide> assert.equal(moment([2008, 0, 13]).week(), 2, 'Jan 13 2008 should be week 2');
<ide> });
<ide>
<del>test("weeks year starting wednesday", function (assert) {
<add>test('weeks year starting wednesday', function (assert) {
<ide> assert.equal(moment([2002, 11, 29]).week(), 52, 'Dec 29 2002 should be week 52');
<ide> assert.equal(moment([2003, 0, 1]).week(), 1, 'Jan 1 2003 should be week 1');
<ide> assert.equal(moment([2003, 0, 4]).week(), 1, 'Jan 4 2003 should be week 1');
<ide> test("weeks year starting wednesday", function (assert) {
<ide> assert.equal(moment([2003, 0, 12]).week(), 2, 'Jan 12 2003 should be week 2');
<ide> });
<ide>
<del>test("weeks year starting thursday", function (assert) {
<add>test('weeks year starting thursday', function (assert) {
<ide> assert.equal(moment([2009, 0, 1]).week(), 1, 'Jan 1 2009 should be week 1');
<ide> assert.equal(moment([2009, 0, 3]).week(), 1, 'Jan 3 2009 should be week 1');
<ide> assert.equal(moment([2009, 0, 4]).week(), 1, 'Jan 4 2009 should be week 1');
<ide> assert.equal(moment([2009, 0, 10]).week(), 2, 'Jan 10 2009 should be week 2');
<ide> assert.equal(moment([2009, 0, 11]).week(), 2, 'Jan 11 2009 should be week 2');
<ide> });
<ide>
<del>test("weeks year starting friday", function (assert) {
<add>test('weeks year starting friday', function (assert) {
<ide> assert.equal(moment([2010, 0, 2]).week(), 53, 'Jan 2 2010 should be week 53');
<ide> assert.equal(moment([2010, 0, 10]).week(), 1, 'Jan 10 2010 should be week 1');
<ide> });
<ide>
<del>test("weeks year starting saturday", function (assert) {
<add>test('weeks year starting saturday', function (assert) {
<ide> assert.equal(moment([2011, 0, 2]).week(), 52, 'Jan 2 2011 should be week 52');
<ide> assert.equal(moment([2011, 0, 8]).week(), 1, 'Jan 8 2011 should be week 1');
<ide> assert.equal(moment([2011, 0, 9]).week(), 1, 'Jan 9 2011 should be week 1');
<ide> });
<ide>
<del>test("weeks year starting sunday format", function (assert) {
<add>test('weeks year starting sunday format', function (assert) {
<ide> assert.equal(moment([2012, 0, 1]).format('w ww wo'), '52 52 52周', 'Jan 1 2012 应该是第52周');
<ide> assert.equal(moment([2012, 0, 7]).format('w ww wo'), '1 01 1周', 'Jan 7 2012 应该是第 1周');
<ide> assert.equal(moment([2012, 0, 14]).format('w ww wo'), '2 02 2周', 'Jan 14 2012 应该是第 2周');
<ide> });
<ide>
<del>test("lenient ordinal parsing", function (assert) {
<add>test('lenient ordinal parsing', function (assert) {
<ide> var i, ordinalStr, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> ordinalStr = moment([2014, 0, i]).format('YYYY MM Do');
<ide> test("lenient ordinal parsing", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("lenient ordinal parsing of number", function (assert) {
<add>test('lenient ordinal parsing of number', function (assert) {
<ide> var i, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> testMoment = moment('2014 01 ' + i, 'YYYY MM Do');
<ide> test("lenient ordinal parsing of number", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("meridiem invariant", function (assert) {
<add>test('meridiem invariant', function (assert) {
<ide> var h, m, t1, t2;
<ide> for (h = 0; h < 24; ++h) {
<ide> for (m = 0; m < 60; m += 15) {
<ide> test("meridiem invariant", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("strict ordinal parsing", function (assert) {
<add>test('strict ordinal parsing', function (assert) {
<ide> var i, ordinalStr, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> ordinalStr = moment([2014, 0, i]).format('YYYY MM Do');
<ide><path>src/test/locale/zh-tw.js
<del>import {localeModule, test} from "../qunit";
<del>import {moment} from "../../moment";
<del>localeModule("zh-tw");
<add>import {localeModule, test} from '../qunit';
<add>import {moment} from '../../moment';
<add>localeModule('zh-tw');
<ide>
<del>test("parse", function (assert) {
<add>test('parse', function (assert) {
<ide> var tests = '一月 1月_二月 2月_三月 3月_四月 4月_五月 5月_六月 6月_七月 7月_八月 8月_九月 9月_十月 10月_十一月 11月_十二月 12月'.split('_'), i;
<ide> function equalTest(input, mmm, i) {
<ide> assert.equal(moment(input, mmm).month(), i, input + ' should be month ' + (i + 1));
<ide> test("parse", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("format", function (assert) {
<add>test('format', function (assert) {
<ide> var a = [
<ide> ['dddd, MMMM Do YYYY, a h:mm:ss', '星期日, 二月 14日 2010, 下午 3:25:50'],
<ide> ['ddd, Ah', '週日, 下午3'],
<ide> test("format", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("format month", function (assert) {
<add>test('format month', function (assert) {
<ide> var expected = '一月 1月_二月 2月_三月 3月_四月 4月_五月 5月_六月 6月_七月 7月_八月 8月_九月 9月_十月 10月_十一月 11月_十二月 12月'.split('_'), i;
<ide>
<ide> for (i = 0; i < expected.length; i++) {
<ide> assert.equal(moment([2011, i, 1]).format('MMMM MMM'), expected[i], expected[i]);
<ide> }
<ide> });
<ide>
<del>test("format week", function (assert) {
<add>test('format week', function (assert) {
<ide> var expected = '星期日 週日 日_星期一 週一 一_星期二 週二 二_星期三 週三 三_星期四 週四 四_星期五 週五 五_星期六 週六 六'.split('_'), i;
<ide>
<ide> for (i = 0; i < expected.length; i++) {
<ide> assert.equal(moment([2011, 0, 2 + i]).format('dddd ddd dd'), expected[i], expected[i]);
<ide> }
<ide> });
<ide>
<del>test("from", function (assert) {
<add>test('from', function (assert) {
<ide> var start = moment([2007, 1, 28]);
<ide> assert.equal(start.from(moment([2007, 1, 28]).add({s: 44}), true), '幾秒', '44 seconds = a few seconds');
<ide> assert.equal(start.from(moment([2007, 1, 28]).add({s: 45}), true), '一分鐘', '45 seconds = a minute');
<ide> test("from", function (assert) {
<ide> assert.equal(start.from(moment([2007, 1, 28]).add({y: 5}), true), '5年', '5 years = 5 years');
<ide> });
<ide>
<del>test("suffix", function (assert) {
<add>test('suffix', function (assert) {
<ide> assert.equal(moment(30000).from(0), '幾秒內', 'prefix');
<ide> assert.equal(moment(0).from(30000), '幾秒前', 'suffix');
<ide> });
<ide>
<del>test("now from now", function (assert) {
<add>test('now from now', function (assert) {
<ide> assert.equal(moment().fromNow(), '幾秒前', 'now from now should display as in the past');
<ide> });
<ide>
<del>test("fromNow", function (assert) {
<add>test('fromNow', function (assert) {
<ide> assert.equal(moment().add({s: 30}).fromNow(), '幾秒內', 'in a few seconds');
<ide> assert.equal(moment().add({d: 5}).fromNow(), '5天內', 'in 5 days');
<ide> });
<ide>
<del>test("calendar day", function (assert) {
<add>test('calendar day', function (assert) {
<ide> var a = moment().hours(2).minutes(0).seconds(0);
<ide>
<ide> assert.equal(moment(a).calendar(), '今天早上2點00', 'today at the same time');
<ide> test("calendar day", function (assert) {
<ide> assert.equal(moment(a).subtract({d: 1}).calendar(), '昨天早上2點00', 'yesterday at the same time');
<ide> });
<ide>
<del>test("calendar next week", function (assert) {
<add>test('calendar next week', function (assert) {
<ide> var i, m;
<ide> for (i = 2; i < 7; i++) {
<ide> m = moment().add({d: i});
<ide> test("calendar next week", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("calendar last week", function (assert) {
<add>test('calendar last week', function (assert) {
<ide> var i, m;
<ide> for (i = 2; i < 7; i++) {
<ide> m = moment().subtract({d: i});
<ide> test("calendar last week", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("calendar all else", function (assert) {
<add>test('calendar all else', function (assert) {
<ide> var weeksAgo = moment().subtract({w: 1}),
<ide> weeksFromNow = moment().add({w: 1});
<ide>
<ide> test("calendar all else", function (assert) {
<ide> assert.equal(weeksFromNow.calendar(), weeksFromNow.format('L'), 'in 2 weeks');
<ide> });
<ide>
<del>test("meridiem", function (assert) {
<add>test('meridiem', function (assert) {
<ide> assert.equal(moment([2011, 2, 23, 0, 0]).format('a'), '早上', 'morning');
<ide> assert.equal(moment([2011, 2, 23, 9, 0]).format('a'), '上午', 'before noon');
<ide> assert.equal(moment([2011, 2, 23, 12, 0]).format('a'), '中午', 'noon');
<ide> test("meridiem", function (assert) {
<ide> assert.equal(moment([2011, 2, 23, 18, 0]).format('A'), '晚上', 'night');
<ide> });
<ide>
<del>test("weeks year starting sunday", function (assert) {
<add>test('weeks year starting sunday', function (assert) {
<ide> assert.equal(moment([2012, 0, 1]).week(), 1, 'Jan 1 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 7]).week(), 1, 'Jan 7 2012 should be week 1');
<ide> assert.equal(moment([2012, 0, 8]).week(), 2, 'Jan 8 2012 should be week 2');
<ide> assert.equal(moment([2012, 0, 14]).week(), 2, 'Jan 14 2012 should be week 2');
<ide> assert.equal(moment([2012, 0, 15]).week(), 3, 'Jan 15 2012 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting monday", function (assert) {
<add>test('weeks year starting monday', function (assert) {
<ide> assert.equal(moment([2006, 11, 31]).week(), 1, 'Dec 31 2006 should be week 1');
<ide> assert.equal(moment([2007, 0, 1]).week(), 1, 'Jan 1 2007 should be week 1');
<ide> assert.equal(moment([2007, 0, 6]).week(), 1, 'Jan 6 2007 should be week 1');
<ide> test("weeks year starting monday", function (assert) {
<ide> assert.equal(moment([2007, 0, 14]).week(), 3, 'Jan 14 2007 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting tuesday", function (assert) {
<add>test('weeks year starting tuesday', function (assert) {
<ide> assert.equal(moment([2007, 11, 29]).week(), 52, 'Dec 29 2007 should be week 52');
<ide> assert.equal(moment([2008, 0, 1]).week(), 1, 'Jan 1 2008 should be week 1');
<ide> assert.equal(moment([2008, 0, 5]).week(), 1, 'Jan 5 2008 should be week 1');
<ide> test("weeks year starting tuesday", function (assert) {
<ide> assert.equal(moment([2008, 0, 13]).week(), 3, 'Jan 13 2008 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting wednesday", function (assert) {
<add>test('weeks year starting wednesday', function (assert) {
<ide> assert.equal(moment([2002, 11, 29]).week(), 1, 'Dec 29 2002 should be week 1');
<ide> assert.equal(moment([2003, 0, 1]).week(), 1, 'Jan 1 2003 should be week 1');
<ide> assert.equal(moment([2003, 0, 4]).week(), 1, 'Jan 4 2003 should be week 1');
<ide> test("weeks year starting wednesday", function (assert) {
<ide> assert.equal(moment([2003, 0, 12]).week(), 3, 'Jan 12 2003 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting thursday", function (assert) {
<add>test('weeks year starting thursday', function (assert) {
<ide> assert.equal(moment([2008, 11, 28]).week(), 1, 'Dec 28 2008 should be week 1');
<ide> assert.equal(moment([2009, 0, 1]).week(), 1, 'Jan 1 2009 should be week 1');
<ide> assert.equal(moment([2009, 0, 3]).week(), 1, 'Jan 3 2009 should be week 1');
<ide> test("weeks year starting thursday", function (assert) {
<ide> assert.equal(moment([2009, 0, 11]).week(), 3, 'Jan 11 2009 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting friday", function (assert) {
<add>test('weeks year starting friday', function (assert) {
<ide> assert.equal(moment([2009, 11, 27]).week(), 1, 'Dec 27 2009 should be week 1');
<ide> assert.equal(moment([2010, 0, 1]).week(), 1, 'Jan 1 2010 should be week 1');
<ide> assert.equal(moment([2010, 0, 2]).week(), 1, 'Jan 2 2010 should be week 1');
<ide> test("weeks year starting friday", function (assert) {
<ide> assert.equal(moment([2010, 0, 10]).week(), 3, 'Jan 10 2010 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting saturday", function (assert) {
<add>test('weeks year starting saturday', function (assert) {
<ide> assert.equal(moment([2010, 11, 26]).week(), 1, 'Dec 26 2010 should be week 1');
<ide> assert.equal(moment([2011, 0, 1]).week(), 1, 'Jan 1 2011 should be week 1');
<ide> assert.equal(moment([2011, 0, 2]).week(), 2, 'Jan 2 2011 should be week 2');
<ide> assert.equal(moment([2011, 0, 8]).week(), 2, 'Jan 8 2011 should be week 2');
<ide> assert.equal(moment([2011, 0, 9]).week(), 3, 'Jan 9 2011 should be week 3');
<ide> });
<ide>
<del>test("weeks year starting sunday format", function (assert) {
<add>test('weeks year starting sunday format', function (assert) {
<ide> assert.equal(moment([2012, 0, 1]).format('w ww wo'), '1 01 1週', 'Jan 1 2012 應該是第 1週');
<ide> assert.equal(moment([2012, 0, 7]).format('w ww wo'), '1 01 1週', 'Jan 7 2012 應該是第 1週');
<ide> assert.equal(moment([2012, 0, 8]).format('w ww wo'), '2 02 2週', 'Jan 8 2012 應該是第 2週');
<ide> assert.equal(moment([2012, 0, 14]).format('w ww wo'), '2 02 2週', 'Jan 14 2012 應該是第 2週');
<ide> assert.equal(moment([2012, 0, 15]).format('w ww wo'), '3 03 3週', 'Jan 15 2012 應該是第 3週');
<ide> });
<ide>
<del>test("lenient ordinal parsing", function (assert) {
<add>test('lenient ordinal parsing', function (assert) {
<ide> var i, ordinalStr, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> ordinalStr = moment([2014, 0, i]).format('YYYY MM Do');
<ide> test("lenient ordinal parsing", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("lenient ordinal parsing of number", function (assert) {
<add>test('lenient ordinal parsing of number', function (assert) {
<ide> var i, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> testMoment = moment('2014 01 ' + i, 'YYYY MM Do');
<ide> test("lenient ordinal parsing of number", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("meridiem invariant", function (assert) {
<add>test('meridiem invariant', function (assert) {
<ide> var h, m, t1, t2;
<ide> for (h = 0; h < 24; ++h) {
<ide> for (m = 0; m < 60; m += 15) {
<ide> test("meridiem invariant", function (assert) {
<ide> }
<ide> });
<ide>
<del>test("strict ordinal parsing", function (assert) {
<add>test('strict ordinal parsing', function (assert) {
<ide> var i, ordinalStr, testMoment;
<ide> for (i = 1; i <= 31; ++i) {
<ide> ordinalStr = moment([2014, 0, i]).format('YYYY MM Do');
<ide><path>src/test/moment/format.js
<ide> test('default format', function (assert) {
<ide> assert.ok(isoRegex.exec(moment().format()), 'default format (' + moment().format() + ') should match ISO');
<ide> });
<ide>
<del>test('escaping quotes', function (assert) {
<del> moment.locale('en');
<del> var date = moment([2012, 0]);
<del> assert.equal(date.format('MMM \'YY'), 'Jan \'12', 'Should be able to format with single parenthesis');
<del> assert.equal(date.format('MMM "YY'), 'Jan "12', 'Should be able to format with double parenthesis');
<del> assert.equal(date.format('MMM \'YY'), 'Jan \'12', 'Should be able to format with single parenthesis');
<del> assert.equal(date.format('MMM "YY'), 'Jan "12', 'Should be able to format with double parenthesis');
<del>});
<del>
<ide> test('toJSON', function (assert) {
<ide> var supportsJson = typeof JSON !== 'undefined' && JSON.stringify && JSON.stringify.call,
<ide> date = moment('2012-10-09T21:30:40.678+0100'); | 225 |
Java | Java | use computeifabsent in scriptfactorypostprocessor | 0f0b1ffe0d830cac89a2a0b104de6ed9fe10a858 | <ide><path>spring-context/src/main/java/org/springframework/scripting/support/ScriptFactoryPostProcessor.java
<ide>
<ide> package org.springframework.scripting.support;
<ide>
<del>import java.util.HashMap;
<ide> import java.util.Map;
<add>import java.util.concurrent.ConcurrentHashMap;
<ide>
<ide> import org.apache.commons.logging.Log;
<ide> import org.apache.commons.logging.LogFactory;
<ide> * @author Rob Harrop
<ide> * @author Rick Evans
<ide> * @author Mark Fisher
<add> * @author Sam Brannen
<ide> * @since 2.0
<ide> */
<ide> public class ScriptFactoryPostProcessor implements SmartInstantiationAwareBeanPostProcessor,
<ide> public class ScriptFactoryPostProcessor implements SmartInstantiationAwareBeanPo
<ide> final DefaultListableBeanFactory scriptBeanFactory = new DefaultListableBeanFactory();
<ide>
<ide> /** Map from bean name String to ScriptSource object. */
<del> private final Map<String, ScriptSource> scriptSourceCache = new HashMap<>();
<add> private final Map<String, ScriptSource> scriptSourceCache = new ConcurrentHashMap<>();
<ide>
<ide>
<ide> /**
<ide> protected BeanDefinition createScriptFactoryBeanDefinition(BeanDefinition bd) {
<ide> * @see #convertToScriptSource
<ide> */
<ide> protected ScriptSource getScriptSource(String beanName, String scriptSourceLocator) {
<del> synchronized (this.scriptSourceCache) {
<del> ScriptSource scriptSource = this.scriptSourceCache.get(beanName);
<del> if (scriptSource == null) {
<del> scriptSource = convertToScriptSource(beanName, scriptSourceLocator, this.resourceLoader);
<del> this.scriptSourceCache.put(beanName, scriptSource);
<del> }
<del> return scriptSource;
<del> }
<add> return this.scriptSourceCache.computeIfAbsent(beanName, key ->
<add> convertToScriptSource(beanName, scriptSourceLocator, this.resourceLoader));
<ide> }
<ide>
<ide> /** | 1 |
Python | Python | add comment to new test | 91e916cb67867db9ce835be28b31904e6efda832 | <ide><path>spacy/tests/regression/test_issue1727.py
<add>'''Test that models with no pretrained vectors can be deserialized correctly
<add>after vectors are added.'''
<ide> from __future__ import unicode_literals
<ide> import numpy
<ide> from ...pipeline import Tagger | 1 |
Text | Text | fix a typo in crypto.generatekeypairsync() | 53eb264cb16f5c1815d4ccfda585b462f9fac92a | <ide><path>doc/api/crypto.md
<ide> behaves as if [`keyObject.export()`][] had been called on its result. Otherwise,
<ide> the respective part of the key is returned as a [`KeyObject`][].
<ide>
<ide> When encoding public keys, it is recommended to use `'spki'`. When encoding
<del>private keys, it is recommended to use `'pks8'` with a strong passphrase, and to
<del>keep the passphrase confidential.
<add>private keys, it is recommended to use `'pkcs8'` with a strong passphrase,
<add>and to keep the passphrase confidential.
<ide>
<ide> ```js
<ide> const { generateKeyPairSync } = require('crypto'); | 1 |
Ruby | Ruby | reduce number of created objects in hash#to_json | 144df5b104d042792f3fa73576d3ca9fac74fa67 | <ide><path>activesupport/lib/active_support/json/encoding.rb
<ide> def jsonify(value)
<ide> when Numeric, NilClass, TrueClass, FalseClass
<ide> value.as_json
<ide> when Hash
<del> Hash[value.map { |k, v| [jsonify(k), jsonify(v)] }]
<add> result = {}
<add> value.each do |k, v|
<add> result[jsonify(k)] = jsonify(v)
<add> end
<add> result
<ide> when Array
<ide> value.map { |v| jsonify(v) }
<ide> else | 1 |
Go | Go | fix wrong cache hits building from tars | f6c8266afddcf24a2eb629af3b8e924e9c78ce73 | <ide><path>integration/build/build_test.go
<ide> RUN cat somefile`
<ide> assert.Contains(t, image.Config.Env, "bar=baz")
<ide> }
<ide>
<add>// #35403 #36122
<add>func TestBuildUncleanTarFilenames(t *testing.T) {
<add> ctx := context.TODO()
<add> defer setupTest(t)()
<add>
<add> dockerfile := `FROM scratch
<add>COPY foo /
<add>FROM scratch
<add>COPY bar /`
<add>
<add> buf := bytes.NewBuffer(nil)
<add> w := tar.NewWriter(buf)
<add> writeTarRecord(t, w, "Dockerfile", dockerfile)
<add> writeTarRecord(t, w, "../foo", "foocontents0")
<add> writeTarRecord(t, w, "/bar", "barcontents0")
<add> err := w.Close()
<add> require.NoError(t, err)
<add>
<add> apiclient := testEnv.APIClient()
<add> resp, err := apiclient.ImageBuild(ctx,
<add> buf,
<add> types.ImageBuildOptions{
<add> Remove: true,
<add> ForceRemove: true,
<add> })
<add>
<add> out := bytes.NewBuffer(nil)
<add> require.NoError(t, err)
<add> _, err = io.Copy(out, resp.Body)
<add> resp.Body.Close()
<add> require.NoError(t, err)
<add>
<add> // repeat with changed data should not cause cache hits
<add>
<add> buf = bytes.NewBuffer(nil)
<add> w = tar.NewWriter(buf)
<add> writeTarRecord(t, w, "Dockerfile", dockerfile)
<add> writeTarRecord(t, w, "../foo", "foocontents1")
<add> writeTarRecord(t, w, "/bar", "barcontents1")
<add> err = w.Close()
<add> require.NoError(t, err)
<add>
<add> resp, err = apiclient.ImageBuild(ctx,
<add> buf,
<add> types.ImageBuildOptions{
<add> Remove: true,
<add> ForceRemove: true,
<add> })
<add>
<add> out = bytes.NewBuffer(nil)
<add> require.NoError(t, err)
<add> _, err = io.Copy(out, resp.Body)
<add> resp.Body.Close()
<add> require.NoError(t, err)
<add> require.NotContains(t, out.String(), "Using cache")
<add>}
<add>
<add>func writeTarRecord(t *testing.T, w *tar.Writer, fn, contents string) {
<add> err := w.WriteHeader(&tar.Header{
<add> Name: fn,
<add> Mode: 0600,
<add> Size: int64(len(contents)),
<add> Typeflag: '0',
<add> })
<add> require.NoError(t, err)
<add> _, err = w.Write([]byte(contents))
<add> require.NoError(t, err)
<add>}
<add>
<ide> type buildLine struct {
<ide> Stream string
<ide> Aux struct {
<ide><path>pkg/tarsum/tarsum.go
<ide> func (ts *tarSum) Read(buf []byte) (int, error) {
<ide> }
<ide> return n, err
<ide> }
<del> ts.currentFile = path.Clean(currentHeader.Name)
<add> ts.currentFile = path.Join(".", path.Join("/", currentHeader.Name))
<ide> if err := ts.encodeHeader(currentHeader); err != nil {
<ide> return 0, err
<ide> } | 2 |
Python | Python | fix mypy errors for apache drill provider. | 433e0296ad1a5ff1c545aa477fe08000089a6e1e | <ide><path>airflow/providers/apache/drill/hooks/drill.py
<ide> def get_uri(self) -> str:
<ide> storage_plugin = conn_md.extra_dejson.get('storage_plugin', 'dfs')
<ide> return f'{conn_type}://{host}/{storage_plugin}' f'?dialect_driver={dialect_driver}'
<ide>
<del> def set_autocommit(self, conn: Connection, autocommit: bool) -> NotImplemented:
<add> def set_autocommit(self, conn: Connection, autocommit: bool) -> NotImplementedError:
<ide> raise NotImplementedError("There are no transactions in Drill.")
<ide>
<ide> def insert_rows(
<ide> def insert_rows(
<ide> commit_every: int = 1000,
<ide> replace: bool = False,
<ide> **kwargs: Any,
<del> ) -> NotImplemented:
<add> ) -> NotImplementedError:
<ide> raise NotImplementedError("There is no INSERT statement in Drill.") | 1 |
Javascript | Javascript | update rulesofhooks with useevent rules | c89a83695c18814e98a8e815a2389a11540e0160 | <ide><path>packages/eslint-plugin-react-hooks/__tests__/ESLintRuleExhaustiveDeps-test.js
<ide> const tests = {
<ide> }, 1000);
<ide> return () => clearInterval(id);
<ide> }, [setCount]);
<del>
<add>
<ide> return <h1>{count}</h1>;
<ide> }
<ide> `,
<ide> const tests = {
<ide> ],
<ide> };
<ide>
<add>if (__EXPERIMENTAL__) {
<add> tests.valid = [
<add> ...tests.valid,
<add> {
<add> code: normalizeIndent`
<add> function MyComponent({ theme }) {
<add> const onStuff = useEvent(() => {
<add> showNotification(theme);
<add> });
<add> useEffect(() => {
<add> onStuff();
<add> }, []);
<add> }
<add> `,
<add> },
<add> ];
<add>}
<add>
<ide> // Tests that are only valid/invalid across parsers supporting Flow
<ide> const testsFlow = {
<ide> valid: [
<ide><path>packages/eslint-plugin-react-hooks/__tests__/ESLintRulesOfHooks-test.js
<ide> const tests = {
<ide> },
<ide> {
<ide> code: `
<del> // This is a false positive (it's valid) that unfortunately
<add> // This is a false positive (it's valid) that unfortunately
<ide> // we cannot avoid. Prefer to rename it to not start with "use"
<ide> class Foo extends Component {
<ide> render() {
<ide> const tests = {
<ide> ],
<ide> };
<ide>
<add>if (__EXPERIMENTAL__) {
<add> tests.valid = [
<add> ...tests.valid,
<add> `
<add> // Valid because functions created with useEvent can be called in a useEffect.
<add> function MyComponent({ theme }) {
<add> const onClick = useEvent(() => {
<add> showNotification(theme);
<add> });
<add> useEffect(() => {
<add> onClick();
<add> });
<add> }
<add> `,
<add> `
<add> // Valid because functions created with useEvent can be called in closures.
<add> function MyComponent({ theme }) {
<add> const onClick = useEvent(() => {
<add> showNotification(theme);
<add> });
<add> return <Child onClick={() => onClick()}></Child>;
<add> }
<add> `,
<add> `
<add> // Valid because functions created with useEvent can be called in closures.
<add> function MyComponent({ theme }) {
<add> const onClick = useEvent(() => {
<add> showNotification(theme);
<add> });
<add> const onClick2 = () => { onClick() };
<add> const onClick3 = useCallback(() => onClick(), []);
<add> return <>
<add> <Child onClick={onClick2}></Child>
<add> <Child onClick={onClick3}></Child>
<add> </>;
<add> }
<add> `,
<add> `
<add> // Valid because functions created with useEvent can be passed by reference in useEffect
<add> // and useEvent.
<add> function MyComponent({ theme }) {
<add> const onClick = useEvent(() => {
<add> showNotification(theme);
<add> });
<add> const onClick2 = useEvent(() => {
<add> debounce(onClick);
<add> });
<add> useEffect(() => {
<add> let id = setInterval(onClick, 100);
<add> return () => clearInterval(onClick);
<add> }, []);
<add> return <Child onClick={() => onClick2()} />
<add> }
<add> `,
<add> `
<add> const MyComponent = ({theme}) => {
<add> const onClick = useEvent(() => {
<add> showNotification(theme);
<add> });
<add> return <Child onClick={() => onClick()}></Child>;
<add> };
<add> `,
<add> `
<add> function MyComponent({ theme }) {
<add> const notificationService = useNotifications();
<add> const showNotification = useEvent((text) => {
<add> notificationService.notify(theme, text);
<add> });
<add> const onClick = useEvent((text) => {
<add> showNotification(text);
<add> });
<add> return <Child onClick={(text) => onClick(text)} />
<add> }
<add> `,
<add> `
<add> function MyComponent({ theme }) {
<add> useEffect(() => {
<add> onClick();
<add> });
<add> const onClick = useEvent(() => {
<add> showNotification(theme);
<add> });
<add> }
<add> `,
<add> ];
<add> tests.invalid = [
<add> ...tests.invalid,
<add> {
<add> code: `
<add> function MyComponent({ theme }) {
<add> const onClick = useEvent(() => {
<add> showNotification(theme);
<add> });
<add> return <Child onClick={onClick}></Child>;
<add> }
<add> `,
<add> errors: [useEventError('onClick')],
<add> },
<add> {
<add> code: `
<add> // This should error even though it shares an identifier name with the below
<add> function MyComponent({theme}) {
<add> const onClick = useEvent(() => {
<add> showNotification(theme)
<add> });
<add> return <Child onClick={onClick} />
<add> }
<add>
<add> // The useEvent function shares an identifier name with the above
<add> function MyOtherComponent({theme}) {
<add> const onClick = useEvent(() => {
<add> showNotification(theme)
<add> });
<add> return <Child onClick={() => onClick()} />
<add> }
<add> `,
<add> errors: [{...useEventError('onClick'), line: 4}],
<add> },
<add> {
<add> code: `
<add> const MyComponent = ({ theme }) => {
<add> const onClick = useEvent(() => {
<add> showNotification(theme);
<add> });
<add> return <Child onClick={onClick}></Child>;
<add> }
<add> `,
<add> errors: [useEventError('onClick')],
<add> },
<add> {
<add> code: `
<add> // Invalid because onClick is being aliased to foo but not invoked
<add> function MyComponent({ theme }) {
<add> const onClick = useEvent(() => {
<add> showNotification(theme);
<add> });
<add> let foo;
<add> useEffect(() => {
<add> foo = onClick;
<add> });
<add> return <Bar onClick={foo} />
<add> }
<add> `,
<add> errors: [useEventError('onClick')],
<add> },
<add> ];
<add>}
<add>
<ide> function conditionalError(hook, hasPreviousFinalizer = false) {
<ide> return {
<ide> message:
<ide> function classError(hook) {
<ide> };
<ide> }
<ide>
<add>function useEventError(fn) {
<add> return {
<add> message:
<add> `\`${fn}\` is a function created with React Hook "useEvent", and can only be called from ` +
<add> 'the same component. They cannot be assigned to variables or passed down.',
<add> };
<add>}
<add>
<ide> // For easier local testing
<ide> if (!process.env.CI) {
<ide> let only = [];
<ide><path>packages/eslint-plugin-react-hooks/src/ExhaustiveDeps.js
<ide> export default {
<ide> // ^^^ true for this reference
<ide> // const ref = useRef()
<ide> // ^^^ true for this reference
<add> // const onStuff = useEvent(() => {})
<add> // ^^^ true for this reference
<ide> // False for everything else.
<ide> function isStableKnownHookValue(resolved) {
<ide> if (!isArray(resolved.defs)) {
<ide> export default {
<ide> if (name === 'useRef' && id.type === 'Identifier') {
<ide> // useRef() return value is stable.
<ide> return true;
<add> } else if (isUseEventIdentifier(callee) && id.type === 'Identifier') {
<add> // useEvent() return value is stable.
<add> return true;
<ide> } else if (name === 'useState' || name === 'useReducer') {
<ide> // Only consider second value in initializing tuple stable.
<ide> if (
<ide> function isSameIdentifier(a, b) {
<ide> function isAncestorNodeOf(a, b) {
<ide> return a.range[0] <= b.range[0] && a.range[1] >= b.range[1];
<ide> }
<add>
<add>function isUseEventIdentifier(node) {
<add> if (__EXPERIMENTAL__) {
<add> return node.type === 'Identifier' && node.name === 'useEvent';
<add> }
<add> return false;
<add>}
<ide><path>packages/eslint-plugin-react-hooks/src/RulesOfHooks.js
<ide> function isInsideComponentOrHook(node) {
<ide> return false;
<ide> }
<ide>
<add>function isUseEventIdentifier(node) {
<add> if (__EXPERIMENTAL__) {
<add> return node.type === 'Identifier' && node.name === 'useEvent';
<add> }
<add> return false;
<add>}
<add>
<ide> export default {
<ide> meta: {
<ide> type: 'problem',
<ide> export default {
<ide> },
<ide> },
<ide> create(context) {
<add> let lastEffect = null;
<ide> const codePathReactHooksMapStack = [];
<ide> const codePathSegmentStack = [];
<add> const useEventViolations = new Set();
<add>
<add> // For a given AST node, iterate through the top level statements and add all useEvent
<add> // definitions. We can do this in non-Program nodes because we can rely on the assumption that
<add> // useEvent functions can only be declared within a component or hook at its top level.
<add> function addAllUseEventViolations(node) {
<add> if (node.body.type !== 'BlockStatement') return;
<add> for (const statement of node.body.body) {
<add> if (statement.type !== 'VariableDeclaration') continue;
<add> for (const declaration of statement.declarations) {
<add> if (
<add> declaration.type === 'VariableDeclarator' &&
<add> declaration.init &&
<add> declaration.init.type === 'CallExpression' &&
<add> declaration.init.callee &&
<add> isUseEventIdentifier(declaration.init.callee)
<add> ) {
<add> useEventViolations.add(declaration.id);
<add> }
<add> }
<add> }
<add> }
<add>
<add> // Resolve a useEvent violation, ie the useEvent created function was called.
<add> function resolveUseEventViolation(scope, ident) {
<add> if (scope.references == null || useEventViolations.size === 0) return;
<add> for (const ref of scope.references) {
<add> if (ref.resolved == null) continue;
<add> const [useEventFunctionIdentifier] = ref.resolved.identifiers;
<add> if (ident.name === useEventFunctionIdentifier.name) {
<add> useEventViolations.delete(useEventFunctionIdentifier);
<add> break;
<add> }
<add> }
<add> }
<add>
<ide> return {
<ide> // Maintain code segment path stack as we traverse.
<ide> onCodePathSegmentStart: segment => codePathSegmentStack.push(segment),
<ide> export default {
<ide> }
<ide> reactHooks.push(node.callee);
<ide> }
<add>
<add> const scope = context.getScope();
<add> // useEvent: Resolve a function created with useEvent that is invoked locally at least once.
<add> // OK - onClick();
<add> resolveUseEventViolation(scope, node.callee);
<add>
<add> // useEvent: useEvent functions can be passed by reference within useEffect as well as in
<add> // another useEvent
<add> if (
<add> node.callee.type === 'Identifier' &&
<add> (node.callee.name === 'useEffect' ||
<add> isUseEventIdentifier(node.callee)) &&
<add> node.arguments.length > 0
<add> ) {
<add> // Denote that we have traversed into a useEffect call, and stash the CallExpr for
<add> // comparison later when we exit
<add> lastEffect = node;
<add> }
<add> },
<add>
<add> Identifier(node) {
<add> // OK - useEffect(() => { setInterval(onClick, ...) }, []);
<add> if (lastEffect != null && node.parent.type === 'CallExpression') {
<add> resolveUseEventViolation(context.getScope(), node);
<add> }
<add> },
<add>
<add> 'CallExpression:exit'(node) {
<add> if (node === lastEffect) {
<add> lastEffect = null;
<add> }
<add> },
<add>
<add> FunctionDeclaration(node) {
<add> // function MyComponent() { const onClick = useEvent(...) }
<add> if (isInsideComponentOrHook(node)) {
<add> addAllUseEventViolations(node);
<add> }
<add> },
<add>
<add> ArrowFunctionExpression(node) {
<add> // const MyComponent = () => { const onClick = useEvent(...) }
<add> if (isInsideComponentOrHook(node)) {
<add> addAllUseEventViolations(node);
<add> }
<add> },
<add>
<add> 'Program:exit'(_node) {
<add> for (const node of useEventViolations.values()) {
<add> context.report({
<add> node,
<add> message:
<add> `\`${context.getSource(
<add> node,
<add> )}\` is a function created with React Hook "useEvent", and can only be called from ` +
<add> 'the same component. They cannot be assigned to variables or passed down.',
<add> });
<add> }
<ide> },
<ide> };
<ide> }, | 4 |
Javascript | Javascript | replace non-breaking with regular space | c6af18d61f4cec13b40d07a7170d2ec8c170e160 | <ide><path>src/renderers/webgl/WebGLProgram.js
<ide> function generateExtensions( extensions, parameters, rendererExtensions ) {
<ide> extensions = extensions || {};
<ide>
<ide> var chunks = [
<del> ( extensions.derivatives || parameters.envMapCubeUV || parameters.bumpMap || parameters.tangentSpaceNormalMap || parameters.clearcoatNormalMap || parameters.flatShading || parameters.shaderID === 'physical' ) ? '#extension GL_OES_standard_derivatives : enable' : '',
<add> ( extensions.derivatives || parameters.envMapCubeUV || parameters.bumpMap || parameters.tangentSpaceNormalMap || parameters.clearcoatNormalMap || parameters.flatShading || parameters.shaderID === 'physical' ) ? '#extension GL_OES_standard_derivatives : enable' : '',
<ide> ( extensions.fragDepth || parameters.logarithmicDepthBuffer ) && rendererExtensions.get( 'EXT_frag_depth' ) ? '#extension GL_EXT_frag_depth : enable' : '',
<ide> ( extensions.drawBuffers ) && rendererExtensions.get( 'WEBGL_draw_buffers' ) ? '#extension GL_EXT_draw_buffers : require' : '',
<ide> ( extensions.shaderTextureLOD || parameters.envMap ) && rendererExtensions.get( 'EXT_shader_texture_lod' ) ? '#extension GL_EXT_shader_texture_lod : enable' : '' | 1 |
Javascript | Javascript | update example to use a module | d5305d565285ed805278ad7ad71b3b34b3e761c6 | <ide><path>src/ng/directive/select.js
<ide> var ngOptionsMinErr = minErr('ngOptions');
<ide> * `value` variable (e.g. `value.propertyName`).
<ide> *
<ide> * @example
<del> <example>
<add> <example module="selectExample">
<ide> <file name="index.html">
<ide> <script>
<del> function MyCntrl($scope) {
<del> $scope.colors = [
<del> {name:'black', shade:'dark'},
<del> {name:'white', shade:'light'},
<del> {name:'red', shade:'dark'},
<del> {name:'blue', shade:'dark'},
<del> {name:'yellow', shade:'light'}
<del> ];
<del> $scope.myColor = $scope.colors[2]; // red
<del> }
<add> angular.module('selectExample', [])
<add> .controller('ExampleController', ['$scope', function($scope) {
<add> $scope.colors = [
<add> {name:'black', shade:'dark'},
<add> {name:'white', shade:'light'},
<add> {name:'red', shade:'dark'},
<add> {name:'blue', shade:'dark'},
<add> {name:'yellow', shade:'light'}
<add> ];
<add> $scope.myColor = $scope.colors[2]; // red
<add> }]);
<ide> </script>
<del> <div ng-controller="MyCntrl">
<add> <div ng-controller="ExampleController">
<ide> <ul>
<ide> <li ng-repeat="color in colors">
<ide> Name: <input ng-model="color.name"> | 1 |
Javascript | Javascript | check availability of canvas & pdf before printing | f4ba0e342e0de0bf94eb5b38d520c1d751d2d64b | <ide><path>web/mozPrintCallback_polyfill.js
<ide>
<ide> function renderProgress() {
<ide> var progressContainer = document.getElementById('mozPrintCallback-shim');
<del> if (canvases) {
<add> if (canvases && canvases.length) {
<ide> var progress = Math.round(100 * index / canvases.length);
<ide> var progressBar = progressContainer.querySelector('progress');
<ide> var progressPerc = progressContainer.querySelector('.relative-progress');
<ide><path>web/viewer.js
<ide> var PDFViewerApplication = {
<ide>
<ide> var alertNotReady = false;
<ide> var i, ii;
<del> if (!this.pagesCount) {
<add> if (!this.pdfDocument || !this.pagesCount) {
<ide> alertNotReady = true;
<ide> } else {
<ide> for (i = 0, ii = this.pagesCount; i < ii; ++i) { | 2 |
Go | Go | add fallback for pull by tag | 495d623ae5b1b601667d82682c5c265be189a29b | <ide><path>distribution/errors.go
<ide> func TranslatePullError(err error, ref reference.Named) error {
<ide> return errdefs.Unknown(err)
<ide> }
<ide>
<add>func isNotFound(err error) bool {
<add> switch v := err.(type) {
<add> case errcode.Errors:
<add> for _, e := range v {
<add> if isNotFound(e) {
<add> return true
<add> }
<add> }
<add> case errcode.Error:
<add> switch v.Code {
<add> case errcode.ErrorCodeDenied, v2.ErrorCodeManifestUnknown, v2.ErrorCodeNameUnknown:
<add> return true
<add> }
<add> }
<add> return false
<add>}
<add>
<ide> // continueOnError returns true if we should fallback to the next endpoint
<ide> // as a result of this error.
<ide> func continueOnError(err error, mirrorEndpoint bool) bool {
<ide><path>distribution/pull_v2.go
<ide> func (p *v2Puller) pullV2Tag(ctx context.Context, ref reference.Named, platform
<ide> dgst digest.Digest
<ide> mt string
<ide> size int64
<add> tagged reference.NamedTagged
<add> isTagged bool
<ide> )
<ide> if digested, isDigested := ref.(reference.Canonical); isDigested {
<ide> dgst = digested.Digest()
<ide> tagOrDigest = digested.String()
<del> } else if tagged, isTagged := ref.(reference.NamedTagged); isTagged {
<add> } else if tagged, isTagged = ref.(reference.NamedTagged); isTagged {
<ide> tagService := p.repo.Tags(ctx)
<ide> desc, err := tagService.Get(ctx, tagged.Tag())
<ide> if err != nil {
<ide> return false, allowV1Fallback(err)
<ide> }
<add>
<ide> dgst = desc.Digest
<ide> tagOrDigest = tagged.Tag()
<ide> mt = desc.MediaType
<ide> func (p *v2Puller) pullV2Tag(ctx context.Context, ref reference.Named, platform
<ide> "remote": ref,
<ide> }))
<ide>
<del> manifest, err := p.manifestStore.Get(ctx, specs.Descriptor{
<add> desc := specs.Descriptor{
<ide> MediaType: mt,
<ide> Digest: dgst,
<ide> Size: size,
<del> })
<add> }
<add> manifest, err := p.manifestStore.Get(ctx, desc)
<ide> if err != nil {
<del> return false, err
<add> if isTagged && isNotFound(errors.Cause(err)) {
<add> logrus.WithField("ref", ref).WithError(err).Debug("Falling back to pull manifest by tag")
<add>
<add> msg := `%s Failed to pull manifest by the resolved digest. This registry does not
<add> appear to conform to the distribution registry specification; falling back to
<add> pull by tag. This fallback is DEPRECATED, and will be removed in a future
<add> release. Please contact admins of %s. %s
<add>`
<add>
<add> warnEmoji := "\U000026A0\U0000FE0F"
<add> progress.Messagef(p.config.ProgressOutput, "WARNING", msg, warnEmoji, p.endpoint.URL, warnEmoji)
<add>
<add> // Fetch by tag worked, but fetch by digest didn't.
<add> // This is a broken registry implementation.
<add> // We'll fallback to the old behavior and get the manifest by tag.
<add> var ms distribution.ManifestService
<add> ms, err = p.repo.Manifests(ctx)
<add> if err != nil {
<add> return false, err
<add> }
<add>
<add> manifest, err = ms.Get(ctx, "", distribution.WithTag(tagged.Tag()))
<add> err = errors.Wrap(err, "error after falling back to get manifest by tag")
<add> }
<add> if err != nil {
<add> return false, err
<add> }
<ide> }
<ide>
<ide> if manifest == nil {
<ide> func (p *v2Puller) pullManifestList(ctx context.Context, ref reference.Named, mf
<ide> return "", "", err
<ide> }
<ide>
<del> manifest, err := p.manifestStore.Get(ctx, specs.Descriptor{
<add> desc := specs.Descriptor{
<ide> Digest: match.Digest,
<ide> Size: match.Size,
<ide> MediaType: match.MediaType,
<del> })
<add> }
<add> manifest, err := p.manifestStore.Get(ctx, desc)
<ide> if err != nil {
<ide> return "", "", err
<ide> } | 2 |
Ruby | Ruby | handle empty otool output | 02e5f8ed6b9618023e8adb372f8431e63e9666ba | <ide><path>Library/Homebrew/mach.rb
<ide> def initialize(path)
<ide> def parse_otool_L_output
<ide> ENV["HOMEBREW_MACH_O_FILE"] = path.expand_path.to_s
<ide> libs = `#{MacOS.locate("otool")} -L "$HOMEBREW_MACH_O_FILE"`.split("\n")
<add> return nil, [] if libs.empty?
<ide>
<ide> libs.shift # first line is the filename
<ide> | 1 |
Javascript | Javascript | fix sys.inspect for regex in different context | 5dc2b9331149436b9331deb890bbd2deb6dfe0e5 | <ide><path>lib/sys.js
<ide> function isRegExp (re) {
<ide> && re.compile
<ide> && re.test
<ide> && re.exec
<del> && s.charAt(0) === "/"
<del> && s.substr(-1) === "/";
<add> && s.match(/^\/.*\/[gim]{0,3}$/);
<ide> }
<ide>
<ide> | 1 |
Python | Python | fix potential issue in topology engine | dacf017d3884a4b84342d891c1504ee3c8bf6a02 | <ide><path>keras/engine/topology.py
<ide> def summary(self):
<ide> print_summary(flattened_layers, getattr(self, 'container_nodes', None))
<ide>
<ide>
<del>def get_source_inputs(tensor):
<add>def get_source_inputs(tensor, layer=None, node_index=None, tensor_index=None):
<ide> '''Returns the list of input tensors
<ide> necessary to compute `tensor`.
<ide>
<ide> Output will always be a list of tensors
<ide> (potentially with 1 element).
<add>
<add> # Arguments
<add> tensor: the tensor to start from.
<add> layer: origin layer of the tensor. Will be
<add> determined via tensor._keras_history if not provided.
<add> node_index: origin node index of the tensor.
<add> tensor_index: origin tensor index of the tensor.
<ide> '''
<ide> if not hasattr(tensor, '_keras_history'):
<ide> raise Exception('Tensor must be a Keras tensor. Found: ' + str(tensor))
<ide> def get_source_inputs(tensor):
<ide> return node.input_tensors
<ide> else:
<ide> source_tensors = []
<del> for x in node.input_tensors:
<del> # TODO: what about graph cycles?
<del> previous_sources = get_source_inputs(x)
<add> for i in range(len(node.inbound_layers)):
<add> x = node.input_tensors[i]
<add> layer = node.inbound_layers[i]
<add> node_index = node.node_indices[i]
<add> tensor_index = node.tensor_indices[i]
<add> previous_sources = get_source_inputs(x,
<add> layer,
<add> node_index,
<add> tensor_index)
<ide> # avoid input redundancy
<ide> for x in previous_sources:
<ide> if x not in source_tensors: | 1 |
Javascript | Javascript | remove unused dependency | 3c3e6980b3584b0a63f03afaaf956dba3b8d93e0 | <ide><path>docs/spec/specs.js
<ide> if (global.jasmine) return;
<ide>
<ide> var jasmine = require('../../lib/jasmine-1.0.1');
<del>var sys = require('util');
<ide>
<ide> for(var key in jasmine) {
<ide> global[key] = jasmine[key]; | 1 |
Ruby | Ruby | fix regex for svn+http | 5f5fdb3284b1ff6c961242b1c659ea63ddaf2b67 | <ide><path>Library/Homebrew/download_strategy.rb
<ide> def detect_download_strategy url
<ide> when %r[^git://] then GitDownloadStrategy
<ide> when %r[^hg://] then MercurialDownloadStrategy
<ide> when %r[^svn://] then SubversionDownloadStrategy
<del> when %r[^svn+http://] then SubversionDownloadStrategy
<add> when %r[^svn\+http://] then SubversionDownloadStrategy
<ide> when %r[^fossil://] then FossilDownloadStrategy
<ide> # Some well-known source hosts
<ide> when %r[^http://github\.com/.+\.git$] then GitDownloadStrategy | 1 |
Javascript | Javascript | add test for scale.quantize | f23cb315dea07c811098b7dcc75ef974f65dad79 | <ide><path>d3.js
<ide> d3.scale.quantize = function() {
<ide>
<ide> scale.domain = function(x) {
<ide> if (!arguments.length) return [x0, x1];
<del> x0 = x[0];
<del> x1 = x[1];
<add> x0 = +x[0];
<add> x1 = +x[x.length - 1];
<ide> kx = range.length / (x1 - x0);
<ide> return scale;
<ide> };
<ide><path>d3.min.js
<ide> (function(){function cs(){return"circle"}function cr(){return 64}function cq(a,b){var c=(a.ownerSVGElement||a).createSVGPoint();if(cp<0&&(window.scrollX||window.scrollY)){var d=d3.select(document.body).append("svg:svg").style("position","absolute").style("top",0).style("left",0),e=d[0][0].getScreenCTM();cp=!e.f&&!e.e,d.remove()}cp?(c.x=b.pageX,c.y=b.pageY):(c.x=b.clientX,c.y=b.clientY),c=c.matrixTransform(a.getScreenCTM().inverse());return[c.x,c.y]}function co(a){return function(){var b=a.apply(this,arguments),c=b[0],d=b[1]+bA;return[c*Math.cos(d),c*Math.sin(d)]}}function cn(a){return[a.x,a.y]}function cm(a){return a.endAngle}function cl(a){return a.startAngle}function ck(a){return a.radius}function cj(a){return a.target}function ci(a){return a.source}function ch(a){return function(b,c){return a[c][1]}}function cg(a){return function(b,c){return a[c][0]}}function cf(a){function i(f){if(f.length<1)return null;var i=bH(this,f,b,d),j=bH(this,f,b===c?cg(i):c,d===e?ch(i):e);return"M"+g(a(j),h)+"L"+g(a(i.reverse()),h)+"Z"}var b=bI,c=bI,d=0,e=bJ,f="linear",g=bK[f],h=.7;i.x=function(a){if(!arguments.length)return c;b=c=a;return i},i.x0=function(a){if(!arguments.length)return b;b=a;return i},i.x1=function(a){if(!arguments.length)return c;c=a;return i},i.y=function(a){if(!arguments.length)return e;d=e=a;return i},i.y0=function(a){if(!arguments.length)return d;d=a;return i},i.y1=function(a){if(!arguments.length)return e;e=a;return i},i.interpolate=function(a){if(!arguments.length)return f;g=bK[f=a];return i},i.tension=function(a){if(!arguments.length)return h;h=a;return i};return i}function ce(a){var b,c=-1,d=a.length,e,f;while(++c<d)b=a[c],e=b[0],f=b[1]+bA,b[0]=e*Math.cos(f),b[1]=e*Math.sin(f);return a}function cd(a){return a.length<3?bL(a):a[0]+bR(a,cc(a))}function cc(a){var b=[],c,d,e,f,g=cb(a),h=-1,i=a.length-1;while(++h<i)c=ca(a[h],a[h+1]),Math.abs(c)<1e-6?g[h]=g[h+1]=0:(d=g[h]/c,e=g[h+1]/c,f=d*d+e*e,f>9&&(f=c*3/Math.sqrt(f),g[h]=f*d,g[h+1]=f*e));h=-1;while(++h<=i)f=(a[Math.min(i,h+1)][0]-a[Math.max(0,h-1)][0])/(6*(1+g[h]*g[h])),b.push([f||0,g[h]*f||0]);return b}function cb(a){var b=0,c=a.length-1,d=[],e=a[0],f=a[1],g=d[0]=ca(e,f);while(++b<c)d[b]=g+(g=ca(e=f,f=a[b+1]));d[b]=g;return d}function ca(a,b){return(b[1]-a[1])/(b[0]-a[0])}function b_(a,b,c){a.push("C",bX(bY,b),",",bX(bY,c),",",bX(bZ,b),",",bX(bZ,c),",",bX(b$,b),",",bX(b$,c))}function bX(a,b){return a[0]*b[0]+a[1]*b[1]+a[2]*b[2]+a[3]*b[3]}function bW(a,b){var c=a.length-1,d=a[0][0],e=a[0][1],f=a[c][0]-d,g=a[c][1]-e,h=-1,i,j;while(++h<=c)i=a[h],j=h/c,i[0]=b*i[0]+(1-b)*(d+j*f),i[1]=b*i[1]+(1-b)*(e+j*g);return bT(a)}function bV(a){var b,c=-1,d=a.length,e=d+4,f,g=[],h=[];while(++c<4)f=a[c%d],g.push(f[0]),h.push(f[1]);b=[bX(b$,g),",",bX(b$,h)],--c;while(++c<e)f=a[c%d],g.shift(),g.push(f[0]),h.shift(),h.push(f[1]),b_(b,g,h);return b.join("")}function bU(a){if(a.length<4)return bL(a);var b=[],c=-1,d=a.length,e,f=[0],g=[0];while(++c<3)e=a[c],f.push(e[0]),g.push(e[1]);b.push(bX(b$,f)+","+bX(b$,g)),--c;while(++c<d)e=a[c],f.shift(),f.push(e[0]),g.shift(),g.push(e[1]),b_(b,f,g);return b.join("")}function bT(a){if(a.length<3)return bL(a);var b=[],c=1,d=a.length,e=a[0],f=e[0],g=e[1],h=[f,f,f,(e=a[1])[0]],i=[g,g,g,e[1]];b.push(f,",",g),b_(b,h,i);while(++c<d)e=a[c],h.shift(),h.push(e[0]),i.shift(),i.push(e[1]),b_(b,h,i);c=-1;while(++c<2)h.shift(),h.push(e[0]),i.shift(),i.push(e[1]),b_(b,h,i);return b.join("")}function bS(a,b){var c=[],d=(1-b)/2,e,f=a[0],g=a[1],h=1,i=a.length;while(++h<i)e=f,f=g,g=a[h],c.push([d*(g[0]-e[0]),d*(g[1]-e[1])]);return c}function bR(a,b){if(b.length<1||a.length!=b.length&&a.length!=b.length+2)return bL(a);var c=a.length!=b.length,d="",e=a[0],f=a[1],g=b[0],h=g,i=1;c&&(d+="Q"+(f[0]-g[0]*2/3)+","+(f[1]-g[1]*2/3)+","+f[0]+","+f[1],e=a[1],i=2);if(b.length>1){h=b[1],f=a[i],i++,d+="C"+(e[0]+g[0])+","+(e[1]+g[1])+","+(f[0]-h[0])+","+(f[1]-h[1])+","+f[0]+","+f[1];for(var j=2;j<b.length;j++,i++)f=a[i],h=b[j],d+="S"+(f[0]-h[0])+","+(f[1]-h[1])+","+f[0]+","+f[1]}if(c){var k=a[i];d+="Q"+(f[0]+h[0]*2/3)+","+(f[1]+h[1]*2/3)+","+k[0]+","+k[1]}return d}function bQ(a,b,c){return a.length<3?bL(a):a[0]+bR(a,bS(a,b))}function bP(a,b){return a.length<3?bL(a):a[0]+bR((a.push(a[0]),a),bS([a[a.length-2]].concat(a,[a[1]]),b))}function bO(a,b){return a.length<4?bL(a):a[1]+bR(a.slice(1,a.length-1),bS(a,b))}function bN(a){var b=[],c=0,d=a.length,e=a[0];b.push(e[0],",",e[1]);while(++c<d)b.push("H",(e=a[c])[0],"V",e[1]);return b.join("")}function bM(a){var b=[],c=0,d=a.length,e=a[0];b.push(e[0],",",e[1]);while(++c<d)b.push("V",(e=a[c])[1],"H",e[0]);return b.join("")}function bL(a){var b=[],c=0,d=a.length,e=a[0];b.push(e[0],",",e[1]);while(++c<d)b.push("L",(e=a[c])[0],",",e[1]);return b.join("")}function bJ(a){return a[1]}function bI(a){return a[0]}function bH(a,b,c,d){var e=[],f=-1,g=b.length,h=typeof c=="function",i=typeof d=="function",j;if(h&&i)while(++f<g)e.push([c.call(a,j=b[f],f),d.call(a,j,f)]);else if(h)while(++f<g)e.push([c.call(a,b[f],f),d]);else if(i)while(++f<g)e.push([c,d.call(a,b[f],f)]);else while(++f<g)e.push([c,d]);return e}function bG(a){function g(d){return d.length<1?null:"M"+e(a(bH(this,d,b,c)),f)}var b=bI,c=bJ,d="linear",e=bK[d],f=.7;g.x=function(a){if(!arguments.length)return b;b=a;return g},g.y=function(a){if(!arguments.length)return c;c=a;return g},g.interpolate=function(a){if(!arguments.length)return d;e=bK[d=a];return g},g.tension=function(a){if(!arguments.length)return f;f=a;return g};return g}function bF(a){return a.endAngle}function bE(a){return a.startAngle}function bD(a){return a.outerRadius}function bC(a){return a.innerRadius}function bv(a){return function(b){return b<0?-Math.pow(-b,a):Math.pow(b,a)}}function bu(a){return a.toPrecision(1)}function bt(a){return-Math.log(-a)/Math.LN10}function bs(a){return Math.log(a)/Math.LN10}function br(a,b,c,d){var e=[],f=[],g=0,h=a.length;while(++g<h)e.push(c(a[g-1],a[g])),f.push(d(b[g-1],b[g]));return function(b){var c=d3.bisect(a,b,1,a.length-1)-1;return f[c](e[c](b))}}function bq(a,b,c,d){var e=c(a[0],a[1]),f=d(b[0],b[1]);return function(a){return f(e(a))}}function bp(a,b){return d3.format(",."+Math.max(0,-Math.floor(Math.log(bn(a,b)[2])/Math.LN10+.01))+"f")}function bo(a,b){return d3.range.apply(d3,bn(a,b))}function bn(a,b){var c=bi(a),d=c[1]-c[0],e=Math.pow(10,Math.floor(Math.log(d/b)/Math.LN10)),f=b/d*e;f<=.15?e*=10:f<=.35?e*=5:f<=.75&&(e*=2),c[0]=Math.ceil(c[0]/e)*e,c[1]=Math.floor(c[1]/e)*e+e*.5,c[2]=e;return c}function bm(a){a=Math.pow(10,Math.round(Math.log(a)/Math.LN10)-1);return{floor:function(b){return Math.floor(b/a)*a},ceil:function(b){return Math.ceil(b/a)*a}}}function bl(a,b){a.range=d3.rebind(a,b.range),a.rangeRound=d3.rebind(a,b.rangeRound),a.interpolate=d3.rebind(a,b.interpolate),a.clamp=d3.rebind(a,b.clamp);return a}function bk(){return Math}function bj(a,b){var c=0,d=a.length-1,e=a[c],f=a[d],g;f<e&&(g=c,c=d,d=g,g=e,e=f,f=g),b=b(f-e),a[c]=b.floor(e),a[d]=b.ceil(f);return a}function bi(a){var b=a[0],c=a[a.length-1];return b<c?[b,c]:[c,b]}function bh(){}function bf(){var a=null,b=bb,c=Infinity;while(b)b.flush?b=a?a.next=b.next:bb=b.next:(c=Math.min(c,b.then+b.delay),b=(a=b).next);return c}function be(){var a,b=Date.now(),c=bb;while(c)a=b-c.then,a>=c.delay&&(c.flush=c.callback(a)),c=c.next;var d=bf()-b;d>24?(isFinite(d)&&(clearTimeout(bd),bd=setTimeout(be,d)),bc=0):(bc=1,bg(be))}function ba(a){return typeof a=="function"?function(b,c,d){var e=a.call(this,b,c)+"";return d!=e&&d3.interpolate(d,e)}:(a=a+"",function(b,c,d){return d!=a&&d3.interpolate(d,a)})}function _(a){function n(b){var h=!0,l=-1;a.each(function(){if(i[++l]!==2){var a=(b-j[l])/k[l],n=this.__transition__,o,p,q=e[l];if(a<1){h=!1;if(a<0)return}else a=1;if(i[l]){if(!n||n.active!==c){i[l]=2;return}}else{if(!n||n.active>c){i[l]=2;return}i[l]=1,g.start.dispatch.apply(this,arguments),q=e[l]={},n.active=c;for(p in d)if(o=d[p].apply(this,arguments))q[p]=o}o=m(a);for(p in q)q[p].call(this,o);if(a===1){i[l]=2;if(n.active===c){var r=n.owner;r===c&&(delete this.__transition__,f&&this.parentNode&&this.parentNode.removeChild(this)),$=c,g.end.dispatch.apply(this,arguments),$=0,n.owner=r}}}});return h}var b={},c=$||++Z,d={},e=[],f=!1,g=d3.dispatch("start","end"),i=[],j=[],k=[],l,m=d3.ease("cubic-in-out");a.each(function(){(this.__transition__||(this.__transition__={})).owner=c}),b.delay=function(c){var d=Infinity,e=-1;typeof c=="function"?a.each(function(a,b){var f=j[++e]=+c.apply(this,arguments);f<d&&(d=f)}):(d=+c,a.each(function(a,b){j[++e]=d})),d3.timer(n,d);return b},b.duration=function(c){var d=-1;typeof c=="function"?(l=0,a.each(function(a,b){var e=k[++d]=+c.apply(this,arguments);e>l&&(l=e)})):(l=+c,a.each(function(a,b){k[++d]=l}));return b},b.ease=function(a){m=typeof a=="function"?a:d3.ease.apply(d3,arguments);return b},b.attrTween=function(a,c){function f(b,d){var e=c.call(this,b,d,this.getAttributeNS(a.space,a.local));return e&&function(b){this.setAttributeNS(a.space,a.local,e(b))}}function e(b,d){var e=c.call(this,b,d,this.getAttribute(a));return e&&function(b){this.setAttribute(a,e(b))}}d["attr."+a]=a.local?f:e;return b},b.attr=function(a,c){return b.attrTween(a,ba(c))},b.styleTween=function(a,c,e){function f(b,d){var f=c.call(this,b,d,window.getComputedStyle(this,null).getPropertyValue(a));return f&&function(b){this.style.setProperty(a,f(b),e)}}arguments.length<3&&(e=null),d["style."+a]=f;return b},b.style=function(a,c,d){arguments.length<3&&(d=null);return b.styleTween(a,ba(c),d)},b.text=function(a){d.text=function(b,c){this.textContent=typeof a=="function"?a.call(this,b,c):a};return b},b.select=function(b){var c,d=_(a.select(b)).ease(m);c=-1,d.delay(function(a,b){return j[++c]}),c=-1,d.duration(function(a,b){return k[++c]});return d},b.selectAll=function(b){var c,d=_(a.selectAll(b)).ease(m);c=-1,d.delay(function(a,b){return j[b?c:++c]}),c=-1,d.duration(function(a,b){return k[b?c:++c]});return d},b.remove=function(){f=!0;return b},b.each=function(a,c){g[a].add(c);return b},b.call=h;return b.delay(0).duration(250)}function Y(a){return{__data__:a}}function X(a){arguments.length||(a=d3.ascending);return function(b,c){return a(b&&b.__data__,c&&c.__data__)}}function W(a){function b(b){var c=[],d,e,f,g;for(var h=0,i=a.length;h<i;h++){f=a[h],c.push(d=[]),d.parentNode=f.parentNode;for(var j=0,k=f.length;j<k;j++)(g=f[j])?(d.push(e=b(f.parentNode)),e.__data__=g.__data__):d.push(null)}return V(c)}a.append=function(a){function d(b){return b.appendChild(document.createElementNS(a.space,a.local))}function c(b){return b.appendChild(document.createElement(a))}a=d3.ns.qualify(a);return b(a.local?d:c)},a.insert=function(a,c){function e(b){return b.insertBefore(document.createElementNS(a.space,a.local),S(c,b))}function d(b){return b.insertBefore(document.createElement(a),S(c,b))}a=d3.ns.qualify(a);return b(a.local?e:d)};return a}function V(a){function d(b){for(var c=0,d=a.length;c<d;c++){var e=a[c];for(var f=0,g=e.length;f<g;f++){var h=e[f];if(h)return b.call(h,h.__data__,f)}}return null}function c(b){var c=[],d,e,f;for(var g=0,h=a.length;g<h;g++){e=a[g];for(var i=0,j=e.length;i<j;i++)if(f=e[i])c.push(d=b(f)),d.parentNode=f}return V(c)}function b(b){var c=[],d,e,f,g;for(var h=0,i=a.length;h<i;h++){f=a[h],c.push(d=[]),d.parentNode=f.parentNode;for(var j=0,k=f.length;j<k;j++)(g=f[j])?(d.push(e=b(g)),e&&"__data__"in g&&(e.__data__=g.__data__)):d.push(null)}return V(c)}a.select=function(a){return b(function(b){return S(a,b)})},a.selectAll=function(a){return c(function(b){return T(a,b)})},a.filter=function(b){var c=[],d,e,f;for(var g=0,h=a.length;g<h;g++){e=a[g],c.push(d=[]),d.parentNode=e.parentNode;for(var i=0,j=e.length;i<j;i++)(f=e[i])&&b.call(f,f.__data__,i)&&d.push(f)}return V(c)},a.map=function(b){var c,d;for(var e=0,f=a.length;e<f;e++){c=a[e];for(var g=0,h=c.length;g<h;g++)if(d=c[g])d.__data__=b.call(d,d.__data__,g)}return a},a.data=function(b,c){function g(a,b){var g=0,h=a.length,i=b.length,j=Math.min(h,i),k=Math.max(h,i),l=[],m=[],n=[],o,p;if(c){var q={},r=[],s,t=b.length;for(g=0;g<h;g++)s=c.call(o=a[g],o.__data__,g),s in q?n[t++]=o:q[s]=o,r.push(s);for(g=0;g<i;g++)o=q[s=c.call(b,p=b[g],g)],o?(o.__data__=p,l[g]=o,m[g]=n[g]=null):(m[g]=Y(p),l[g]=n[g]=null),delete q[s];for(g=0;g<h;g++)r[g]in q&&(n[g]=a[g])}else{for(;g<j;g++)o=a[g],p=b[g],o?(o.__data__=p,l[g]=o,m[g]=n[g]=null):(m[g]=Y(p),l[g]=n[g]=null);for(;g<i;g++)m[g]=Y(b[g]),l[g]=n[g]=null;for(;g<k;g++)n[g]=a[g],m[g]=l[g]=null}m.parentNode=l.parentNode=n.parentNode=a.parentNode,d.push(m),e.push(l),f.push(n)}var d=[],e=[],f=[],h=-1,i=a.length,j;if(typeof b=="function")while(++h<i)g(j=a[h],b.call(j,j.parentNode.__data__,h));else while(++h<i)g(j=a[h],b);var k=V(e);k.enter=function(){return W(d)},k.exit=function(){return V(f)};return k},a.each=function(b){for(var c=0,d=a.length;c<d;c++){var e=a[c];for(var f=0,g=e.length;f<g;f++){var h=e[f];h&&b.call(h,h.__data__,f)}}return a},a.empty=function(){return!d(function(){return!0})},a.node=function(){return d(function(){return this})},a.attr=function(b,c){function j(){var a=c.apply(this,arguments);a==null?this.removeAttributeNS(b.space,b.local):this.setAttributeNS(b.space,b.local,a)}function i(){var a=c.apply(this,arguments);a==null?this.removeAttribute(b):this.setAttribute(b,a)}function h(){this.setAttributeNS(b.space,b.local,c)}function g(){this.setAttribute(b,c)}function f(){this.removeAttributeNS(b.space,b.local)}function e(){this.removeAttribute(b)}b=d3.ns.qualify(b);if(arguments.length<2)return d(b.local?function(){return this.getAttributeNS(b.space,b.local)}:function(){return this.getAttribute(b)});return a.each(c==null?b.local?f:e:typeof c=="function"?b.local?j:i:b.local?h:g)},a.classed=function(b,c){function i(){(c.apply(this,arguments)?f:h).call(this)}function h(){if(a=this.classList)return a.remove(b);var a=this.className,c=a.baseVal!=null,d=c?a.baseVal:a;d=g(d.replace(e," ")),c?a.baseVal=d:this.className=d}function f(){if(a=this.classList)return a.add(b);var a=this.className,c=a.baseVal!=null,d=c?a.baseVal:a;e.lastIndex=0,e.test(d)||(d=g(d+" "+b),c?a.baseVal=d:this.className=d)}var e=new RegExp("(^|\\s+)"+d3.requote(b)+"(\\s+|$)","g");if(arguments.length<2)return d(function(){if(a=this.classList)return a.contains(b);var a=this.className;e.lastIndex=0;return e.test(a.baseVal!=null?a.baseVal:a)});return a.each(typeof c=="function"?i:c?f:h)},a.style=function(b,c,e){function h(){var a=c.apply(this,arguments);a==null?this.style.removeProperty(b):this.style.setProperty(b,a,e)}function g(){this.style.setProperty(b,c,e)}function f(){this.style.removeProperty(b)}arguments.length<3&&(e="");if(arguments.length<2)return d(function(){return window.getComputedStyle(this,null).getPropertyValue(b)});return a.each(c==null?f:typeof c=="function"?h:g)},a.property=function(b,c){function g(){var a=c.apply(this,arguments);a==null?delete this[b]:this[b]=a}function f(){this[b]=c}function e(){delete this[b]}b=d3.ns.qualify(b);if(arguments.length<2)return d(function(){return this[b]});return a.each(c==null?e:typeof c=="function"?g:f)},a.text=function(b){function e(){this.textContent=b.apply(this,arguments)}function c(){this.textContent=b}if(arguments.length<1)return d(function(){return this.textContent});return a.each(typeof b=="function"?e:c)},a.html=function(b){function e(){this.innerHTML=b.apply(this,arguments)}function c(){this.innerHTML=b}if(arguments.length<1)return d(function(){return this.innerHTML});return a.each(typeof b=="function"?e:c)},a.append=function(a){function d(b){return b.appendChild(document.createElementNS(a.space,a.local))}function c(b){return b.appendChild(document.createElement(a))}a=d3.ns.qualify(a);return b(a.local?d:c)},a.insert=function(a,c){function e(b){return b.insertBefore(document.createElementNS(a.space,a.local),S(c,b))}function d(b){return b.insertBefore(document.createElement(a),S(c,b))}a=d3.ns.qualify(a);return b(a.local?e:d)},a.remove=function(){return a.each(function(){var a=this.parentNode;a&&a.removeChild(this)})},a.sort=function(b){b=X.apply(this,arguments);for(var c=0,d=a.length;c<d;c++){var e=a[c];e.sort(b);for(var f=1,g=e.length,h=e[0];f<g;f++){var i=e[f];i&&(h&&h.parentNode.insertBefore(i,h.nextSibling),h=i)}}return a},a.on=function(b,c,d){arguments.length<3&&(d=!1);var e=b.indexOf("."),f=e===-1?b:b.substring(0,e),g="__on"+b;return a.each(function(a,b){function h(a){var d=d3.event;d3.event=a;try{c.call(this,e.__data__,b)}finally{d3.event=d}}this[g]&&this.removeEventListener(f,this[g],d),c&&this.addEventListener(f,this[g]=h,d);var e=this})},a.transition=function(){return _(a)},a.call=h;return a}function R(a,b,c){function g(a){return Math.round(f(a)*255)}function f(a){a>360?a-=360:a<0&&(a+=360);if(a<60)return d+(e-d)*a/60;if(a<180)return e;if(a<240)return d+(e-d)*(240-a)/60;return d}var d,e;a=a%360,a<0&&(a+=360),b=b<0?0:b>1?1:b,c=c<0?0:c>1?1:c,e=c<=.5?c*(1+b):c+b-c*b,d=2*c-e;return H(g(a+120),g(a),g(a-120))}function Q(a,b,c){this.h=a,this.s=b,this.l=c}function P(a,b,c){return new Q(a,b,c)}function M(a){var b=parseFloat(a);return a.charAt(a.length-1)==="%"?Math.round(b*2.55):b}function L(a,b,c){var d=Math.min(a/=255,b/=255,c/=255),e=Math.max(a,b,c),f=e-d,g,h,i=(e+d)/2;f?(h=i<.5?f/(e+d):f/(2-e-d),a==e?g=(b-c)/f+(b<c?6:0):b==e?g=(c-a)/f+2:g=(a-b)/f+4,g*=60):h=g=0;return P(g,h,i)}function K(a,b,c){var d=0,e=0,f=0,g,h,i;g=/([a-z]+)\((.*)\)/i.exec(a);if(g){h=g[2].split(",");switch(g[1]){case"hsl":return c(parseFloat(h[0]),parseFloat(h[1])/100,parseFloat(h[2])/100);case"rgb":return b(M(h[0]),M(h[1]),M(h[2]))}}if(i=N[a])return b(i.r,i.g,i.b);a!=null&&a.charAt(0)==="#"&&(a.length===4?(d=a.charAt(1),d+=d,e=a.charAt(2),e+=e,f=a.charAt(3),f+=f):a.length===7&&(d=a.substring(1,3),e=a.substring(3,5),f=a.substring(5,7)),d=parseInt(d,16),e=parseInt(e,16),f=parseInt(f,16));return b(d,e,f)}function J(a){return a<16?"0"+a.toString(16):a.toString(16)}function I(a,b,c){this.r=a,this.g=b,this.b=c}function H(a,b,c){return new I(a,b,c)}function G(a,b){b=1/(b-(a=+a));return function(c){return Math.max(0,Math.min(1,(c-a)*b))}}function F(a,b){b=1/(b-(a=+a));return function(c){return(c-a)*b}}function E(a){return a in D||/\bcolor\b/.test(a)?d3.interpolateRgb:d3.interpolate}function B(a){return a<1/2.75?7.5625*a*a:a<2/2.75?7.5625*(a-=1.5/2.75)*a+.75:a<2.5/2.75?7.5625*(a-=2.25/2.75)*a+.9375:7.5625*(a-=2.625/2.75)*a+.984375}function A(a){a||(a=1.70158);return function(b){return b*b*((a+1)*b-a)}}function z(a,b){var c;arguments.length<2&&(b=.45),arguments.length<1?(a=1,c=b/4):c=b/(2*Math.PI)*Math.asin(1/a);return function(d){return 1+a*Math.pow(2,10*-d)*Math.sin((d-c)*2*Math.PI/b)}}function y(a){return 1-Math.sqrt(1-a*a)}function x(a){return Math.pow(2,10*(a-1))}function w(a){return 1-Math.cos(a*Math.PI/2)}function v(a){return function(b){return Math.pow(b,a)}}function u(a){return a}function t(a){return function(b){return.5*(b<.5?a(2*b):2-a(2-2*b))}}function s(a){return function(b){return 1-a(1-b)}}function n(a){var b=a.lastIndexOf("."),c=b>=0?a.substring(b):(b=a.length,""),d=[];while(b>0)d.push(a.substring(b-=3,b+3));return d.reverse().join(",")+c}function m(a){return a+""}function j(a){var b={},c=[];b.add=function(a){for(var d=0;d<c.length;d++)if(c[d].listener==a)return b;c.push({listener:a,on:!0});return b},b.remove=function(a){for(var d=0;d<c.length;d++){var e=c[d];if(e.listener==a){e.on=!1,c=c.slice(0,d).concat(c.slice(d+1));break}}return b},b.dispatch=function(){var a=c;for(var b=0,d=a.length;b<d;b++){var e=a[b];e.on&&e.listener.apply(this,arguments)}};return b}function h(a){a.apply(this,(arguments[0]=this,arguments));return this}function g(a){return a.replace(/(^\s+)|(\s+$)/g,"").replace(/\s+/g," ")}function f(a){return a==null}function e(a){return a.length}function c(a){return Array.prototype.slice.call(a)}function b(a){var b=-1,c=a.length,d=[];while(++b<c)d.push(a[b]);return d}d3={version:"1.29.4"},Date.now||(Date.now=function(){return+(new Date)}),Object.create||(Object.create=function(a){function b(){}b.prototype=a;return new b});var a=c;try{a(document.documentElement.childNodes)[0].nodeType}catch(d){a=b}d3.functor=function(a){return typeof a=="function"?a:function(){return a}},d3.rebind=function(a,b){return function(){var c=b.apply(a,arguments);return arguments.length?a:c}},d3.ascending=function(a,b){return a<b?-1:a>b?1:a>=b?0:NaN},d3.descending=function(a,b){return b<a?-1:b>a?1:b>=a?0:NaN},d3.min=function(a,b){var c=-1,d=a.length,e,f;if(arguments.length===1){while(++c<d&&((e=a[c])==null||e!=e))e=undefined;while(++c<d)(f=a[c])!=null&&e>f&&(e=f)}else{while(++c<d&&((e=b.call(a,a[c],c))==null||e!=e))e=undefined;while(++c<d)(f=b.call(a,a[c],c))!=null&&e>f&&(e=f)}return e},d3.max=function(a,b){var c=-1,d=a.length,e,f;if(arguments.length===1){while(++c<d&&((e=a[c])==null||e!=e))e=undefined;while(++c<d)(f=a[c])!=null&&f>e&&(e=f)}else{while(++c<d&&((e=b.call(a,a[c],c))==null||e!=e))e=undefined;while(++c<d)(f=b.call(a,a[c],c))!=null&&f>e&&(e=f)}return e},d3.sum=function(a,b){var c=0,d=a.length,e,f=-1;if(arguments.length===1)while(++f<d)isNaN(e=+a[f])||(c+=e);else while(++f<d)isNaN(e=+b.call(a,a[f],f))||(c+=e);return c},d3.quantile=function(a,b){var c=(a.length-1)*b+1,d=Math.floor(c),e=a[d-1],f=c-d;return f?e+f*(a[d]-e):e},d3.zip=function(){if(!(f=arguments.length))return[];for(var a=-1,b=d3.min(arguments,e),c=Array(b);++a<b;)for(var d=-1,f,g=c[a]=Array(f);++d<f;)g[d]=arguments[d][a];return c},d3.bisectLeft=function(a,b,c,d){arguments.length<3&&(c=0),arguments.length<4&&(d=a.length);while(c<d){var e=c+d>>1;a[e]<b?c=e+1:d=e}return c},d3.bisect=d3.bisectRight=function(a,b,c,d){arguments.length<3&&(c=0),arguments.length<4&&(d=a.length);while(c<d){var e=c+d>>1;b<a[e]?d=e:c=e+1}return c},d3.first=function(a,b){var c=0,d=a.length,e=a[0],f;arguments.length===1&&(b=d3.ascending);while(++c<d)b.call(a,e,f=a[c])>0&&(e=f);return e},d3.last=function(a,b){var c=0,d=a.length,e=a[0],f;arguments.length===1&&(b=d3.ascending);while(++c<d)b.call(a,e,f=a[c])<=0&&(e=f);return e},d3.nest=function(){function g(a,d){if(d>=b.length)return a;var e=[],f=c[d++],h;for(h in a)e.push({key:h,values:g(a[h],d)});f&&e.sort(function(a,b){return f(a.key,b.key)});return e}function f(c,g){if(g>=b.length)return e?e.call(a,c):d?c.sort(d):c;var h=-1,i=c.length,j=b[g++],k,l,m={};while(++h<i)(k=j(l=c[h]))in m?m[k].push(l):m[k]=[l];for(k in m)m[k]=f(m[k],g);return m}var a={},b=[],c=[],d,e;a.map=function(a){return f(a,0)},a.entries=function(a){return g(f(a,0),0)},a.key=function(c){b.push(c);return a},a.sortKeys=function(d){c[b.length-1]=d;return a},a.sortValues=function(b){d=b;return a},a.rollup=function(b){e=b;return a};return a},d3.keys=function(a){var b=[];for(var c in a)b.push(c);return b},d3.values=function(a){var b=[];for(var c in a)b.push(a[c]);return b},d3.entries=function(a){var b=[];for(var c in a)b.push({key:c,value:a[c]});return b},d3.permute=function(a,b){var c=[],d=-1,e=b.length;while(++d<e)c[d]=a[b[d]];return c},d3.merge=function(a){return Array.prototype.concat.apply([],a)},d3.split=function(a,b){var c=[],d=[],e,g=-1,h=a.length;arguments.length<2&&(b=f);while(++g<h)b.call(d,e=a[g],g)?d=[]:(d.length||c.push(d),d.push(e));return c},d3.range=function(a,b,c){arguments.length<3&&(c=1,arguments.length<2&&(b=a,a=0));if((b-a)/c==Infinity)throw new Error("infinite range");var d=[],e=-1,f;if(c<0)while((f=a+c*++e)>b)d.push(f);else while((f=a+c*++e)<b)d.push(f);return d},d3.requote=function(a){return a.replace(i,"\\$&")};var i=/[\\\^\$\*\+\?\|\[\]\(\)\.\{\}]/g;d3.round=function(a,b){return b?Math.round(a*Math.pow(10,b))*Math.pow(10,-b):Math.round(a)},d3.xhr=function(a,b,c){var d=new XMLHttpRequest;arguments.length<3?c=b:b&&d.overrideMimeType&&d.overrideMimeType(b),d.open("GET",a,!0),d.onreadystatechange=function(){d.readyState===4&&c(d.status<300?d:null)},d.send(null)},d3.text=function(a,b,c){function d(a){c(a&&a.responseText)}arguments.length<3&&(c=b,b=null),d3.xhr(a,b,d)},d3.json=function(a,b){d3.text(a,"application/json",function(a){b(a?JSON.parse(a):null)})},d3.html=function(a,b){d3.text(a,"text/html",function(a){if(a!=null){var c=document.createRange();c.selectNode(document.body),a=c.createContextualFragment(a)}b(a)})},d3.xml=function(a,b,c){function d(a){c(a&&a.responseXML)}arguments.length<3&&(c=b,b=null),d3.xhr(a,b,d)},d3.ns={prefix:{svg:"http://www.w3.org/2000/svg",xhtml:"http://www.w3.org/1999/xhtml",xlink:"http://www.w3.org/1999/xlink",xml:"http://www.w3.org/XML/1998/namespace",xmlns:"http://www.w3.org/2000/xmlns/"},qualify:function(a){var b=a.indexOf(":");return b<0?a:{space:d3.ns.prefix[a.substring(0,b)],local:a.substring(b+1)}}},d3.dispatch=function(a){var b={},c;for(var d=0,e=arguments.length;d<e;d++)c=arguments[d],b[c]=j(c);return b},d3.format=function(a){var b=k.exec(a),c=b[1]||" ",d=b[3]||"",e=b[5],f=+b[6],g=b[7],h=b[8],i=b[9],j=!1,o=!1;h&&(h=h.substring(1)),e&&(c="0",g&&(f-=Math.floor((f-1)/4)));switch(i){case"n":g=!0,i="g";break;case"%":j=!0,i="f";break;case"p":j=!0,i="r";break;case"d":o=!0,h="0"}i=l[i]||m;return function(a){var b=j?a*100:+a,k=b<0&&(b=-b)?"−":d;if(o&&b%1)return"";a=i(b,h);if(e){var l=a.length+k.length;l<f&&(a=Array(f-l+1).join(c)+a),g&&(a=n(a)),a=k+a}else{g&&(a=n(a)),a=k+a;var l=a.length;l<f&&(a=Array(f-l+1).join(c)+a)}j&&(a+="%");return a}};var k=/(?:([^{])?([<>=^]))?([+\- ])?(#)?(0)?([0-9]+)?(,)?(\.[0-9]+)?([a-zA-Z%])?/,l={g:function(a,b){return a.toPrecision(b)},e:function(a,b){return a.toExponential(b)},f:function(a,b){return a.toFixed(b)},r:function(a,b){var c=1+Math.floor(1e-15+Math.log(a)/Math.LN10);return d3.round(a,b-c).toFixed(Math.max(0,b-c))}},o=v(2),p=v(3),q={linear:function(){return u},poly:v,quad:function(){return o},cubic:function(){return p},sin:function(){return w},exp:function(){return x},circle:function(){return y},elastic:z,back:A,bounce:function(){return B}},r={"in":function(a){return a},out:s,"in-out":t,"out-in":function(a){return t(s(a))}};d3.ease=function(a){var b=a.indexOf("-"),c=b>=0?a.substring(0,b):a,d=b>=0?a.substring(b+1):"in";return r[d](q[c].apply(null,Array.prototype.slice.call(arguments,1)))},d3.event=null,d3.interpolate=function(a,b){var c=d3.interpolators.length,d;while(--c>=0&&!(d=d3.interpolators[c](a,b)));return d},d3.interpolateNumber=function(a,b){b-=a;return function(c){return a+b*c}},d3.interpolateRound=function(a,b){b-=a;return function(c){return Math.round(a+b*c)}},d3.interpolateString=function(a,b){var c,d,e,f=0,g=0,h=[],i=[],j,k;C.lastIndex=0;for(d=0;c=C.exec(b);++d)c.index&&h.push(b.substring(f,g=c.index)),i.push({i:h.length,x:c[0]}),h.push(null),f=C.lastIndex;f<b.length&&h.push(b.substring(f));for(d=0,j=i.length;(c=C.exec(a))&&d<j;++d){k=i[d];if(k.x==c[0]){if(k.i)if(h[k.i+1]==null){h[k.i-1]+=k.x,h.splice(k.i,1);for(e=d+1;e<j;++e)i[e].i--}else{h[k.i-1]+=k.x+h[k.i+1],h.splice(k.i,2);for(e=d+1;e<j;++e)i[e].i-=2}else if(h[k.i+1]==null)h[k.i]=k.x;else{h[k.i]=k.x+h[k.i+1],h.splice(k.i+1,1);for(e=d+1;e<j;++e)i[e].i--}i.splice(d,1),j--,d--}else k.x=d3.interpolateNumber(parseFloat(c[0]),parseFloat(k.x))}while(d<j)k=i.pop(),h[k.i+1]==null?h[k.i]=k.x:(h[k.i]=k.x+h[k.i+1],h.splice(k.i+1,1)),j--;if(h.length===1)return h[0]==null?i[0].x:function(){return b};return function(a){for(d=0;d<j;++d)h[(k=i[d]).i]=k.x(a);return h.join("")}},d3.interpolateRgb=function(a,b){a=d3.rgb(a),b=d3.rgb(b);var c=a.r,d=a.g,e=a.b,f=b.r-c,g=b.g-d,h=b.b-e;return function(a){return"rgb("+Math.round(c+f*a)+","+Math.round(d+g*a)+","+Math.round(e+h*a)+")"}},d3.interpolateHsl=function(a,b){a=d3.hsl(a),b=d3.hsl(b);var c=a.h,d=a.s,e=a.l,f=b.h-c,g=b.s-d,h=b.l-e;return function(a){return R(c+f*a,d+g*a,e+h*a).toString()}},d3.interpolateArray=function(a,b){var c=[],d=[],e=a.length,f=b.length,g=Math.min(a.length,b.length),h;for(h=0;h<g;++h)c.push(d3.interpolate(a[h],b[h]));for(;h<e;++h)d[h]=a[h];for(;h<f;++h)d[h]=b[h];return function(a){for(h=0;h<g;++h)d[h]=c[h](a);return d}},d3.interpolateObject=function(a,b){var c={},d={},e;for(e in a)e in b?c[e]=E(e)(a[e],b[e]):d[e]=a[e];for(e in b)e in a||(d[e]=b[e]);return function(a){for(e in c)d[e]=c[e](a);return d}};var C=/[-+]?(?:\d+\.\d+|\d+\.|\.\d+|\d+)(?:[eE][-]?\d+)?/g,D={background:1,fill:1,stroke:1};d3.interpolators=[d3.interpolateObject,function(a,b){return b instanceof Array&&d3.interpolateArray(a,b)},function(a,b){return typeof b=="string"&&d3.interpolateString(String(a),b)},function(a,b){return(typeof b=="string"?b in N||/^(#|rgb\(|hsl\()/.test(b):b instanceof I||b instanceof Q)&&d3.interpolateRgb(String(a),b)},function(a,b){return typeof b=="number"&&d3.interpolateNumber(+a,b)}],d3.rgb=function(a,b,c){return arguments.length===1?K(""+a,H,R):H(~~a,~~b,~~c)},I.prototype.brighter=function(a){a=Math.pow(.7,arguments.length?a:1);var b=this.r,c=this.g,d=this.b,e=30;if(!b&&!c&&!d)return H(e,e,e);b&&b<e&&(b=e),c&&c<e&&(c=e),d&&d<e&&(d=e);return H(Math.min(255,Math.floor(b/a)),Math.min(255,Math.floor(c/a)),Math.min(255,Math.floor(d/a)))},I.prototype.darker=function(a){a=Math.pow(.7,arguments.length?a:1);return H(Math.max(0,Math.floor(a*this.r)),Math.max(0,Math.floor(a*this.g)),Math.max(0,Math.floor(a*this.b)))},I.prototype.hsl=function(){return L(this.r,this.g,this.b)},I.prototype.toString=function(){return"#"+J(this.r)+J(this.g)+J(this.b)};var N={aliceblue:"#f0f8ff",antiquewhite:"#faebd7",aqua:"#00ffff",aquamarine:"#7fffd4",azure:"#f0ffff",beige:"#f5f5dc",bisque:"#ffe4c4",black:"#000000",blanchedalmond:"#ffebcd",blue:"#0000ff",blueviolet:"#8a2be2",brown:"#a52a2a",burlywood:"#deb887",cadetblue:"#5f9ea0",chartreuse:"#7fff00",chocolate:"#d2691e",coral:"#ff7f50",cornflowerblue:"#6495ed",cornsilk:"#fff8dc",crimson:"#dc143c",cyan:"#00ffff",darkblue:"#00008b",darkcyan:"#008b8b",darkgoldenrod:"#b8860b",darkgray:"#a9a9a9",darkgreen:"#006400",darkgrey:"#a9a9a9",darkkhaki:"#bdb76b",darkmagenta:"#8b008b",darkolivegreen:"#556b2f",darkorange:"#ff8c00",darkorchid:"#9932cc",darkred:"#8b0000",darksalmon:"#e9967a",darkseagreen:"#8fbc8f",darkslateblue:"#483d8b",darkslategray:"#2f4f4f",darkslategrey:"#2f4f4f",darkturquoise:"#00ced1",darkviolet:"#9400d3",deeppink:"#ff1493",deepskyblue:"#00bfff",dimgray:"#696969",dimgrey:"#696969",dodgerblue:"#1e90ff",firebrick:"#b22222",floralwhite:"#fffaf0",forestgreen:"#228b22",fuchsia:"#ff00ff",gainsboro:"#dcdcdc",ghostwhite:"#f8f8ff",gold:"#ffd700",goldenrod:"#daa520",gray:"#808080",green:"#008000",greenyellow:"#adff2f",grey:"#808080",honeydew:"#f0fff0",hotpink:"#ff69b4",indianred:"#cd5c5c",indigo:"#4b0082",ivory:"#fffff0",khaki:"#f0e68c",lavender:"#e6e6fa",lavenderblush:"#fff0f5",lawngreen:"#7cfc00",lemonchiffon:"#fffacd",lightblue:"#add8e6",lightcoral:"#f08080",lightcyan:"#e0ffff",lightgoldenrodyellow:"#fafad2",lightgray:"#d3d3d3",lightgreen:"#90ee90",lightgrey:"#d3d3d3",lightpink:"#ffb6c1",lightsalmon:"#ffa07a",lightseagreen:"#20b2aa",lightskyblue:"#87cefa",lightslategray:"#778899",lightslategrey:"#778899",lightsteelblue:"#b0c4de",lightyellow:"#ffffe0",lime:"#00ff00",limegreen:"#32cd32",linen:"#faf0e6",magenta:"#ff00ff",maroon:"#800000",mediumaquamarine:"#66cdaa",mediumblue:"#0000cd",mediumorchid:"#ba55d3",mediumpurple:"#9370db",mediumseagreen:"#3cb371",mediumslateblue:"#7b68ee",mediumspringgreen:"#00fa9a",mediumturquoise:"#48d1cc",mediumvioletred:"#c71585",midnightblue:"#191970",mintcream:"#f5fffa",mistyrose:"#ffe4e1",moccasin:"#ffe4b5",navajowhite:"#ffdead",navy:"#000080",oldlace:"#fdf5e6",olive:"#808000",olivedrab:"#6b8e23",orange:"#ffa500",orangered:"#ff4500",orchid:"#da70d6",palegoldenrod:"#eee8aa",palegreen:"#98fb98",paleturquoise:"#afeeee",palevioletred:"#db7093",papayawhip:"#ffefd5",peachpuff:"#ffdab9",peru:"#cd853f",pink:"#ffc0cb",plum:"#dda0dd",powderblue:"#b0e0e6",purple:"#800080",red:"#ff0000",rosybrown:"#bc8f8f",royalblue:"#4169e1",saddlebrown:"#8b4513",salmon:"#fa8072",sandybrown:"#f4a460",seagreen:"#2e8b57",seashell:"#fff5ee",sienna:"#a0522d",silver:"#c0c0c0",skyblue:"#87ceeb",slateblue:"#6a5acd",slategray:"#708090",slategrey:"#708090",snow:"#fffafa",springgreen:"#00ff7f",steelblue:"#4682b4",tan:"#d2b48c",teal:"#008080",thistle:"#d8bfd8",tomato:"#ff6347",turquoise:"#40e0d0",violet:"#ee82ee",wheat:"#f5deb3",white:"#ffffff",whitesmoke:"#f5f5f5",yellow:"#ffff00",yellowgreen:"#9acd32"};for(var O in N)N[O]=K(N[O],H,R);d3.hsl=function(a,b,c){return arguments.length===1?K(""+a,L,P):P(+a,+b,+c)},Q.prototype.brighter=function(a){a=Math.pow(.7,arguments.length?a:1);return P(this.h,this.s,this.l/a)},Q.prototype.darker=function(a){a=Math.pow(.7,arguments.length?a:1);return P(this.h,this.s,a*this.l)},Q.prototype.rgb=function(){return R(this.h,this.s,this.l)},Q.prototype.toString=function(){return"hsl("+this.h+","+this.s*100+"%,"+this.l*100+"%)"};var S=function(a,b){return b.querySelector(a)},T=function(b,c){return a(c.querySelectorAll(b))};typeof Sizzle=="function"&&(S=function(a,b){return Sizzle(a,b)[0]},T=function(a,b){return Sizzle.uniqueSort(Sizzle(a,b))});var U=V([[document]]);U[0].parentNode=document.documentElement,d3.select=function(a){return typeof a=="string"?U.select(a):V([[a]])},d3.selectAll=function(b){return typeof
<del>b=="string"?U.selectAll(b):V([a(b)])},d3.transition=U.transition;var Z=0,$=0,bb=null,bc,bd;d3.timer=function(a,b){var c=Date.now(),d=!1,e,f=bb;if(arguments.length<2)b=0;else if(!isFinite(b))return;while(f){if(f.callback===a){f.then=c,f.delay=b,d=!0;break}e=f,f=f.next}d||(bb={callback:a,then:c,delay:b,next:bb}),bc||(bd=clearTimeout(bd),bc=1,bg(be))},d3.timer.flush=function(){var a,b=Date.now(),c=bb;while(c)a=b-c.then,c.delay||(c.flush=c.callback(a)),c=c.next;bf()};var bg=window.requestAnimationFrame||window.webkitRequestAnimationFrame||window.mozRequestAnimationFrame||window.oRequestAnimationFrame||window.msRequestAnimationFrame||function(a){setTimeout(a,17)};d3.scale={},d3.scale.linear=function(){function h(a){return e(a)}function g(){var g=a.length==2?bq:br,i=d?G:F;e=g(a,b,i,c),f=g(b,a,i,d3.interpolate);return h}var a=[0,1],b=[0,1],c=d3.interpolate,d=!1,e,f;h.invert=function(a){return f(a)},h.domain=function(b){if(!arguments.length)return a;a=b.map(Number);return g()},h.range=function(a){if(!arguments.length)return b;b=a;return g()},h.rangeRound=function(a){return h.range(a).interpolate(d3.interpolateRound)},h.clamp=function(a){if(!arguments.length)return d;d=a;return g()},h.interpolate=function(a){if(!arguments.length)return c;c=a;return g()},h.ticks=function(b){return bo(a,b)},h.tickFormat=function(b){return bp(a,b)},h.nice=function(){bj(a,bm);return g()};return g()},d3.scale.log=function(){function d(c){return a(b(c))}var a=d3.scale.linear(),b=bs,c=b.pow;d.invert=function(b){return c(a.invert(b))},d.domain=function(e){if(!arguments.length)return a.domain().map(c);b=e[0]<0?bt:bs,c=b.pow,a.domain(e.map(b));return d},d.nice=function(){a.domain(bj(a.domain(),bk));return d},d.ticks=function(){var d=bi(a.domain()),e=[];if(d.every(isFinite)){var f=Math.floor(d[0]),g=Math.ceil(d[1]),h=c(d[0]),i=c(d[1]);if(b===bt){e.push(c(f));for(;f++<g;)for(var j=9;j>0;j--)e.push(c(f)*j)}else{for(;f<g;f++)for(var j=1;j<10;j++)e.push(c(f)*j);e.push(c(f))}for(f=0;e[f]<h;f++);for(g=e.length;e[g-1]>i;g--);e=e.slice(f,g)}return e},d.tickFormat=function(){return bu};return bl(d,a)},bs.pow=function(a){return Math.pow(10,a)},bt.pow=function(a){return-Math.pow(10,-a)},d3.scale.pow=function(){function e(b){return a(c(b))}var a=d3.scale.linear(),b=1,c=Number,d=c;e.invert=function(b){return d(a.invert(b))},e.domain=function(f){if(!arguments.length)return a.domain().map(d);c=bv(b),d=bv(1/b),a.domain(f.map(c));return e},e.ticks=function(a){return bo(e.domain(),a)},e.tickFormat=function(a){return bp(e.domain(),a)},e.nice=function(){return e.domain(bj(e.domain(),bm))},e.exponent=function(a){if(!arguments.length)return b;var c=e.domain();b=a;return e.domain(c)};return bl(e,a)},d3.scale.sqrt=function(){return d3.scale.pow().exponent(.5)},d3.scale.ordinal=function(){function f(d){var e=d in b?b[d]:b[d]=a.push(d)-1;return c[e%c.length]}var a=[],b={},c=[],d=0,e=bh;f.domain=function(c){if(!arguments.length)return a;a=c,b={};var d=-1,g=-1,h=a.length;while(++d<h)c=a[d],c in b||(b[c]=++g);e();return f},f.range=function(a){if(!arguments.length)return c;c=a,e=bh;return f},f.rangePoints=function(b,g){arguments.length<2&&(g=0),(e=function(){var e=b[0],f=b[1],h=(f-e)/(a.length-1+g);c=a.length==1?[(e+f)/2]:d3.range(e+h*g/2,f+h/2,h),d=0})();return f},f.rangeBands=function(b,g){arguments.length<2&&(g=0),(e=function(){var e=b[0],f=b[1],h=(f-e)/(a.length+g);c=d3.range(e+h*g,f,h),d=h*(1-g)})();return f},f.rangeRoundBands=function(b,g){arguments.length<2&&(g=0),(e=function(){var e=b[0],f=b[1],h=f-e,i=Math.floor(h/(a.length+g)),j=h-(a.length-g)*i;c=d3.range(e+Math.round(j/2),f,i),d=Math.round(i*(1-g))})();return f},f.rangeBand=function(){return d};return f},d3.scale.category10=function(){return d3.scale.ordinal().range(bw)},d3.scale.category20=function(){return d3.scale.ordinal().range(bx)},d3.scale.category20b=function(){return d3.scale.ordinal().range(by)},d3.scale.category20c=function(){return d3.scale.ordinal().range(bz)};var bw=["#1f77b4","#ff7f0e","#2ca02c","#d62728","#9467bd","#8c564b","#e377c2","#7f7f7f","#bcbd22","#17becf"],bx=["#1f77b4","#aec7e8","#ff7f0e","#ffbb78","#2ca02c","#98df8a","#d62728","#ff9896","#9467bd","#c5b0d5","#8c564b","#c49c94","#e377c2","#f7b6d2","#7f7f7f","#c7c7c7","#bcbd22","#dbdb8d","#17becf","#9edae5"],by=["#393b79","#5254a3","#6b6ecf","#9c9ede","#637939","#8ca252","#b5cf6b","#cedb9c","#8c6d31","#bd9e39","#e7ba52","#e7cb94","#843c39","#ad494a","#d6616b","#e7969c","#7b4173","#a55194","#ce6dbd","#de9ed6"],bz=["#3182bd","#6baed6","#9ecae1","#c6dbef","#e6550d","#fd8d3c","#fdae6b","#fdd0a2","#31a354","#74c476","#a1d99b","#c7e9c0","#756bb1","#9e9ac8","#bcbddc","#dadaeb","#636363","#969696","#bdbdbd","#d9d9d9"];d3.scale.quantile=function(){function e(a){if(isNaN(a=+a))return NaN;return b[d3.bisect(c,a)]}function d(){var d=0,e=a.length,f=b.length;c.length=Math.max(0,f-1);while(++d<f)c[d-1]=d3.quantile(a,d/f)}var a=[],b=[],c=[];e.domain=function(b){if(!arguments.length)return a;a=b.filter(function(a){return!isNaN(a)}).sort(d3.ascending),d();return e},e.range=function(a){if(!arguments.length)return b;b=a,d();return e},e.quantiles=function(){return c};return e},d3.scale.quantize=function(){function f(b){return e[Math.max(0,Math.min(d,Math.floor(c*(b-a))))]}var a=0,b=1,c=2,d=1,e=[0,1];f.domain=function(d){if(!arguments.length)return[a,b];a=d[0],b=d[1],c=e.length/(b-a);return f},f.range=function(g){if(!arguments.length)return e;e=g,c=e.length/(b-a),d=e.length-1;return f};return f},d3.svg={},d3.svg.arc=function(){function e(){var e=a.apply(this,arguments),f=b.apply(this,arguments),g=c.apply(this,arguments)+bA,h=d.apply(this,arguments)+bA,i=h-g,j=i<Math.PI?"0":"1",k=Math.cos(g),l=Math.sin(g),m=Math.cos(h),n=Math.sin(h);return i>=bB?e?"M0,"+f+"A"+f+","+f+" 0 1,1 0,"+ -f+"A"+f+","+f+" 0 1,1 0,"+f+"M0,"+e+"A"+e+","+e+" 0 1,1 0,"+ -e+"A"+e+","+e+" 0 1,1 0,"+e+"Z":"M0,"+f+"A"+f+","+f+" 0 1,1 0,"+ -f+"A"+f+","+f+" 0 1,1 0,"+f+"Z":e?"M"+f*k+","+f*l+"A"+f+","+f+" 0 "+j+",1 "+f*m+","+f*n+"L"+e*m+","+e*n+"A"+e+","+e+" 0 "+j+",0 "+e*k+","+e*l+"Z":"M"+f*k+","+f*l+"A"+f+","+f+" 0 "+j+",1 "+f*m+","+f*n+"L0,0"+"Z"}var a=bC,b=bD,c=bE,d=bF;e.innerRadius=function(b){if(!arguments.length)return a;a=d3.functor(b);return e},e.outerRadius=function(a){if(!arguments.length)return b;b=d3.functor(a);return e},e.startAngle=function(a){if(!arguments.length)return c;c=d3.functor(a);return e},e.endAngle=function(a){if(!arguments.length)return d;d=d3.functor(a);return e},e.centroid=function(){var e=(a.apply(this,arguments)+b.apply(this,arguments))/2,f=(c.apply(this,arguments)+d.apply(this,arguments))/2+bA;return[Math.cos(f)*e,Math.sin(f)*e]};return e};var bA=-Math.PI/2,bB=2*Math.PI-1e-6;d3.svg.line=function(){return bG(Object)};var bK={linear:bL,"step-before":bM,"step-after":bN,basis:bT,"basis-open":bU,"basis-closed":bV,bundle:bW,cardinal:bQ,"cardinal-open":bO,"cardinal-closed":bP,monotone:cd},bY=[0,2/3,1/3,0],bZ=[0,1/3,2/3,0],b$=[0,1/6,2/3,1/6];d3.svg.line.radial=function(){var a=bG(ce);a.radius=a.x,delete a.x,a.angle=a.y,delete a.y;return a},d3.svg.area=function(){return cf(Object)},d3.svg.area.radial=function(){var a=cf(ce);a.radius=a.x,delete a.x,a.innerRadius=a.x0,delete a.x0,a.outerRadius=a.x1,delete a.x1,a.angle=a.y,delete a.y,a.startAngle=a.y0,delete a.y0,a.endAngle=a.y1,delete a.y1;return a},d3.svg.chord=function(){function j(a,b,c,d){return"Q 0,0 "+d}function i(a,b){return"A"+a+","+a+" 0 0,1 "+b}function h(a,b){return a.a0==b.a0&&a.a1==b.a1}function g(a,b,f,g){var h=b.call(a,f,g),i=c.call(a,h,g),j=d.call(a,h,g)+bA,k=e.call(a,h,g)+bA;return{r:i,a0:j,a1:k,p0:[i*Math.cos(j),i*Math.sin(j)],p1:[i*Math.cos(k),i*Math.sin(k)]}}function f(c,d){var e=g(this,a,c,d),f=g(this,b,c,d);return"M"+e.p0+i(e.r,e.p1)+(h(e,f)?j(e.r,e.p1,e.r,e.p0):j(e.r,e.p1,f.r,f.p0)+i(f.r,f.p1)+j(f.r,f.p1,e.r,e.p0))+"Z"}var a=ci,b=cj,c=ck,d=bE,e=bF;f.radius=function(a){if(!arguments.length)return c;c=d3.functor(a);return f},f.source=function(b){if(!arguments.length)return a;a=d3.functor(b);return f},f.target=function(a){if(!arguments.length)return b;b=d3.functor(a);return f},f.startAngle=function(a){if(!arguments.length)return d;d=d3.functor(a);return f},f.endAngle=function(a){if(!arguments.length)return e;e=d3.functor(a);return f};return f},d3.svg.diagonal=function(){function d(d,e){var f=a.call(this,d,e),g=b.call(this,d,e),h=(f.y+g.y)/2,i=[f,{x:f.x,y:h},{x:g.x,y:h},g];i=i.map(c);return"M"+i[0]+"C"+i[1]+" "+i[2]+" "+i[3]}var a=ci,b=cj,c=cn;d.source=function(b){if(!arguments.length)return a;a=d3.functor(b);return d},d.target=function(a){if(!arguments.length)return b;b=d3.functor(a);return d},d.projection=function(a){if(!arguments.length)return c;c=a;return d};return d},d3.svg.diagonal.radial=function(){var a=d3.svg.diagonal(),b=cn,c=a.projection;a.projection=function(a){return arguments.length?c(co(b=a)):b};return a},d3.svg.mouse=function(a){return cq(a,d3.event)};var cp=/WebKit/.test(navigator.userAgent)?-1:0;d3.svg.touches=function(b){var c=d3.event.touches;return c?a(c).map(function(a){var c=cq(b,a);c.identifier=a.identifier;return c}):[]},d3.svg.symbol=function(){function c(c,d){return(ct[a.call(this,c,d)]||ct.circle)(b.call(this,c,d))}var a=cs,b=cr;c.type=function(b){if(!arguments.length)return a;a=d3.functor(b);return c},c.size=function(a){if(!arguments.length)return b;b=d3.functor(a);return c};return c};var ct={circle:function(a){var b=Math.sqrt(a/Math.PI);return"M0,"+b+"A"+b+","+b+" 0 1,1 0,"+ -b+"A"+b+","+b+" 0 1,1 0,"+b+"Z"},cross:function(a){var b=Math.sqrt(a/5)/2;return"M"+ -3*b+","+ -b+"H"+ -b+"V"+ -3*b+"H"+b+"V"+ -b+"H"+3*b+"V"+b+"H"+b+"V"+3*b+"H"+ -b+"V"+b+"H"+ -3*b+"Z"},diamond:function(a){var b=Math.sqrt(a/(2*cv)),c=b*cv;return"M0,"+ -b+"L"+c+",0"+" 0,"+b+" "+ -c+",0"+"Z"},square:function(a){var b=Math.sqrt(a)/2;return"M"+ -b+","+ -b+"L"+b+","+ -b+" "+b+","+b+" "+ -b+","+b+"Z"},"triangle-down":function(a){var b=Math.sqrt(a/cu),c=b*cu/2;return"M0,"+c+"L"+b+","+ -c+" "+ -b+","+ -c+"Z"},"triangle-up":function(a){var b=Math.sqrt(a/cu),c=b*cu/2;return"M0,"+ -c+"L"+b+","+c+" "+ -b+","+c+"Z"}};d3.svg.symbolTypes=d3.keys(ct);var cu=Math.sqrt(3),cv=Math.tan(30*Math.PI/180)})()
<ide>\ No newline at end of file
<add>b=="string"?U.selectAll(b):V([a(b)])},d3.transition=U.transition;var Z=0,$=0,bb=null,bc,bd;d3.timer=function(a,b){var c=Date.now(),d=!1,e,f=bb;if(arguments.length<2)b=0;else if(!isFinite(b))return;while(f){if(f.callback===a){f.then=c,f.delay=b,d=!0;break}e=f,f=f.next}d||(bb={callback:a,then:c,delay:b,next:bb}),bc||(bd=clearTimeout(bd),bc=1,bg(be))},d3.timer.flush=function(){var a,b=Date.now(),c=bb;while(c)a=b-c.then,c.delay||(c.flush=c.callback(a)),c=c.next;bf()};var bg=window.requestAnimationFrame||window.webkitRequestAnimationFrame||window.mozRequestAnimationFrame||window.oRequestAnimationFrame||window.msRequestAnimationFrame||function(a){setTimeout(a,17)};d3.scale={},d3.scale.linear=function(){function h(a){return e(a)}function g(){var g=a.length==2?bq:br,i=d?G:F;e=g(a,b,i,c),f=g(b,a,i,d3.interpolate);return h}var a=[0,1],b=[0,1],c=d3.interpolate,d=!1,e,f;h.invert=function(a){return f(a)},h.domain=function(b){if(!arguments.length)return a;a=b.map(Number);return g()},h.range=function(a){if(!arguments.length)return b;b=a;return g()},h.rangeRound=function(a){return h.range(a).interpolate(d3.interpolateRound)},h.clamp=function(a){if(!arguments.length)return d;d=a;return g()},h.interpolate=function(a){if(!arguments.length)return c;c=a;return g()},h.ticks=function(b){return bo(a,b)},h.tickFormat=function(b){return bp(a,b)},h.nice=function(){bj(a,bm);return g()};return g()},d3.scale.log=function(){function d(c){return a(b(c))}var a=d3.scale.linear(),b=bs,c=b.pow;d.invert=function(b){return c(a.invert(b))},d.domain=function(e){if(!arguments.length)return a.domain().map(c);b=e[0]<0?bt:bs,c=b.pow,a.domain(e.map(b));return d},d.nice=function(){a.domain(bj(a.domain(),bk));return d},d.ticks=function(){var d=bi(a.domain()),e=[];if(d.every(isFinite)){var f=Math.floor(d[0]),g=Math.ceil(d[1]),h=c(d[0]),i=c(d[1]);if(b===bt){e.push(c(f));for(;f++<g;)for(var j=9;j>0;j--)e.push(c(f)*j)}else{for(;f<g;f++)for(var j=1;j<10;j++)e.push(c(f)*j);e.push(c(f))}for(f=0;e[f]<h;f++);for(g=e.length;e[g-1]>i;g--);e=e.slice(f,g)}return e},d.tickFormat=function(){return bu};return bl(d,a)},bs.pow=function(a){return Math.pow(10,a)},bt.pow=function(a){return-Math.pow(10,-a)},d3.scale.pow=function(){function e(b){return a(c(b))}var a=d3.scale.linear(),b=1,c=Number,d=c;e.invert=function(b){return d(a.invert(b))},e.domain=function(f){if(!arguments.length)return a.domain().map(d);c=bv(b),d=bv(1/b),a.domain(f.map(c));return e},e.ticks=function(a){return bo(e.domain(),a)},e.tickFormat=function(a){return bp(e.domain(),a)},e.nice=function(){return e.domain(bj(e.domain(),bm))},e.exponent=function(a){if(!arguments.length)return b;var c=e.domain();b=a;return e.domain(c)};return bl(e,a)},d3.scale.sqrt=function(){return d3.scale.pow().exponent(.5)},d3.scale.ordinal=function(){function f(d){var e=d in b?b[d]:b[d]=a.push(d)-1;return c[e%c.length]}var a=[],b={},c=[],d=0,e=bh;f.domain=function(c){if(!arguments.length)return a;a=c,b={};var d=-1,g=-1,h=a.length;while(++d<h)c=a[d],c in b||(b[c]=++g);e();return f},f.range=function(a){if(!arguments.length)return c;c=a,e=bh;return f},f.rangePoints=function(b,g){arguments.length<2&&(g=0),(e=function(){var e=b[0],f=b[1],h=(f-e)/(a.length-1+g);c=a.length==1?[(e+f)/2]:d3.range(e+h*g/2,f+h/2,h),d=0})();return f},f.rangeBands=function(b,g){arguments.length<2&&(g=0),(e=function(){var e=b[0],f=b[1],h=(f-e)/(a.length+g);c=d3.range(e+h*g,f,h),d=h*(1-g)})();return f},f.rangeRoundBands=function(b,g){arguments.length<2&&(g=0),(e=function(){var e=b[0],f=b[1],h=f-e,i=Math.floor(h/(a.length+g)),j=h-(a.length-g)*i;c=d3.range(e+Math.round(j/2),f,i),d=Math.round(i*(1-g))})();return f},f.rangeBand=function(){return d};return f},d3.scale.category10=function(){return d3.scale.ordinal().range(bw)},d3.scale.category20=function(){return d3.scale.ordinal().range(bx)},d3.scale.category20b=function(){return d3.scale.ordinal().range(by)},d3.scale.category20c=function(){return d3.scale.ordinal().range(bz)};var bw=["#1f77b4","#ff7f0e","#2ca02c","#d62728","#9467bd","#8c564b","#e377c2","#7f7f7f","#bcbd22","#17becf"],bx=["#1f77b4","#aec7e8","#ff7f0e","#ffbb78","#2ca02c","#98df8a","#d62728","#ff9896","#9467bd","#c5b0d5","#8c564b","#c49c94","#e377c2","#f7b6d2","#7f7f7f","#c7c7c7","#bcbd22","#dbdb8d","#17becf","#9edae5"],by=["#393b79","#5254a3","#6b6ecf","#9c9ede","#637939","#8ca252","#b5cf6b","#cedb9c","#8c6d31","#bd9e39","#e7ba52","#e7cb94","#843c39","#ad494a","#d6616b","#e7969c","#7b4173","#a55194","#ce6dbd","#de9ed6"],bz=["#3182bd","#6baed6","#9ecae1","#c6dbef","#e6550d","#fd8d3c","#fdae6b","#fdd0a2","#31a354","#74c476","#a1d99b","#c7e9c0","#756bb1","#9e9ac8","#bcbddc","#dadaeb","#636363","#969696","#bdbdbd","#d9d9d9"];d3.scale.quantile=function(){function e(a){if(isNaN(a=+a))return NaN;return b[d3.bisect(c,a)]}function d(){var d=0,e=a.length,f=b.length;c.length=Math.max(0,f-1);while(++d<f)c[d-1]=d3.quantile(a,d/f)}var a=[],b=[],c=[];e.domain=function(b){if(!arguments.length)return a;a=b.filter(function(a){return!isNaN(a)}).sort(d3.ascending),d();return e},e.range=function(a){if(!arguments.length)return b;b=a,d();return e},e.quantiles=function(){return c};return e},d3.scale.quantize=function(){function f(b){return e[Math.max(0,Math.min(d,Math.floor(c*(b-a))))]}var a=0,b=1,c=2,d=1,e=[0,1];f.domain=function(d){if(!arguments.length)return[a,b];a=+d[0],b=+d[d.length-1],c=e.length/(b-a);return f},f.range=function(g){if(!arguments.length)return e;e=g,c=e.length/(b-a),d=e.length-1;return f};return f},d3.svg={},d3.svg.arc=function(){function e(){var e=a.apply(this,arguments),f=b.apply(this,arguments),g=c.apply(this,arguments)+bA,h=d.apply(this,arguments)+bA,i=h-g,j=i<Math.PI?"0":"1",k=Math.cos(g),l=Math.sin(g),m=Math.cos(h),n=Math.sin(h);return i>=bB?e?"M0,"+f+"A"+f+","+f+" 0 1,1 0,"+ -f+"A"+f+","+f+" 0 1,1 0,"+f+"M0,"+e+"A"+e+","+e+" 0 1,1 0,"+ -e+"A"+e+","+e+" 0 1,1 0,"+e+"Z":"M0,"+f+"A"+f+","+f+" 0 1,1 0,"+ -f+"A"+f+","+f+" 0 1,1 0,"+f+"Z":e?"M"+f*k+","+f*l+"A"+f+","+f+" 0 "+j+",1 "+f*m+","+f*n+"L"+e*m+","+e*n+"A"+e+","+e+" 0 "+j+",0 "+e*k+","+e*l+"Z":"M"+f*k+","+f*l+"A"+f+","+f+" 0 "+j+",1 "+f*m+","+f*n+"L0,0"+"Z"}var a=bC,b=bD,c=bE,d=bF;e.innerRadius=function(b){if(!arguments.length)return a;a=d3.functor(b);return e},e.outerRadius=function(a){if(!arguments.length)return b;b=d3.functor(a);return e},e.startAngle=function(a){if(!arguments.length)return c;c=d3.functor(a);return e},e.endAngle=function(a){if(!arguments.length)return d;d=d3.functor(a);return e},e.centroid=function(){var e=(a.apply(this,arguments)+b.apply(this,arguments))/2,f=(c.apply(this,arguments)+d.apply(this,arguments))/2+bA;return[Math.cos(f)*e,Math.sin(f)*e]};return e};var bA=-Math.PI/2,bB=2*Math.PI-1e-6;d3.svg.line=function(){return bG(Object)};var bK={linear:bL,"step-before":bM,"step-after":bN,basis:bT,"basis-open":bU,"basis-closed":bV,bundle:bW,cardinal:bQ,"cardinal-open":bO,"cardinal-closed":bP,monotone:cd},bY=[0,2/3,1/3,0],bZ=[0,1/3,2/3,0],b$=[0,1/6,2/3,1/6];d3.svg.line.radial=function(){var a=bG(ce);a.radius=a.x,delete a.x,a.angle=a.y,delete a.y;return a},d3.svg.area=function(){return cf(Object)},d3.svg.area.radial=function(){var a=cf(ce);a.radius=a.x,delete a.x,a.innerRadius=a.x0,delete a.x0,a.outerRadius=a.x1,delete a.x1,a.angle=a.y,delete a.y,a.startAngle=a.y0,delete a.y0,a.endAngle=a.y1,delete a.y1;return a},d3.svg.chord=function(){function j(a,b,c,d){return"Q 0,0 "+d}function i(a,b){return"A"+a+","+a+" 0 0,1 "+b}function h(a,b){return a.a0==b.a0&&a.a1==b.a1}function g(a,b,f,g){var h=b.call(a,f,g),i=c.call(a,h,g),j=d.call(a,h,g)+bA,k=e.call(a,h,g)+bA;return{r:i,a0:j,a1:k,p0:[i*Math.cos(j),i*Math.sin(j)],p1:[i*Math.cos(k),i*Math.sin(k)]}}function f(c,d){var e=g(this,a,c,d),f=g(this,b,c,d);return"M"+e.p0+i(e.r,e.p1)+(h(e,f)?j(e.r,e.p1,e.r,e.p0):j(e.r,e.p1,f.r,f.p0)+i(f.r,f.p1)+j(f.r,f.p1,e.r,e.p0))+"Z"}var a=ci,b=cj,c=ck,d=bE,e=bF;f.radius=function(a){if(!arguments.length)return c;c=d3.functor(a);return f},f.source=function(b){if(!arguments.length)return a;a=d3.functor(b);return f},f.target=function(a){if(!arguments.length)return b;b=d3.functor(a);return f},f.startAngle=function(a){if(!arguments.length)return d;d=d3.functor(a);return f},f.endAngle=function(a){if(!arguments.length)return e;e=d3.functor(a);return f};return f},d3.svg.diagonal=function(){function d(d,e){var f=a.call(this,d,e),g=b.call(this,d,e),h=(f.y+g.y)/2,i=[f,{x:f.x,y:h},{x:g.x,y:h},g];i=i.map(c);return"M"+i[0]+"C"+i[1]+" "+i[2]+" "+i[3]}var a=ci,b=cj,c=cn;d.source=function(b){if(!arguments.length)return a;a=d3.functor(b);return d},d.target=function(a){if(!arguments.length)return b;b=d3.functor(a);return d},d.projection=function(a){if(!arguments.length)return c;c=a;return d};return d},d3.svg.diagonal.radial=function(){var a=d3.svg.diagonal(),b=cn,c=a.projection;a.projection=function(a){return arguments.length?c(co(b=a)):b};return a},d3.svg.mouse=function(a){return cq(a,d3.event)};var cp=/WebKit/.test(navigator.userAgent)?-1:0;d3.svg.touches=function(b){var c=d3.event.touches;return c?a(c).map(function(a){var c=cq(b,a);c.identifier=a.identifier;return c}):[]},d3.svg.symbol=function(){function c(c,d){return(ct[a.call(this,c,d)]||ct.circle)(b.call(this,c,d))}var a=cs,b=cr;c.type=function(b){if(!arguments.length)return a;a=d3.functor(b);return c},c.size=function(a){if(!arguments.length)return b;b=d3.functor(a);return c};return c};var ct={circle:function(a){var b=Math.sqrt(a/Math.PI);return"M0,"+b+"A"+b+","+b+" 0 1,1 0,"+ -b+"A"+b+","+b+" 0 1,1 0,"+b+"Z"},cross:function(a){var b=Math.sqrt(a/5)/2;return"M"+ -3*b+","+ -b+"H"+ -b+"V"+ -3*b+"H"+b+"V"+ -b+"H"+3*b+"V"+b+"H"+b+"V"+3*b+"H"+ -b+"V"+b+"H"+ -3*b+"Z"},diamond:function(a){var b=Math.sqrt(a/(2*cv)),c=b*cv;return"M0,"+ -b+"L"+c+",0"+" 0,"+b+" "+ -c+",0"+"Z"},square:function(a){var b=Math.sqrt(a)/2;return"M"+ -b+","+ -b+"L"+b+","+ -b+" "+b+","+b+" "+ -b+","+b+"Z"},"triangle-down":function(a){var b=Math.sqrt(a/cu),c=b*cu/2;return"M0,"+c+"L"+b+","+ -c+" "+ -b+","+ -c+"Z"},"triangle-up":function(a){var b=Math.sqrt(a/cu),c=b*cu/2;return"M0,"+ -c+"L"+b+","+c+" "+ -b+","+c+"Z"}};d3.svg.symbolTypes=d3.keys(ct);var cu=Math.sqrt(3),cv=Math.tan(30*Math.PI/180)})()
<ide>\ No newline at end of file
<ide><path>src/scale/quantize.js
<ide> d3.scale.quantize = function() {
<ide>
<ide> scale.domain = function(x) {
<ide> if (!arguments.length) return [x0, x1];
<del> x0 = x[0];
<del> x1 = x[1];
<add> x0 = +x[0];
<add> x1 = +x[x.length - 1];
<ide> kx = range.length / (x1 - x0);
<ide> return scale;
<ide> };
<ide><path>test/scale/quantize-test.js
<add>require("../env");
<add>require("../../d3");
<add>
<add>var vows = require("vows"),
<add> assert = require("assert");
<add>
<add>var suite = vows.describe("d3.scale.quantize");
<add>
<add>suite.addBatch({
<add> "quantize": {
<add> topic: function() {
<add> return d3.scale.quantize;
<add> },
<add> "has the default domain [0, 1]": function(quantize) {
<add> var x = quantize();
<add> assert.deepEqual(x.domain(), [0, 1]);
<add> assert.equal(x(.25), 0);
<add> },
<add> "has the default range [0, 1]": function(quantize) {
<add> var x = quantize();
<add> assert.deepEqual(x.range(), [0, 1]);
<add> assert.equal(x(.75), 1);
<add> },
<add> "maps a number to a discrete value in the range": function(quantize) {
<add> var x = quantize().range([0, 1, 2]);
<add> assert.equal(x(0), 0);
<add> assert.equal(x(.2), 0);
<add> assert.equal(x(.4), 1);
<add> assert.equal(x(.6), 1);
<add> assert.equal(x(.8), 2);
<add> assert.equal(x(1), 2);
<add> },
<add> "coerces domain to numbers": function(quantize) {
<add> var x = quantize().domain(["0", "100"]);
<add> assert.strictEqual(x.domain()[0], 0);
<add> assert.strictEqual(x.domain()[1], 100);
<add> },
<add> "only considers the extent of the domain": function(quantize) {
<add> var x = quantize().domain([-1, 0, 100]);
<add> assert.deepEqual(x.domain(), [-1, 100]);
<add> },
<add> "clamps input values to the domain": function(quantize) {
<add> var a = {}, b = {}, c = {}, x = quantize().range([a, b, c]);
<add> assert.equal(x(-.5), a);
<add> assert.equal(x(1.5), c);
<add> },
<add> "range cardinality determines the degree of quantization": function(quantize) {
<add> var x = quantize();
<add> assert.inDelta(x.range(d3.range(0, 1.001, .001))(1/3), .333, 1e-6);
<add> assert.inDelta(x.range(d3.range(0, 1.01, .01))(1/3), .33, 1e-6);
<add> assert.inDelta(x.range(d3.range(0, 1.1, .1))(1/3), .3, 1e-6);
<add> assert.inDelta(x.range(d3.range(0, 1.2, .2))(1/3), .4, 1e-6);
<add> assert.inDelta(x.range(d3.range(0, 1.25, .25))(1/3), .25, 1e-6);
<add> assert.inDelta(x.range(d3.range(0, 1.5, .5))(1/3), .5, 1e-6);
<add> assert.inDelta(x.range(d3.range(1))(1/3), 0, 1e-6);
<add> },
<add> "range values are arbitrary": function(quantize) {
<add> var a = {}, b = {}, c = {}, x = quantize().range([a, b, c]);
<add> assert.equal(x(0), a);
<add> assert.equal(x(.2), a);
<add> assert.equal(x(.4), b);
<add> assert.equal(x(.6), b);
<add> assert.equal(x(.8), c);
<add> assert.equal(x(1), c);
<add> }
<add> }
<add>});
<add>
<add>suite.export(module); | 4 |
Javascript | Javascript | use simpler boolean check vs a function call | 4bf1a09522955eb52de1fafb4ee1ecc5982b7a3e | <ide><path>src/attributes/classes.js
<ide> jQuery.fn.extend( {
<ide>
<ide> toggleClass: function( value, stateVal ) {
<ide> var type = typeof value,
<del> classNames = type === "string" ? value.match( rnotwhite ) : "",
<del> checker = typeof stateVal === "boolean" ?
<del> function() { return !stateVal; } :
<del> jQuery.fn.hasClass;
<add> classNames = type === "string" ? value.match( rnotwhite ) : [];
<ide>
<ide> return this.each( function( i ) {
<ide> var className,
<ide> jQuery.fn.extend( {
<ide> // Toggle individual class names based on presence or stateVal
<ide> while ( ( className = classNames[ c++ ] ) ) {
<ide>
<del> if ( checker.call( self, className ) ) {
<add> if ( stateVal === false || stateVal !== true && self.hasClass( className ) ) {
<ide> self.removeClass( className );
<ide> } else {
<ide> self.addClass( className );
<ide><path>test/unit/attributes.js
<ide> QUnit.test( "removeClass(undefined) is a no-op", function( assert ) {
<ide> } );
<ide>
<ide> var testToggleClass = function( valueObj, assert ) {
<del> assert.expect( 9 );
<add> assert.expect( 11 );
<ide>
<ide> var e = jQuery( "#firstp" );
<ide> assert.ok( !e.is( ".test" ), "Assert class not present" );
<ide> var testToggleClass = function( valueObj, assert ) {
<ide> // class name with a boolean
<ide> e.toggleClass( valueObj( "test" ), false );
<ide> assert.ok( !e.is( ".test" ), "Assert class not present" );
<add> e.toggleClass( valueObj( "test" ), false );
<add> assert.ok( !e.is( ".test" ), "Assert class still not present" );
<ide> e.toggleClass( valueObj( "test" ), true );
<ide> assert.ok( e.is( ".test" ), "Assert class present" );
<add> e.toggleClass( valueObj( "test" ), true );
<add> assert.ok( e.is( ".test" ), "Assert class still present" );
<ide> e.toggleClass( valueObj( "test" ), false );
<ide> assert.ok( !e.is( ".test" ), "Assert class not present" );
<ide> | 2 |
Text | Text | add line breaks & indentation | c1531cd7b349dadd58e5ebb463ba2224570bb17b | <ide><path>docs/Analytics.md
<ide> Homebrew gathers anonymous aggregate user behaviour analytics using Google Analytics. You will be notified the first time you run `brew update` or install Homebrew. Analytics are not enabled until after this notice is shown, to ensure that you can [opt out](Analytics.md#opting-out) without ever sending analytics data.
<ide>
<ide> ## Why?
<add>
<ide> Homebrew is provided free of charge and run entirely by volunteers in their spare time. As a result, we do not have the resources to do detailed user studies of Homebrew users to decide on how best to design future features and prioritise current work. Anonymous aggregate user analytics allow us to prioritise fixes and features based on how, where and when people use Homebrew. For example:
<ide>
<ide> - If a formula is widely used and is failing often it will enable us to prioritise fixing that formula over others.
<ide> - Collecting the OS version allows us to decide what versions of macOS to prioritise and support and identify build failures that occur only on single versions.
<ide>
<ide> ## How Long?
<add>
<ide> Homebrew's anonymous user and event data have a 14 month retention period. This is the [lowest possible value for Google Analytics](https://support.google.com/analytics/answer/7667196).
<ide>
<ide> ## What?
<add>
<ide> Homebrew's analytics record some shared information for every event:
<ide>
<ide> - The Homebrew user agent, e.g. `Homebrew/2.5.0 (Macintosh; Intel Mac OS X 10.15.6) curl/7.64.1`.
<ide> It is impossible for the Homebrew developers to match any particular event to an
<ide> As far as we can tell it would be impossible for Google to match the randomly generated Homebrew-only analytics user ID to any other Google Analytics user ID. If Google turned evil the only thing they could do would be to lie about anonymising IP addresses and attempt to match users based on IP addresses.
<ide>
<ide> ## When/Where?
<add>
<ide> Homebrew's analytics are sent throughout Homebrew's execution to Google Analytics over HTTPS.
<ide>
<ide> ## Who?
<add>
<ide> Summaries of installation and error analytics are publicly available [here](https://brew.sh/analytics/). A JSON API is also available. The majority of Homebrew maintainers are not granted more detailed analytics data beyond these public resources.
<ide>
<ide> ## How?
<add>
<ide> The code is viewable in [`analytics.rb`](https://github.com/Homebrew/brew/blob/HEAD/Library/Homebrew/utils/analytics.rb) and [`analytics.sh`](https://github.com/Homebrew/brew/blob/HEAD/Library/Homebrew/utils/analytics.sh). They are done in a separate background process and fail fast to avoid delaying any execution. They will fail immediately and silently if you have no network connection.
<ide>
<ide> ## Opting out
<add>
<ide> Homebrew analytics helps us maintainers and leaving it on is appreciated. However, if you want to opt out of Homebrew's analytics, you can set this variable in your environment:
<ide>
<ide> ```sh
<ide><path>docs/Bottles.md
<ide> Bottles are produced by installing a formula with `brew install --build-bottle <formula>` and then bottling it with `brew bottle <formula>`. This outputs the bottle DSL which should be inserted into the formula file.
<ide>
<ide> ## Usage
<add>
<ide> If a bottle is available and usable it will be downloaded and poured automatically when you `brew install <formula>`. If you wish to disable this you can do so by specifying `--build-from-source`.
<ide>
<ide> Bottles will not be used if the user requests it (see above), if the formula requests it (with `pour_bottle?`), if any options are specified during installation (bottles are all compiled with default options), if the bottle is not up to date (e.g. lacking a checksum) or if the bottle's `cellar` is not `:any` nor equal to the current `HOMEBREW_CELLAR`.
<ide>
<ide> ## Creation
<add>
<ide> Bottles are created using the [Brew Test Bot](Brew-Test-Bot.md), usually when people submit pull requests to Homebrew. The `bottle do` block is updated by maintainers when they merge a pull request. For the Homebrew organisations' taps they are uploaded to and downloaded from [GitHub Packages](https://github.com/orgs/Homebrew/packages).
<ide>
<ide> By default, bottles will be built for the oldest CPU supported by the OS/architecture you're building for (Core 2 for 64-bit OSs). This ensures that bottles are compatible with all computers you might distribute them to. If you *really* want your bottles to be optimised for something else, you can pass the `--bottle-arch=` option to build for another architecture; for example, `brew install foo --build-bottle --bottle-arch=penryn`. Just remember that if you build for a newer architecture some of your users might get binaries they can't run and that would be sad!
<ide>
<ide> ## Format
<add>
<ide> Bottles are simple gzipped tarballs of compiled binaries. Any metadata is stored in a formula's bottle DSL and in the bottle filename (i.e. macOS version, revision).
<ide>
<ide> ## Bottle DSL (Domain Specific Language)
<add>
<ide> Bottles have a DSL to be used in formulae which is contained in the `bottle do ... end` block.
<ide>
<ide> A simple (and typical) example:
<ide> end
<ide> ```
<ide>
<ide> ### Root URL (`root_url`)
<add>
<ide> Optionally contains the URL root used to calculate bottle URLs.
<add>
<ide> By default this is omitted and the Homebrew default bottle URL root is used. This may be useful for taps which wish to provide bottles for their formulae or to cater for a non-default `HOMEBREW_CELLAR`.
<ide>
<ide> ### Cellar (`cellar`)
<add>
<ide> Optionally contains the value of `HOMEBREW_CELLAR` in which the bottles were built.
<add>
<ide> Most compiled software contains references to its compiled location so cannot be simply relocated anywhere on disk. If this value is `:any` or `:any_skip_relocation` this means that the bottle can be safely installed in any Cellar as it did not contain any references to its installation Cellar. This can be omitted if a bottle is compiled (as all default Homebrew ones are) for the default `HOMEBREW_CELLAR`.
<ide>
<ide> ### Rebuild version (`rebuild`)
<add>
<ide> Optionally contains the rebuild version of the bottle.
<add>
<ide> Sometimes bottles may need be updated without bumping the version of the formula, e.g. a new patch was applied. In that case the rebuild will have a value of 1 or more.
<ide>
<ide> ### Checksum (`sha256`)
<add>
<ide> Contains the SHA-256 hash of a bottle for a particular version of macOS.
<ide>
<ide> ## Formula DSL
<add>
<ide> An additional method is available in the formula DSL.
<ide>
<ide> ### Pour bottle (`pour_bottle?`)
<add>
<ide> Optionally returns a boolean to decide whether a bottle should be used for this formula.
<add>
<ide> For example a bottle may break if another formula has been compiled with non-default options, so this method could check for that case and return `false`.
<ide>
<ide> A full example:
<ide><path>docs/Interesting-Taps-and-Forks.md
<ide> # Interesting Taps & Forks
<ide>
<ide> A [tap](Taps.md) is Homebrew-speak for a Git repository containing extra formulae.
<add>
<ide> Homebrew has the capability to add (and remove) multiple taps to your local installation with the `brew tap` and `brew untap` commands. Type `man brew` in your terminal. The main repository at <https://github.com/Homebrew/homebrew-core>, often called `homebrew/core`, is always built-in.
<ide>
<ide> Your taps are Git repositories located at `$(brew --repository)/Library/Taps`.
<ide>
<ide> ## Unsupported interesting taps
<del>* [homebrew-ffmpeg/ffmpeg](https://github.com/homebrew-ffmpeg/homebrew-ffmpeg): A tap for FFmpeg with additional options, including nonfree additions.
<add>* [homebrew-ffmpeg/ffmpeg](https://github.com/homebrew-ffmpeg/homebrew-ffmpeg): A tap for FFmpeg with additional options, including nonfree additions.
<ide>
<del>* [denji/nginx](https://github.com/denji/homebrew-nginx): A tap for NGINX modules, intended for its `nginx-full` formula which includes more module options.
<add>* [denji/nginx](https://github.com/denji/homebrew-nginx): A tap for NGINX modules, intended for its `nginx-full` formula which includes more module options.
<ide>
<del>* [InstantClientTap/instantclient](https://github.com/InstantClientTap/homebrew-instantclient): A tap for Oracle Instant Client. The packages need to be downloaded manually.
<add>* [InstantClientTap/instantclient](https://github.com/InstantClientTap/homebrew-instantclient): A tap for Oracle Instant Client. The packages need to be downloaded manually.
<ide>
<del>* [osx-cross/avr](https://github.com/osx-cross/homebrew-avr): GNU AVR toolchain (Libc, compilers and other tools for Atmel MCUs, useful for Arduino hackers and AVR programmers).
<add>* [osx-cross/avr](https://github.com/osx-cross/homebrew-avr): GNU AVR toolchain (Libc, compilers and other tools for Atmel MCUs, useful for Arduino hackers and AVR programmers).
<ide>
<del>* [petere/postgresql](https://github.com/petere/homebrew-postgresql): Allows installing multiple PostgreSQL versions in parallel.
<add>* [petere/postgresql](https://github.com/petere/homebrew-postgresql): Allows installing multiple PostgreSQL versions in parallel.
<ide>
<del>* [osrf/simulation](https://github.com/osrf/homebrew-simulation): Tools for robotics simulation.
<add>* [osrf/simulation](https://github.com/osrf/homebrew-simulation): Tools for robotics simulation.
<ide>
<del>* [brewsci/bio](https://github.com/brewsci/homebrew-bio): Bioinformatics formulae.
<add>* [brewsci/bio](https://github.com/brewsci/homebrew-bio): Bioinformatics formulae.
<ide>
<del>* [davidchall/hep](https://github.com/davidchall/homebrew-hep): High energy physics formulae.
<add>* [davidchall/hep](https://github.com/davidchall/homebrew-hep): High energy physics formulae.
<ide>
<del>* [lifepillar/appleii](https://github.com/lifepillar/homebrew-appleii): Formulae for vintage Apple emulation.
<add>* [lifepillar/appleii](https://github.com/lifepillar/homebrew-appleii): Formulae for vintage Apple emulation.
<ide>
<del>* [gromgit/fuse](https://github.com/gromgit/homebrew-fuse): macOS FUSE formulae that are no longer available in `homebrew/core`.
<add>* [gromgit/fuse](https://github.com/gromgit/homebrew-fuse): macOS FUSE formulae that are no longer available in `homebrew/core`.
<ide>
<ide> ## Unsupported interesting forks
<ide>
<del>* [mistydemeo/tigerbrew](https://github.com/mistydemeo/tigerbrew): Experimental Tiger PowerPC version.
<add>* [mistydemeo/tigerbrew](https://github.com/mistydemeo/tigerbrew): Experimental Tiger PowerPC version.
<ide><path>docs/Taps.md
<ide> but the command isn't limited to any one location.
<ide> * `brew tap` without arguments lists the currently tapped repositories. For
<ide> example:
<ide>
<del>```sh
<del>$ brew tap
<del>homebrew/core
<del>mistydemeo/tigerbrew
<del>dunn/emacs
<del>```
<add> ```sh
<add> $ brew tap
<add> homebrew/core
<add> mistydemeo/tigerbrew
<add> dunn/emacs
<add> ```
<ide>
<ide> <!-- vale Homebrew.Terms = OFF -->
<ide> <!-- The `terms` lint suggests changing "repo" to "repository". But we need the abbreviation in the tap syntax and URL example. -->
<add>
<ide> * `brew tap <user/repo>` makes a clone of the repository at
<ide> https://github.com/user/homebrew-repo. After that, `brew` will be able to work on
<ide> those formulae as if they were in Homebrew's canonical repository. You can
<ide> install and uninstall them with `brew [un]install`, and the formulae are
<ide> automatically updated when you run `brew update`. (See below for details
<ide> about how `brew tap` handles the names of repositories.)
<add>
<ide> <!-- vale Homebrew.Terms = ON -->
<ide>
<ide> * `brew tap <user/repo> <URL>` makes a clone of the repository at URL.
<ide><path>docs/Tips-N'-Tricks.md
<ide> This can be useful if a package can't build against the version of something you
<ide> And of course, you can simply `brew link <formula>` again afterwards!
<ide>
<ide> ## Pre-downloading a file for a formula
<add>
<ide> Sometimes it's faster to download a file via means other than those
<ide> strategies that are available as part of Homebrew. For example,
<ide> Erlang provides a torrent that'll let you download at 4–5× the normal
<ide> In Sublime Text 2/3, you can use Package Control to install
<ide> which adds highlighting for inline patches.
<ide>
<ide> ### Vim
<add>
<ide> [brew.vim](https://github.com/xu-cheng/brew.vim) adds highlighting to
<ide> inline patches in Vim.
<ide>
<ide> ### Emacs
<add>
<ide> [homebrew-mode](https://github.com/dunn/homebrew-mode) provides syntax
<ide> highlighting for inline patches as well as a number of helper functions
<ide> for editing formula files.
<ide> for editing formula files.
<ide> for emacs shell-mode and eshell-mode.
<ide>
<ide> ### Atom
<add>
<ide> [language-homebrew-formula](https://atom.io/packages/language-homebrew-formula)
<ide> adds highlighting and diff support (with the
<ide> [language-diff](https://atom.io/packages/language-diff) plugin). | 5 |
Text | Text | add default revalidate value to docs | fb7342ac7c8e90f3ac08ff896fa5ad95ddc4d16c | <ide><path>docs/basic-features/data-fetching.md
<ide> The `context` parameter is an object containing the following keys:
<ide> `getStaticProps` should return an object with:
<ide>
<ide> - `props` - An **optional** object with the props that will be received by the page component. It should be a [serializable object](https://en.wikipedia.org/wiki/Serialization)
<del>- `revalidate` - An **optional** amount in seconds after which a page re-generation can occur. More on [Incremental Static Regeneration](#incremental-static-regeneration)
<add>- `revalidate` - An **optional** amount in seconds after which a page re-generation can occur (defaults to: `false` or no revalidating). More on [Incremental Static Regeneration](#incremental-static-regeneration)
<ide> - `notFound` - An **optional** boolean value to allow the page to return a 404 status and page. Below is an example of how it works:
<ide>
<ide> ```js | 1 |
Text | Text | clarify instruction regarding color | 9b6dc9ee34ec3031244e2481f13705be2fc0a2df | <ide><path>curriculum/challenges/english/14-responsive-web-design-22/learn-css-colors-by-building-a-set-of-colored-markers/step-090.md
<ide> dashedName: step-90
<ide>
<ide> Now that you're familiar with the `box-shadow` property you can finalize the shadows, starting with the one for the red marker.
<ide>
<del>In the `.red` CSS rule, update the values for the `box-shadow` property so `offsetX` is `0`,`offsetY` is `0`, `blurRadius` is `20px`, and `spreadRadius` is `0`.
<add>In the `.red` CSS rule, update the values for the `box-shadow` property so `offsetX` is `0`,`offsetY` is `0`, `blurRadius` is `20px`, `spreadRadius` is `0`, and `color` is `red`.
<ide>
<ide> # --hints--
<ide> | 1 |
Javascript | Javascript | replace timeouts in test with compiler done checks | ae0edf3fbb572948597a9da6376e3d49b0d2d18b | <ide><path>test/ChangesAndRemovals.test.js
<ide> const createSingleCompiler = () => {
<ide> });
<ide> };
<ide>
<add>const onceDone = (compiler, action) => {
<add> let initial = true;
<add> compiler.hooks.done.tap("ChangesAndRemovalsTest", () => {
<add> if (!initial) return;
<add> initial = false;
<add> setTimeout(action, 100);
<add> });
<add>};
<add>
<ide> function cleanup() {
<ide> rimraf.sync(tempFolderPath);
<ide> }
<ide> describe("ChangesAndRemovals", () => {
<ide> const compiler = createSingleCompiler();
<ide> let watcher;
<ide>
<del> compiler.hooks.watchRun.tap("ModifiedFilesTest", compiler => {
<add> compiler.hooks.watchRun.tap("ChangesAndRemovalsTest", compiler => {
<ide> if (!compiler.modifiedFiles) return;
<ide> const modifications = Array.from(compiler.modifiedFiles);
<ide> expect(modifications).toContain(tempFilePath);
<ide> describe("ChangesAndRemovals", () => {
<ide> if (err) done(err);
<ide> });
<ide>
<del> setTimeout(() => {
<add> onceDone(compiler, () => {
<ide> fs.appendFileSync(tempFilePath, "\nlet x = 'file modified';");
<del> }, 1000);
<add> });
<ide> });
<ide>
<ide> it("should not track modified files during initial watchRun", done => {
<ide> const compiler = createSingleCompiler();
<ide> let watcher;
<ide> const watchRunFinished = new Promise(resolve => {
<del> compiler.hooks.watchRun.tap("ModifiedFilesTest", compiler => {
<add> compiler.hooks.watchRun.tap("ChangesAndRemovalsTest", compiler => {
<ide> expect(compiler.modifiedFiles).toBe(undefined);
<ide> resolve();
<ide> });
<ide> describe("ChangesAndRemovals", () => {
<ide> const compiler = createSingleCompiler();
<ide> let watcher;
<ide>
<del> compiler.hooks.watchRun.tap("ModifiedFilesTest", compiler => {
<add> compiler.hooks.watchRun.tap("ChangesAndRemovalsTest", compiler => {
<ide> if (!compiler.modifiedFiles) return;
<ide> const modifications = Array.from(compiler.modifiedFiles);
<ide> expect(modifications).toHaveLength(0);
<ide> describe("ChangesAndRemovals", () => {
<ide>
<ide> watcher = compiler.watch({ aggregateTimeout: 50 }, () => {});
<ide>
<del> setTimeout(() => {
<add> onceDone(compiler, () => {
<ide> fs.unlinkSync(tempFilePath);
<del> }, 1000);
<add> });
<ide> });
<ide>
<ide> it("should track removed files when they've been deleted in watchRun", done => {
<ide> const compiler = createSingleCompiler();
<ide> let watcher;
<ide>
<del> compiler.hooks.watchRun.tap("RemovedFilesTest", compiler => {
<add> compiler.hooks.watchRun.tap("ChangesAndRemovalsTest", compiler => {
<ide> if (!compiler.removedFiles) return;
<ide> const removals = Array.from(compiler.removedFiles);
<ide> expect(removals).toContain(tempFilePath);
<ide> describe("ChangesAndRemovals", () => {
<ide>
<ide> watcher = compiler.watch({ aggregateTimeout: 50 }, () => {});
<ide>
<del> setTimeout(() => {
<add> onceDone(compiler, () => {
<ide> fs.unlinkSync(tempFilePath);
<del> }, 1000);
<add> });
<ide> });
<ide>
<ide> it("should not track removed files during initial watchRun", done => {
<ide> const compiler = createSingleCompiler();
<ide> let watcher;
<ide>
<ide> const watchRunFinished = new Promise(resolve => {
<del> compiler.hooks.watchRun.tap("RemovedFilesTest", compiler => {
<add> compiler.hooks.watchRun.tap("ChangesAndRemovalsTest", compiler => {
<ide> expect(compiler.removedFiles).toBe(undefined);
<ide> resolve();
<ide> });
<ide> describe("ChangesAndRemovals", () => {
<ide> const compiler = createSingleCompiler();
<ide> let watcher;
<ide>
<del> compiler.hooks.watchRun.tap("RemovedFilesTest", compiler => {
<add> compiler.hooks.watchRun.tap("ChangesAndRemovalsTest", compiler => {
<ide> if (!compiler.removedFiles) return;
<ide> const removals = Array.from(compiler.removedFiles);
<ide> expect(removals).toHaveLength(0);
<ide> describe("ChangesAndRemovals", () => {
<ide>
<ide> watcher = compiler.watch({ aggregateTimeout: 50 }, () => {});
<ide>
<del> setTimeout(() => {
<add> onceDone(compiler, () => {
<ide> fs.appendFileSync(tempFilePath, "\nlet x = 'file modified';");
<del> }, 1000);
<add> });
<ide> });
<ide> }); | 1 |
Javascript | Javascript | allow duplicate keys in formdata | 56fef9b6225ffc1ba87f784660eebe842866c57d | <ide><path>Libraries/Network/FormData.js
<ide> type FormDataPart = {
<ide> */
<ide> class FormData {
<ide> _parts: Array<FormDataNameValuePair>;
<del> _partsByKey: {[key: string]: FormDataNameValuePair};
<ide>
<ide> constructor() {
<ide> this._parts = [];
<del> this._partsByKey = {};
<ide> }
<ide>
<ide> append(key: string, value: FormDataValue) {
<del> var parts = this._partsByKey[key];
<del> if (parts) {
<del> // It's a bit unclear what the behaviour should be in this case.
<del> // The XMLHttpRequest spec doesn't specify it, while MDN says that
<del> // the any new values should appended to existing values. We're not
<del> // doing that for now -- it's tedious and doesn't seem worth the effort.
<del> parts[1] = value;
<del> return;
<del> }
<del> parts = [key, value];
<del> this._parts.push(parts);
<del> this._partsByKey[key] = parts;
<add> // The XMLHttpRequest spec doesn't specify if duplicate keys are allowed.
<add> // MDN says that any new values should be appended to existing values.
<add> // In any case, major browsers allow duplicate keys, so that's what we'll do
<add> // too. They'll simply get appended as additional form data parts in the
<add> // request body, leaving the server to deal with them.
<add> this._parts.push([key, value]);
<ide> }
<ide>
<ide> getParts(): Array<FormDataPart> { | 1 |
Go | Go | improve some messages in the node subcmds | eb962235fbf1579cf36bb0582347e8639ec47205 | <ide><path>api/client/node/accept.go
<ide> func runAccept(dockerCli *client.DockerCli, flags *pflag.FlagSet, args []string)
<ide> }); err != nil {
<ide> return err
<ide> }
<del> fmt.Println(id, "attempting to accept a node in the swarm.")
<add> fmt.Fprintf(dockerCli.Out(), "Node %s accepted in the swarm.", id)
<ide> }
<ide>
<ide> return nil
<ide><path>api/client/node/demote.go
<ide> func runDemote(dockerCli *client.DockerCli, flags *pflag.FlagSet, args []string)
<ide> }); err != nil {
<ide> return err
<ide> }
<del> fmt.Println(id, "attempting to demote a manager in the swarm.")
<add> fmt.Fprintf(dockerCli.Out(), "Manager %s demoted in the swarm.", id)
<ide> }
<ide>
<ide> return nil
<ide><path>api/client/node/promote.go
<ide> func runPromote(dockerCli *client.DockerCli, flags *pflag.FlagSet, args []string
<ide> }); err != nil {
<ide> return err
<ide> }
<del> fmt.Println(id, "attempting to promote a node to a manager in the swarm.")
<add> fmt.Fprintf(dockerCli.Out(), "Node %s promoted to a manager in the swarm.", id)
<ide> }
<ide>
<ide> return nil
<ide><path>api/client/node/update.go
<ide> func newUpdateCommand(dockerCli *client.DockerCli) *cobra.Command {
<ide> Short: "Update a node",
<ide> Args: cli.ExactArgs(1),
<ide> RunE: func(cmd *cobra.Command, args []string) error {
<del> return runUpdate(dockerCli, args[0], mergeNodeUpdate(flags))
<add> if err := runUpdate(dockerCli, args[0], mergeNodeUpdate(flags)); err != nil {
<add> return err
<add> }
<add> fmt.Fprintln(dockerCli.Out(), args[0])
<add> return nil
<ide> },
<ide> }
<ide>
<ide> func runUpdate(dockerCli *client.DockerCli, nodeID string, mergeNode func(node *
<ide> return err
<ide> }
<ide>
<del> fmt.Fprintf(dockerCli.Out(), "%s\n", nodeID)
<ide> return nil
<ide> }
<ide> | 4 |
Mixed | Javascript | add case for url.parse throwing a urierror | 2ff107dad7faaef617916d84101bb43b73dbd4e6 | <ide><path>doc/api/url.md
<ide> added: v0.1.25
<ide> The `url.parse()` method takes a URL string, parses it, and returns a URL
<ide> object.
<ide>
<add>A `TypeError` is thrown if `urlString` is not a string.
<add>
<add>A `URIError` is thrown if the `auth` property is present but cannot be decoded.
<add>
<ide> ## url.resolve(from, to)
<ide> <!-- YAML
<ide> added: v0.1.25
<ide><path>test/parallel/test-url-parse-invalid-input.js
<ide> const url = require('url');
<ide> ].forEach(function(val) {
<ide> assert.throws(function() { url.parse(val); }, TypeError);
<ide> });
<add>
<add>assert.throws(function() { url.parse('http://%E0%A4%A@fail'); }, /^URIError: URI malformed$/); | 2 |
PHP | PHP | organize requests differently | d306965007aed4fd9167f48228caa7813d07b7f8 | <ide><path>app/Http/Controllers/Auth/AuthController.php
<ide> <?php namespace App\Http\Controllers\Auth;
<ide>
<ide> use App\User;
<del>use Illuminate\Http\Request;
<add>use App\Http\Requests;
<ide> use App\Http\Controllers\Controller;
<ide> use Illuminate\Contracts\Auth\Guard;
<ide>
<ide> public function getRegister()
<ide> /**
<ide> * Handle a registration request for the application.
<ide> *
<del> * @param Request $request
<add> * @param RegisterRequest $request
<ide> * @return Response
<ide> */
<del> public function postRegister(Request $request)
<add> public function postRegister(Requests\Auth\RegisterRequest $request)
<ide> {
<del> $this->validate($request, [
<del> 'name' => 'required|max:255',
<del> 'email' => 'required|email|max:255|unique:users',
<del> 'password' => 'required|min:6|confirmed',
<del> ]);
<del>
<ide> $user = User::forceCreate([
<ide> 'name' => $request->name,
<ide> 'email' => $request->email,
<ide> public function getLogin()
<ide> /**
<ide> * Handle a login request to the application.
<ide> *
<del> * @param Request $request
<add> * @param LoginRequest $request
<ide> * @return Response
<ide> */
<del> public function postLogin(Request $request)
<add> public function postLogin(Requests\Auth\LoginRequest $request)
<ide> {
<del> $this->validate($request, [
<del> 'email' => 'required', 'password' => 'required'
<del> ]);
<del>
<ide> $credentials = $request->only('email', 'password');
<ide>
<ide> if ($this->auth->attempt($credentials, $request->has('remember')))
<ide><path>app/Http/Controllers/Auth/PasswordController.php
<ide> <?php namespace App\Http\Controllers\Auth;
<ide>
<ide> use App\User;
<del>use Illuminate\Http\Request;
<add>use App\Http\Requests;
<ide> use App\Http\Controllers\Controller;
<ide> use Illuminate\Contracts\Auth\Guard;
<ide> use Illuminate\Contracts\Auth\PasswordBroker;
<ide> public function getEmail()
<ide> /**
<ide> * Send a reset link to the given user.
<ide> *
<del> * @param Request $request
<add> * @param EmailPasswordLinkRequest $request
<ide> * @return Response
<ide> */
<del> public function postEmail(Request $request)
<add> public function postEmail(Requests\Auth\EmailPasswordLinkRequest $request)
<ide> {
<del> $this->validate($request, ['email' => 'required']);
<del>
<ide> switch ($response = $this->passwords->sendResetLink($request->only('email')))
<ide> {
<ide> case PasswordBroker::INVALID_USER:
<ide> public function getReset($token = null)
<ide> /**
<ide> * Reset the given user's password.
<ide> *
<del> * @param Request $request
<add> * @param ResetPasswordRequest $request
<ide> * @return Response
<ide> */
<del> public function postReset(Request $request)
<add> public function postReset(Requests\Auth\ResetPasswordRequest $request)
<ide> {
<ide> $credentials = $request->only(
<ide> 'email', 'password', 'password_confirmation', 'token'
<ide><path>app/Http/Requests/Auth/EmailPasswordLinkRequest.php
<add><?php namespace App\Http\Requests\Auth;
<add>
<add>use App\Http\Requests\Request;
<add>
<add>class EmailPasswordLinkRequest extends Request {
<add>
<add> /**
<add> * Get the validation rules that apply to the request.
<add> *
<add> * @return array
<add> */
<add> public function rules()
<add> {
<add> return [
<add> 'email' => 'required',
<add> ];
<add> }
<add>
<add> /**
<add> * Determine if the user is authorized to make this request.
<add> *
<add> * @return bool
<add> */
<add> public function authorize()
<add> {
<add> return true;
<add> }
<add>
<add>}
<ide><path>app/Http/Requests/Auth/LoginRequest.php
<add><?php namespace App\Http\Requests\Auth;
<add>
<add>use App\Http\Requests\Request;
<add>
<add>class LoginRequest extends Request {
<add>
<add> /**
<add> * Get the validation rules that apply to the request.
<add> *
<add> * @return array
<add> */
<add> public function rules()
<add> {
<add> return [
<add> 'email' => 'required', 'password' => 'required',
<add> ];
<add> }
<add>
<add> /**
<add> * Determine if the user is authorized to make this request.
<add> *
<add> * @return bool
<add> */
<add> public function authorize()
<add> {
<add> return true;
<add> }
<add>
<add>}
<ide><path>app/Http/Requests/Auth/RegisterRequest.php
<add><?php namespace App\Http\Requests\Auth;
<add>
<add>use App\Http\Requests\Request;
<add>
<add>class RegisterRequest extends Request {
<add>
<add> /**
<add> * Get the validation rules that apply to the request.
<add> *
<add> * @return array
<add> */
<add> public function rules()
<add> {
<add> return [
<add> 'name' => 'required|max:255',
<add> 'email' => 'required|email|max:255|unique:users',
<add> 'password' => 'required|min:6|confirmed',
<add> ];
<add> }
<add>
<add> /**
<add> * Determine if the user is authorized to make this request.
<add> *
<add> * @return bool
<add> */
<add> public function authorize()
<add> {
<add> return true;
<add> }
<add>
<add>}
<ide><path>app/Http/Requests/Auth/ResetPasswordRequest.php
<add><?php namespace App\Http\Requests\Auth;
<add>
<add>use App\Http\Requests\Request;
<add>
<add>class ResetPasswordRequest extends Request {
<add>
<add> /**
<add> * Get the validation rules that apply to the request.
<add> *
<add> * @return array
<add> */
<add> public function rules()
<add> {
<add> return [
<add> 'token' => 'required',
<add> 'email' => 'required',
<add> 'password' => 'required|confirmed',
<add> ];
<add> }
<add>
<add> /**
<add> * Determine if the user is authorized to make this request.
<add> *
<add> * @return bool
<add> */
<add> public function authorize()
<add> {
<add> return false;
<add> }
<add>
<add>} | 6 |
PHP | PHP | fix phpcs doc errors | be7abf7d56c4fb4ea59350d894e0200b4effee14 | <ide><path>src/View/Cell.php
<ide> abstract class Cell
<ide> /**
<ide> * Constructor.
<ide> *
<del> * @param \Cake\Network\Request $request the request to use in the cell
<del> * @param \Cake\Network\Response $response the response to use in the cell
<del> * @param \Cake\Event\EventManager $eventManager then eventManager to bind events to
<del> * @param array $cellOptions cell options to apply
<add> * @param \Cake\Network\Request $request The request to use in the cell.
<add> * @param \Cake\Network\Response $response The response to use in the cell.
<add> * @param \Cake\Event\EventManager $eventManager The eventManager to bind events to.
<add> * @param array $cellOptions Cell options to apply.
<ide> */
<ide> public function __construct(
<ide> Request $request = null,
<ide> public function __construct(
<ide> *
<ide> * @param string|null $template Custom template name to render. If not provided (null), the last
<ide> * value will be used. This value is automatically set by `CellTrait::cell()`.
<del> * @return string The rendered cell
<add> * @return string The rendered cell.
<ide> * @throws \Cake\View\Exception\MissingCellViewException When a MissingTemplateException is raised during rendering.
<ide> */
<ide> public function render($template = null) | 1 |
Ruby | Ruby | add a method for configuring abstract controllers | 9eddc8544417323dcd8460026027c3359b2ad717 | <ide><path>actionpack/lib/abstract_controller/base.rb
<ide> def config
<ide> @config ||= ActiveSupport::InheritableOptions.new(superclass < Base ? superclass.config : {})
<ide> end
<ide>
<add> def configure
<add> yield config
<add> end
<add>
<ide> # A list of all internal methods for a controller. This finds the first
<ide> # abstract superclass of a controller, and gets a list of all public
<ide> # instance methods on that abstract class. Public instance methods of | 1 |
PHP | PHP | add type hints | 0068b6f8026734acbff1bbaa2a0bf380bd48fbfd | <ide><path>src/I18n/FormatterInterface.php
<ide> interface FormatterInterface
<ide> * @param array $tokenValues The list of values to interpolate in the message
<ide> * @return string The formatted message
<ide> */
<del> public function format($locale, $message, array $tokenValues): string;
<add> public function format(string $locale, string $message, array $tokenValues): string;
<ide> }
<ide><path>src/I18n/FormatterLocator.php
<ide> public function __construct(array $registry = [])
<ide> * Sets a formatter into the registry by name.
<ide> *
<ide> * @param string $name The formatter name.
<del> *
<ide> * @param callable $spec A callable that returns a formatter object.
<ide> * @return void
<ide> */
<del> public function set($name, $spec)
<add> public function set(string $name, callable $spec): void
<ide> {
<ide> $this->registry[$name] = $spec;
<ide> $this->converted[$name] = false;
<ide> public function set($name, $spec)
<ide> * @return \Cake\I18n\FormatterInterface A formatter object.
<ide> * @throws \Cake\I18n\Exception\FormatterNotMappedException
<ide> */
<del> public function get($name)
<add> public function get(string $name): FormatterInterface
<ide> {
<del> if (! isset($this->registry[$name])) {
<add> if (!isset($this->registry[$name])) {
<ide> throw new FormatterNotMappedException($name);
<ide> }
<ide>
<del> if (! $this->converted[$name]) {
<add> if (!$this->converted[$name]) {
<ide> $func = $this->registry[$name];
<ide> $this->registry[$name] = $func();
<ide> $this->converted[$name] = true;
<ide><path>src/I18n/Package.php
<ide> public function __construct(
<ide> * @param array $messages The messages for this package.
<ide> * @return void
<ide> */
<del> public function setMessages(array $messages)
<add> public function setMessages(array $messages): void
<ide> {
<ide> $this->messages = $messages;
<ide> }
<ide> public function setMessages(array $messages)
<ide> * Adds one message for this package.
<ide> *
<ide> * @param string $key the key of the message
<del> *
<ide> * @param string $message the actual message
<ide> * @return void
<ide> */
<del> public function addMessage($key, $message)
<add> public function addMessage(string $key, string $message): void
<ide> {
<ide> $this->messages[$key] = $message;
<ide> }
<ide> public function addMessage($key, $message)
<ide> * @param array $messages The messages to add in this package.
<ide> * @return void
<ide> */
<del> public function addMessages($messages)
<add> public function addMessages(array $messages): void
<ide> {
<ide> $this->messages = array_merge($this->messages, $messages);
<ide> }
<ide> public function addMessages($messages)
<ide> *
<ide> * @return array
<ide> */
<del> public function getMessages()
<add> public function getMessages(): array
<ide> {
<ide> return $this->messages;
<ide> }
<ide> public function getMessages()
<ide> * @param string $key the key of the message to return
<ide> * @return mixed The message translation string, or false if not found.
<ide> */
<del> public function getMessage($key)
<add> public function getMessage(string $key)
<ide> {
<ide> if (isset($this->messages[$key])) {
<ide> return $this->messages[$key];
<ide> public function getMessage($key)
<ide> * @param string $formatter The formatter name for this package.
<ide> * @return void
<ide> */
<del> public function setFormatter($formatter)
<add> public function setFormatter(string $formatter): void
<ide> {
<ide> $this->formatter = $formatter;
<ide> }
<ide> public function setFormatter($formatter)
<ide> *
<ide> * @return string
<ide> */
<del> public function getFormatter()
<add> public function getFormatter(): string
<ide> {
<ide> return $this->formatter;
<ide> }
<ide>
<ide> /**
<ide> * Sets the fallback package name.
<ide> *
<del> * @param string $fallback The fallback package name.
<add> * @param string|null $fallback The fallback package name.
<ide> * @return void
<ide> */
<del> public function setFallback($fallback)
<add> public function setFallback(?string $fallback): void
<ide> {
<ide> $this->fallback = $fallback;
<ide> }
<ide> public function setFallback($fallback)
<ide> *
<ide> * @return string|null
<ide> */
<del> public function getFallback()
<add> public function getFallback(): ?string
<ide> {
<ide> return $this->fallback;
<ide> }
<ide><path>src/I18n/PackageLocator.php
<ide> public function __construct(array $registry = [])
<ide> * Sets a Package object.
<ide> *
<ide> * @param string $name The package name.
<del> *
<ide> * @param string $locale The locale for the package.
<del> *
<ide> * @param callable $spec A callable that returns a package.
<ide> * @return void
<ide> */
<del> public function set($name, $locale, callable $spec)
<add> public function set(string $name, string $locale, callable $spec): void
<ide> {
<ide> $this->registry[$name][$locale] = $spec;
<ide> $this->converted[$name][$locale] = false;
<ide> public function set($name, $locale, callable $spec)
<ide> * Gets a Package object.
<ide> *
<ide> * @param string $name The package name.
<del> *
<ide> * @param string $locale The locale for the package.
<ide> * @return \Cake\I18n\Package
<ide> */
<del> public function get($name, $locale)
<add> public function get(string $name, string $locale): Package
<ide> {
<del> if (! isset($this->registry[$name][$locale])) {
<add> if (!isset($this->registry[$name][$locale])) {
<ide> throw new I18nException("Package '$name' with locale '$locale' is not registered.");
<ide> }
<ide>
<del> if (! $this->converted[$name][$locale]) {
<add> if (!$this->converted[$name][$locale]) {
<ide> $func = $this->registry[$name][$locale];
<ide> $this->registry[$name][$locale] = $func();
<ide> $this->converted[$name][$locale] = true;
<ide><path>src/I18n/Translator.php
<ide> public function __construct(
<ide> * @param string $key The message key.
<ide> * @return mixed The message translation string, or false if not found.
<ide> */
<del> protected function getMessage($key)
<add> protected function getMessage(string $key)
<ide> {
<ide> $message = $this->package->getMessage($key);
<ide> if ($message) {
<ide> protected function getMessage($key)
<ide> * message.
<ide> * @return string The translated message with tokens replaced.
<ide> */
<del> public function translate($key, array $tokensValues = []): string
<add> public function translate(string $key, array $tokensValues = []): string
<ide> {
<ide> if (isset($tokensValues['_count'])) {
<ide> $message = $this->getMessage(static::PLURAL_PREFIX . $key);
<ide> protected function resolveContext(string $key, array $message, array $vars)
<ide> *
<ide> * @return \Cake\I18n\Package
<ide> */
<del> public function getPackage()
<add> public function getPackage(): Package
<ide> {
<ide> return $this->package;
<ide> }
<ide><path>src/I18n/TranslatorRegistry.php
<ide> public function __construct(
<ide> * @param string $locale The new locale code.
<ide> * @return void
<ide> */
<del> public function setLocale($locale)
<add> public function setLocale(string $locale): void
<ide> {
<ide> $this->locale = $locale;
<ide> }
<ide> public function setLocale($locale)
<ide> *
<ide> * @return string
<ide> */
<del> public function getLocale()
<add> public function getLocale(): string
<ide> {
<ide> return $this->locale;
<ide> }
<ide> public function getLocale()
<ide> *
<ide> * @return \Cake\I18n\PackageLocator
<ide> */
<del> public function getPackages()
<add> public function getPackages(): PackageLocator
<ide> {
<ide> return $this->packages;
<ide> }
<ide> public function getPackages()
<ide> *
<ide> * @return \Cake\I18n\FormatterLocator
<ide> */
<del> public function getFormatters()
<add> public function getFormatters(): FormatterLocator
<ide> {
<ide> return $this->formatters;
<ide> }
<ide> public function setCacher($cacher): void
<ide> /**
<ide> * Gets a translator from the registry by package for a locale.
<ide> *
<del> * @param string|null $name The translator package to retrieve.
<add> * @param string $name The translator package to retrieve.
<ide> * @param string|null $locale The locale to use; if empty, uses the default
<ide> * locale.
<ide> * @return \Cake\I18n\Translator|null A translator object.
<ide> * @throws \Cake\I18n\Exception\I18nException If no translator with that name could be found
<ide> * for the given locale.
<ide> */
<del> public function get($name, $locale = null)
<add> public function get(string $name, ?string $locale = null): ?Translator
<ide> {
<del> if (!$name) {
<del> return null;
<del> }
<del>
<ide> if ($locale === null) {
<ide> $locale = $this->getLocale();
<ide> }
<ide> protected function _getTranslator(string $name, string $locale): Translator
<ide> protected function createInstance(string $name, string $locale): Translator
<ide> {
<ide> $package = $this->packages->get($name, $locale);
<del> $fallback = $this->get($package->getFallback(), $locale);
<add> $fallback = $package->getFallback();
<add> if ($fallback !== null) {
<add> $fallback = $this->get($fallback, $locale);
<add> }
<ide> $formatter = $this->formatters->get($package->getFormatter());
<ide>
<ide> return new Translator($locale, $package, $formatter, $fallback);
<ide><path>tests/TestCase/ORM/RulesCheckerIntegrationTest.php
<ide> public function testIsLinkedToMessageWithI18n(): void
<ide> ];
<ide> $this->assertEquals($expected, $comment->getErrors());
<ide>
<del> $translator->getPackage()->addMessage($messageId, null);
<add> $translator->getPackage()->addMessage($messageId, '');
<ide> }
<ide>
<ide> /**
<ide> public function testIsNotLinkedToMessageWithI18n(): void
<ide> ];
<ide> $this->assertEquals($expected, $comment->getErrors());
<ide>
<del> $translator->getPackage()->addMessage($messageId, null);
<add> $translator->getPackage()->addMessage($messageId, '');
<ide> }
<ide>
<ide> /**
<ide> function () use ($rulesChecker) {
<ide> ];
<ide> $this->assertEquals($expected, $comment->getErrors());
<ide>
<del> $translator->getPackage()->addMessage($messageId, null);
<add> $translator->getPackage()->addMessage($messageId, '');
<ide> }
<ide>
<ide> /**
<ide> function () use ($rulesChecker) {
<ide> ];
<ide> $this->assertEquals($expected, $comment->getErrors());
<ide>
<del> $translator->getPackage()->addMessage($messageId, null);
<add> $translator->getPackage()->addMessage($messageId, '');
<ide> }
<ide>
<ide> /** | 7 |
Ruby | Ruby | remove deprecated api | f53c247d10acbaacb0d61824cfce888c4b0520d2 | <ide><path>actionpack/lib/action_controller/test_case.rb
<ide> def paramify_values(hash_or_array_or_value)
<ide>
<ide> def process(action, http_method = 'GET', *args)
<ide> check_required_ivars
<del> http_method, args = handle_old_process_api(http_method, args)
<ide>
<ide> if args.first.is_a?(String)
<ide> @request.env['RAW_POST_DATA'] = args.shift
<ide> def check_required_ivars
<ide> end
<ide> end
<ide>
<del> def handle_old_process_api(http_method, args)
<del> # 4.0: Remove this method.
<del> if http_method.is_a?(Hash)
<del> ActiveSupport::Deprecation.warn("TestCase#process now expects the HTTP method as second argument: process(action, http_method, params, session, flash)")
<del> args.unshift(http_method)
<del> http_method = args.last.is_a?(String) ? args.last : "GET"
<del> end
<del>
<del> [http_method, args]
<del> end
<del>
<ide> def build_request_uri(action, parameters)
<ide> unless @request.env["PATH_INFO"]
<ide> options = @controller.respond_to?(:url_options) ? @controller.__send__(:url_options).merge(parameters) : parameters
<ide><path>actionpack/test/controller/action_pack_assertions_test.rb
<ide> def test_response_object
<ide> end
<ide>
<ide> def test_render_based_on_parameters
<del> process :render_based_on_parameters, "name" => "David"
<add> process :render_based_on_parameters, 'GET', "name" => "David"
<ide> assert_equal "Mr. David", @response.body
<ide> end
<ide>
<ide><path>actionpack/test/controller/test_case_test.rb
<ide> def test_process_with_request_uri_with_params
<ide> process :test_uri, "GET", :id => 7
<ide> assert_equal "/test_test/test/test_uri/7", @response.body
<ide> end
<del>
<del> def test_process_with_old_api
<del> assert_deprecated do
<del> process :test_uri, :id => 7
<del> assert_equal "/test_test/test/test_uri/7", @response.body
<del> end
<del> end
<ide>
<ide> def test_process_with_request_uri_with_params_with_explicit_uri
<ide> @request.env['PATH_INFO'] = "/explicit/uri" | 3 |
Javascript | Javascript | join iterables correctly | 83ec8a3c5747ab266bd3281288d4c82601e40061 | <ide><path>lib/FunctionModuleTemplatePlugin.js
<ide> const joinIterableWithComma = iterable => {
<ide> let str = "";
<ide> let first = true;
<ide> for (const item of iterable) {
<del> str += item;
<ide> if (first) {
<ide> first = false;
<ide> } else {
<ide> str += ", ";
<ide> }
<add> str += item;
<ide> }
<ide> return str;
<ide> }; | 1 |
Javascript | Javascript | remove debugging code | daf23a0341eddeb38a4762af3cb7a95b4dc33747 | <ide><path>pdf.js
<ide> function warn(msg) {
<ide> }
<ide>
<ide> function error(msg) {
<del> console.log(backtrace());
<add> log(backtrace());
<ide> throw new Error(msg);
<ide> }
<ide>
<ide> var XRef = (function() {
<ide> return this.fetch(obj);
<ide> },
<ide> fetch: function(ref) {
<del>
<del>
<del> if ("undefined" == typeof ref) {
<del> console.log(backtrace());
<del> }
<del>
<del>
<ide> var num = ref.num;
<ide> var e = this.cache[num];
<ide> if (e)
<ide> var ColorSpace = (function() {
<ide> };
<ide>
<ide> constructor.parse = function colorspace_parse(cs, xref, res) {
<del>
<del>
<del>
<del> if ("undefined" == typeof(cs))
<del> console.log(backtrace());
<del>
<del>
<del>
<del>
<ide> if (IsName(cs)) {
<ide> var colorSpaces = res.get('ColorSpace');
<ide> if (colorSpaces) { | 1 |
Go | Go | fix testauthzpluginalloweventstream for multiarch | 36a974a1a6267828b773de19ed298947c66c4945 | <ide><path>integration-cli/docker_cli_authz_unix_test.go
<ide> import (
<ide>
<ide> "bufio"
<ide> "bytes"
<add> "os/exec"
<add> "strconv"
<add> "time"
<add>
<ide> "github.com/docker/docker/pkg/authorization"
<ide> "github.com/docker/docker/pkg/integration/checker"
<ide> "github.com/docker/docker/pkg/plugins"
<ide> "github.com/go-check/check"
<del> "os/exec"
<del> "strconv"
<del> "time"
<ide> )
<ide>
<ide> const (
<ide> func (s *DockerAuthzSuite) TestAuthZPluginDenyResponse(c *check.C) {
<ide> func (s *DockerAuthzSuite) TestAuthZPluginAllowEventStream(c *check.C) {
<ide> testRequires(c, DaemonIsLinux)
<ide>
<del> // Start the authorization plugin
<del> err := s.d.Start("--authorization-plugin=" + testAuthZPlugin)
<del> c.Assert(err, check.IsNil)
<add> // start the daemon and load busybox to avoid pulling busybox from Docker Hub
<add> c.Assert(s.d.StartWithBusybox(), check.IsNil)
<add> // restart the daemon and enable the authorization plugin, otherwise busybox loading
<add> // is blocked by the plugin itself
<add> c.Assert(s.d.Restart("--authorization-plugin="+testAuthZPlugin), check.IsNil)
<ide> s.ctrl.reqRes.Allow = true
<ide> s.ctrl.resRes.Allow = true
<ide>
<ide> func (s *DockerAuthzSuite) TestAuthZPluginAllowEventStream(c *check.C) {
<ide> defer observer.Stop()
<ide>
<ide> // Create a container and wait for the creation events
<del> _, err = s.d.Cmd("pull", "busybox")
<del> c.Assert(err, check.IsNil)
<ide> out, err := s.d.Cmd("run", "-d", "busybox", "top")
<del> c.Assert(err, check.IsNil)
<add> c.Assert(err, check.IsNil, check.Commentf(out))
<ide>
<ide> containerID := strings.TrimSpace(out)
<ide> | 1 |
Javascript | Javascript | add end point for initializecore | 9687090b5bf5b5073d676482e78a508d590cd587 | <ide><path>Libraries/Core/InitializeCore.js
<ide> if (__DEV__) {
<ide>
<ide> if (startTime != null) {
<ide> const PerformanceLogger = require('PerformanceLogger');
<del> PerformanceLogger.markPoint('InitializeCoreStartTime', startTime);
<add> PerformanceLogger.markPoint('initializeCore_start', startTime);
<add> PerformanceLogger.markPoint('initializeCore_end');
<ide> } | 1 |
PHP | PHP | remove duplicate variable | a54268697a6c544312dd0b610c68db5021d267d3 | <ide><path>src/Illuminate/Database/Eloquent/Model.php
<ide> protected function performUpdate($query)
<ide> return false;
<ide> }
<ide>
<del> $dirty = $this->getDirty();
<del>
<ide> // Once we have run the update operation, we will fire the "updated" event for
<ide> // this model instance. This will allow developers to hook into these after
<ide> // models are updated, giving them a chance to do any special processing. | 1 |
Python | Python | import mock module directly | 28d73f4619e5778760e2bc4057872b5bc1f84e09 | <ide><path>libcloud/test/compute/test_libvirt_driver.py
<ide>
<ide> from libcloud.test import unittest
<ide> if unittest2_required:
<del> from unittest2 import mock
<add> import mock
<ide> else:
<ide> from unittest import mock
<ide> | 1 |
Text | Text | fix typo in models.md | b1996a51a1a51e310df8ce08964359376bd11a46 | <ide><path>website/docs/usage/models.md
<ide> logic around spaCy's loader, you can use
<ide> [pytest](http://pytest.readthedocs.io/en/latest/)'s
<ide> [`importorskip()`](https://docs.pytest.org/en/latest/builtin.html#_pytest.outcomes.importorskip)
<ide> method to only run a test if a specific pipeline package or version is
<del>installed. Each pipeline package package exposes a `__version__` attribute which
<add>installed. Each pipeline package exposes a `__version__` attribute which
<ide> you can also use to perform your own version compatibility checks before loading
<ide> it. | 1 |
Python | Python | fix some weird behavior with scaling | fe3838cb006de3606fd38d03ac168f09dc5b0507 | <ide><path>celery/tests/worker/test_autoscale.py
<ide> def test_body(self):
<ide> state.reserved_requests.clear()
<ide> x.body()
<ide> self.assertEqual(x.pool.num_processes, 10)
<del> x._last_action = monotonic() - 10000
<add> x._last_scale_up = monotonic() - 10000
<ide> x.body()
<ide> self.assertEqual(x.pool.num_processes, 3)
<ide> self.assertTrue(worker.consumer._update_prefetch_count.called)
<ide> def test_shrink_raises_ValueError(self, debug):
<ide> worker = Mock(name='worker')
<ide> x = autoscale.Autoscaler(self.pool, 10, 3, worker=worker)
<ide> x.scale_up(3)
<del> x._last_action = monotonic() - 10000
<add> x._last_scale_up = monotonic() - 10000
<ide> x.pool.shrink_raises_ValueError = True
<ide> x.scale_down(1)
<ide> self.assertTrue(debug.call_count)
<ide> def test_update_and_force(self):
<ide> self.assertEqual(x.processes, 5)
<ide> x.force_scale_down(3)
<ide> self.assertEqual(x.processes, 2)
<del> x.update(3, None)
<add> x.update(None, 3)
<ide> self.assertEqual(x.processes, 3)
<ide> x.force_scale_down(1000)
<ide> self.assertEqual(x.min_concurrency, 0)
<ide><path>celery/worker/autoscale.py
<ide> def __init__(self, pool, max_concurrency,
<ide> self.max_concurrency = max_concurrency
<ide> self.min_concurrency = min_concurrency
<ide> self.keepalive = keepalive
<del> self._last_action = None
<add> self._last_scale_up = None
<ide> self.worker = worker
<ide>
<ide> assert self.keepalive, 'cannot scale down too fast.'
<ide> def _maybe_scale(self, req=None):
<ide> if cur > procs:
<ide> self.scale_up(cur - procs)
<ide> return True
<del> elif cur < procs:
<del> self.scale_down((procs - cur) - self.min_concurrency)
<add> cur = max(self.qty, self.min_concurrency)
<add> if cur < procs:
<add> self.scale_down(procs - cur)
<ide> return True
<ide>
<ide> def maybe_scale(self, req=None):
<ide> def maybe_scale(self, req=None):
<ide> def update(self, max=None, min=None):
<ide> with self.mutex:
<ide> if max is not None:
<del> if max < self.max_concurrency:
<add> if max < self.processes:
<ide> self._shrink(self.processes - max)
<ide> self.max_concurrency = max
<ide> if min is not None:
<del> if min > self.min_concurrency:
<del> self._grow(min - self.min_concurrency)
<add> if min > self.processes:
<add> self._grow(min - self.processes)
<ide> self.min_concurrency = min
<ide> return self.max_concurrency, self.min_concurrency
<ide>
<ide> def force_scale_up(self, n):
<ide> new = self.processes + n
<ide> if new > self.max_concurrency:
<ide> self.max_concurrency = new
<del> self.min_concurrency += 1
<ide> self._grow(n)
<ide>
<ide> def force_scale_down(self, n):
<ide> def force_scale_down(self, n):
<ide> self._shrink(min(n, self.processes))
<ide>
<ide> def scale_up(self, n):
<del> self._last_action = monotonic()
<add> self._last_scale_up = monotonic()
<ide> return self._grow(n)
<ide>
<ide> def scale_down(self, n):
<del> if n and self._last_action and (
<del> monotonic() - self._last_action > self.keepalive):
<del> self._last_action = monotonic()
<add> if self._last_scale_up and (
<add> monotonic() - self._last_scale_up > self.keepalive):
<ide> return self._shrink(n)
<ide>
<ide> def _grow(self, n): | 2 |
Text | Text | remove blank lines | 40563a3ab457f5b1d8a5defaecb7375c55bc3fd5 | <ide><path>guides/source/working_with_javascript_in_rails.md
<ide> In case of buttons the `data-turbo-confirm` attribute must be associated to the
<ide> ```erb
<ide> <%= button_to "Delete post', post, method: :delete, form: { data: { turbo_confirm: "Are you sure?" } } %>
<ide> ```
<del>
<del> | 1 |
Javascript | Javascript | log individual test results when in --debug mode | 4daeda1490bd12b64f1bb7a9bae017f957adb89f | <ide><path>grunt/config/webdriver-jasmine.js
<ide> exports.local = {
<ide> }
<ide> }
<ide>
<add>if (grunt.option('debug')) exports.local.url += '?debug=' + grunt.option('debug');
<add>
<ide>
<ide> exports.saucelabs = {
<ide> webdriver: {
<ide><path>test/lib/reportTestResults.browser.js
<add>console._log = console.log;
<add>console.log = function(message){
<add> console._log(message);
<add> postDataToURL({type:'log', message:message}, '/reportTestResults');
<add>}
<add>console._error = console.error;
<add>console.error = function(message){
<add> console._error(message);
<add> postDataToURL({type:'error', message:message}, '/reportTestResults');
<add>}
<add>
<ide> ;(function(env){
<ide> env.addReporter(new jasmine.JSReporter());
<add> if (location.search.substring(1).indexOf('debug') != -1){
<add> env.addReporter(new TAPReporter(console.log.bind(console)));
<add> }
<ide>
<ide> function report(){
<ide> if (typeof jasmine.getJSReport != 'function') { | 2 |
Javascript | Javascript | simplify formulas based on code review | 463a8dd77899cde1a2c542c6c90d0c7614285f16 | <ide><path>src/helpers/helpers.easing.js
<ide> var effects = {
<ide> return 1;
<ide> }
<ide> if (!p) {
<del> p = 1 * 0.3;
<add> p = 0.3;
<ide> }
<del> if (a < Math.abs(1)) {
<add> if (a < 1) {
<ide> a = 1;
<ide> s = p / 4;
<ide> } else {
<ide> var effects = {
<ide> return 1;
<ide> }
<ide> if (!p) {
<del> p = 1 * 0.3;
<add> p = 0.3;
<ide> }
<del> if (a < Math.abs(1)) {
<add> if (a < 1) {
<ide> a = 1;
<ide> s = p / 4;
<ide> } else {
<ide> var effects = {
<ide> return 1;
<ide> }
<ide> if (!p) {
<del> p = 0.3 * 1.5;
<add> p = 0.45;
<ide> }
<del> if (a < Math.abs(1)) {
<add> if (a < 1) {
<ide> a = 1;
<ide> s = p / 4;
<ide> } else { | 1 |
Text | Text | define report version semantics | c127e4ea97d0d5111c46cf0703ad439e055ae251 | <ide><path>doc/api/report.md
<ide> includes the date, time, PID, and a sequence number. The sequence number helps
<ide> in associating the report dump with the runtime state if generated multiple
<ide> times for the same Node.js process.
<ide>
<add>Diagnostic report has an associated single-digit version number (`report.header.reportVersion`),
<add>uniquely representing the report format. The version number is bumped
<add>when new key is added or removed, or the data type of a value is changed.
<add>Report version definitions are consistent across LTS releases.
<add>
<ide> ## Configuration
<ide>
<ide> Additional runtime configuration of report generation is available via | 1 |
Ruby | Ruby | add command to mirror to bintray. (#263) | 0123e04faed98c06dc395a2ec0d7fa0de2f56d5d | <ide><path>Library/Homebrew/dev-cmd/mirror.rb
<add># Mirrors the stable URL for a formula on Bintray.
<add>#
<add># Usage: brew mirror <formula> [<formula> ...]
<add>
<add>module Homebrew
<add> def mirror
<add> if ARGV.named.empty?
<add> odie "This command requires at least formula argument!"
<add> end
<add>
<add> bintray_user = ENV["BINTRAY_USER"]
<add> bintray_key = ENV["BINTRAY_KEY"]
<add> if !bintray_user || !bintray_key
<add> raise "Missing BINTRAY_USER or BINTRAY_KEY variables!"
<add> end
<add>
<add> ARGV.formulae.each do |f|
<add> bintray_package = Utils::Bottles::Bintray.package f.name
<add> bintray_repo_url = "https://api.bintray.com/packages/homebrew/mirror"
<add> package_url = "#{bintray_repo_url}/#{bintray_package}"
<add>
<add> unless system "curl", "--silent", "--fail", "--output", "/dev/null", package_url
<add> package_blob = <<-EOS.undent
<add> {"name": "#{bintray_package}",
<add> "public_download_numbers": true,
<add> "public_stats": true}
<add> EOS
<add> curl "--silent", "--fail", "-u#{bintray_user}:#{bintray_key}",
<add> "-H", "Content-Type: application/json",
<add> "-d", package_blob, bintray_repo_url
<add> puts
<add> end
<add>
<add> download = f.fetch
<add> f.verify_download_integrity(download)
<add> filename = download.basename
<add> destination_url = "https://dl.bintray.com/homebrew/mirror/#{filename}"
<add>
<add> ohai "Uploading to #{destination_url}"
<add> content_url = "https://api.bintray.com/content/homebrew/mirror"
<add> content_url += "/#{bintray_package}/#{f.pkg_version}/#{filename}"
<add> content_url += "?publish=1"
<add> curl "--silent", "--fail", "-u#{bintray_user}:#{bintray_key}",
<add> "-T", download, content_url
<add> puts
<add> ohai "Mirrored #{filename}!"
<add> end
<add> end
<add>end | 1 |
Go | Go | skip existing volumes in volumes-from | 57b49efc98d2f4605c95d5579a6cd952dfd6f124 | <ide><path>container.go
<ide> func (container *Container) Start(hostConfig *HostConfig) error {
<ide> }
<ide> for volPath, id := range c.Volumes {
<ide> if _, exists := container.Volumes[volPath]; exists {
<del> return fmt.Errorf("The requested volume %s overlap one of the volume of the container %s", volPath, c.ID)
<add> continue
<ide> }
<ide> if err := os.MkdirAll(path.Join(container.RootfsPath(), volPath), 0755); err != nil {
<ide> return nil
<ide> func (container *Container) Start(hostConfig *HostConfig) error {
<ide> // Create the requested volumes if they don't exist
<ide> for volPath := range container.Config.Volumes {
<ide> volPath = path.Clean(volPath)
<del> // If an external bind is defined for this volume, use that as a source
<add> // Skip existing volumes
<ide> if _, exists := container.Volumes[volPath]; exists {
<del> // Skip existing mounts
<del> } else if bindMap, exists := binds[volPath]; exists {
<add> continue
<add> }
<add> // If an external bind is defined for this volume, use that as a source
<add> if bindMap, exists := binds[volPath]; exists {
<ide> container.Volumes[volPath] = bindMap.SrcPath
<ide> if strings.ToLower(bindMap.Mode) == "rw" {
<ide> container.VolumesRW[volPath] = true
<ide><path>container_test.go
<ide> func TestVolumesFromWithVolumes(t *testing.T) {
<ide> if container.Volumes["/test"] != container2.Volumes["/test"] {
<ide> t.Fail()
<ide> }
<add>
<add> // Ensure it restarts successfully
<add> _, err = container2.Output()
<add> if err != nil {
<add> t.Fatal(err)
<add> }
<ide> }
<ide>
<ide> func TestOnlyLoopbackExistsWhenUsingDisableNetworkOption(t *testing.T) { | 2 |
PHP | PHP | remove unused code | a9a53a743e5f854d9812f56f55e752f1cbdddb16 | <ide><path>src/Illuminate/Translation/Translator.php
<ide> use Illuminate\Support\Arr;
<ide> use Illuminate\Support\Str;
<ide> use Illuminate\Support\Collection;
<del>use Illuminate\Support\HtmlString;
<ide> use Illuminate\Support\Traits\Macroable;
<ide> use Illuminate\Contracts\Translation\Loader;
<ide> use Illuminate\Support\NamespacedItemResolver;
<ide> protected function makeReplacements($line, array $replace)
<ide> $replace = $this->sortReplacements($replace);
<ide>
<ide> foreach ($replace as $key => $value) {
<del> // $value = $value instanceof HtmlString ? $value->toHtml() : e($value);
<del>
<ide> $line = str_replace(
<ide> [':'.$key, ':'.Str::upper($key), ':'.Str::ucfirst($key)],
<ide> [$value, Str::upper($value), Str::ucfirst($value)], | 1 |
Javascript | Javascript | use inputfilesystem instead of real filesystem | 17ca14ccd96dcb951c29f6762260cb7a3fc434d0 | <ide><path>lib/DllReferencePlugin.js
<ide> var DelegatedSourceDependency = require("./dependencies/DelegatedSourceDependency");
<ide> var DelegatedModuleFactoryPlugin = require("./DelegatedModuleFactoryPlugin");
<ide> var ExternalModuleFactoryPlugin = require("./ExternalModuleFactoryPlugin");
<del>var fs = require("fs");
<ide>
<ide> function DllReferencePlugin(options) {
<ide> this.options = options;
<ide> DllReferencePlugin.prototype.apply = function(compiler) {
<ide> var manifest = this.options.manifest;
<ide> if(typeof manifest === "string") {
<ide> params.compilationDependencies.push(manifest);
<del> fs.readFile(manifest, "utf-8", function(err, result) {
<add> compiler.inputFileSystem.readFile(manifest, function(err, result) {
<ide> if(err) return callback(err);
<del> params["dll reference " + manifest] = JSON.parse(result);
<add> params["dll reference " + manifest] = JSON.parse(result.toString("utf-8"));
<ide> return callback();
<ide> });
<ide> } else { | 1 |
Text | Text | add instructions to update local git config | 8b1db6df8012a33b3da74de245074021c4c0c8ff | <ide><path>doc/guides/contributing/pull-requests.md
<ide> These are detailed in the [Building guide][].
<ide> Once you have `git` and are sure you have all of the necessary dependencies,
<ide> it's time to create a fork.
<ide>
<del>Before getting started, it is recommended to configure `git` so that it knows
<del>who you are:
<del>
<del>```text
<del>$ git config --global user.name "J. Random User"
<del>$ git config --global user.email "j.random.user@example.com"
<del>```
<del>Please make sure this local email is also added to your
<del>[GitHub email list](https://github.com/settings/emails) so that your commits
<del>will be properly associated with your account and you will be promoted
<del>to Contributor once your first commit is landed.
<del>
<ide> ### Step 1: Fork
<ide>
<ide> Fork the project [on GitHub](https://github.com/nodejs/node) and clone your fork
<ide> $ git remote add upstream https://github.com/nodejs/node.git
<ide> $ git fetch upstream
<ide> ```
<ide>
<add>It is recommended to configure `git` so that it knows who you are:
<add>
<add>```text
<add>$ git config user.name "J. Random User"
<add>$ git config user.email "j.random.user@example.com"
<add>```
<add>Please make sure this local email is also added to your
<add>[GitHub email list](https://github.com/settings/emails) so that your commits
<add>will be properly associated with your account and you will be promoted
<add>to Contributor once your first commit is landed.
<add>
<ide> ### Step 2: Branch
<ide>
<ide> As a best practice to keep your development environment as organized as | 1 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.