/*!
 * regex-cache <https://github.com/jonschlinkert/regex-cache>
 *
 * Copyright (c) 2015 Jon Schlinkert.
 * Licensed under the MIT license.
 */

'use strict';

var assert = require('assert');
var should = require('should');
var cache = require('./');
var fn = require('./support');

var str = 'a abc foo xyz fooabc';

describe('regex-cache:', function() {
  describe('no cache:', function() {
    it('should use the un-cached regex to match:', function() {
      var matches = str.match(fn.toRegex());
      matches[1].should.equal('a');
    });
  });

  describe('when a regex is passed:', function() {
    it('should return it directly:', function() {
      cache(fn.toRegex()).should.eql(/([^W]?)/);
    });
  });

  describe('when a function is passed:', function() {
    it('should call the function when no other arguments are passed:', function() {
      str.match(cache(fn.toRegex))[1].should.equal('a');
    });

    it('should cache the results on the `_default_` key:', function() {
      str.match(cache(fn.toRegex))[1].should.equal('a');
      cache.basic.should.have.property('_default_');
    });
  });

  describe('with cache:', function() {
    it('should use the cached regex to match:', function() {
      var cached = cache(fn.toRegex);
      var a = str.match(cached);
      var b = str.match(cached);
      var c = str.match(cached);
      var d = str.match(cached);
      var e = str.match(cached);
      e[1].should.equal('a');
      cache.basic.should.have.property('_default_');
    });

    it('should work when a regex is passed:', function() {
      str.match(cache(fn.toRegex()))[1].should.equal('a');
      cache.basic.should.have.property('_default_');
    });

    it('should work when a function is passed:', function() {
      str.match(cache(fn.toRegex))[1].should.equal('a');
      cache.basic.should.have.property('_default_');
    });

    it('should work when options are passed:', function() {
      str.match(cache(fn.toRegex()))[1].should.equal('a');
      str.match(cache(fn.toRegex, 'foo'))[1].should.equal('foo');
      assert.equal(str.match(cache(fn.toRegex, 'bar')), null);
      str.match(cache(fn.toRegex, 'foo', { a: true, b: true, c: true }))[1].should.equal('fooabc');
      str.match(cache(fn.toRegex, { a: true, b: true, c: true, flags: 'g'}))[0].should.equal('abc');
    });

    it('should work when an option is an object:', function() {
      str.match(cache(fn.toRegex, 'foo', { d: {e: 'abc'} }))[0].should.equal('fooabc');
      str.match(cache(fn.toRegex, 'foo', { d: {e: 'ab'} }))[0].should.equal('fooab');
      str.match(cache(fn.toRegex, 'foo', { d: {f: 'abc'} }))[0].should.equal('foo');
    });

    it('should not use a cached regex when options have changed:', function() {
      str.match(cache(fn.toRegex, { a: true, b: true, c: true }))[1].should.equal('abc');
      // change `a` to false
      str.match(cache(fn.toRegex, { a: false, b: true, c: true }))[1].should.equal('bc');
      str.match(cache(fn.toRegex, { a: false, b: true, c: true }))[1].should.not.equal('abc');
    });
  });

  describe('cache object:', function() {
    it('should expose the cache:', function() {
      cache(fn.toRegex, 'foo');
      cache.basic.should.have.property('foo');

      cache(fn.toRegex, 'bar', { a: true, b: true, c: true });
      cache.cache.should.have.property('bar');

      // cache(fn.toRegex, { a: true, b: true, c: true });
      // // cache.cache.should.have.property('atruebtruectrue');

      // cache(fn.toRegex, { a: true, b: true, c: true, flags: 'g'});
      // cache.cache.should.have.property('atruebtruectrueflagsg');
      // cache.cache.should.have.property('foo');
    });
  });
});