Remove JSDocs from everywhere in the Repo - source code, GHPages, etc. We're not using them and the stale docs were confusing. Fixes #338 Fixes #99

src/core/base.js

@@ -1,9 +1,3 @@
-
-/**
- * Top level namespace for Jasmine, a lightweight JavaScript BDD/spec/testing framework.
- *
- * @namespace
- */
 var jasmine = {};
 
 // TODO: do we need this now that we have boot.js?
@@ -11,27 +5,12 @@ if (typeof window == "undefined" && typeof exports == "object") {
   exports.jasmine = jasmine;
 }
 
-/**
- * @private
- */
 jasmine.unimplementedMethod_ = function() {
   throw new Error("unimplemented method");
 };
 
-/**
- * Default interval in milliseconds for event loop yields (e.g. to allow network activity or to refresh the screen with the HTML-based runner). Small values here may result in slow test running. Zero means no updates until all tests have completed.
- *
- */
 jasmine.DEFAULT_UPDATE_INTERVAL = 250;
-
-/**
- * Maximum levels of nesting that will be included when an object is pretty-printed
- */
 jasmine.MAX_PRETTY_PRINT_DEPTH = 40;
-
-/**
- * Default timeout interval in milliseconds for waitsFor() blocks.
- */
 jasmine.DEFAULT_TIMEOUT_INTERVAL = 5000;
 
 jasmine.getGlobal = function() {
@@ -42,216 +21,62 @@ jasmine.getGlobal = function() {
   return getGlobal();
 };
 
-/**
- * Getter for the Jasmine environment. Ensures one gets created
- */
 jasmine.getEnv = function(options) {
   var env = jasmine.currentEnv_ = jasmine.currentEnv_ || new jasmine.Env(options);
   //jasmine. singletons in here (setTimeout blah blah).
   return env;
 };
 
-/**
- * @ignore
- * @private
- * @param value
- * @returns {Boolean}
- */
 jasmine.isArray_ = function(value) {
   return jasmine.isA_("Array", value);
 };
 
-/**
- * @ignore
- * @private
- * @param value
- * @returns {Boolean}
- */
 jasmine.isString_ = function(value) {
   return jasmine.isA_("String", value);
 };
 
-/**
- * @ignore
- * @private
- * @param value
- * @returns {Boolean}
- */
 jasmine.isNumber_ = function(value) {
   return jasmine.isA_("Number", value);
 };
 
-/**
- * @ignore
- * @private
- * @param {String} typeName
- * @param value
- * @returns {Boolean}
- */
 jasmine.isA_ = function(typeName, value) {
   return Object.prototype.toString.apply(value) === '[object ' + typeName + ']';
 };
 
-/**
- * Pretty printer for expecations.  Takes any object and turns it into a human-readable string.
- *
- * @param value {Object} an object to be outputted
- * @returns {String}
- */
 jasmine.pp = function(value) {
   var stringPrettyPrinter = new jasmine.StringPrettyPrinter();
   stringPrettyPrinter.format(value);
   return stringPrettyPrinter.string;
 };
 
-/**
- * Returns true if the object is a DOM Node.
- *
- * @param {Object} obj object to check
- * @returns {Boolean}
- */
 jasmine.isDomNode = function(obj) {
   return obj.nodeType > 0;
 };
 
-/**
- * Returns a matchable 'generic' object of the class type.  For use in expecations of type when values don't matter.
- *
- * @example
- * // don't care about which function is passed in, as long as it's a function
- * expect(mySpy).toHaveBeenCalledWith(jasmine.any(Function));
- *
- * @param {Class} clazz
- * @returns matchable object of the type clazz
- */
 jasmine.any = function(clazz) {
   return new jasmine.Matchers.Any(clazz);
 };
 
-/**
- * Returns a matchable subset of a JSON object. For use in expectations when you don't care about all of the
- * attributes on the object.
- *
- * @example
- * // don't care about any other attributes than foo.
- * expect(mySpy).toHaveBeenCalledWith(jasmine.objectContaining({foo: "bar"});
- *
- * @param sample {Object} sample
- * @returns matchable object for the sample
- */
 jasmine.objectContaining = function (sample) {
     return new jasmine.Matchers.ObjectContaining(sample);
 };
 
-/**
- * Jasmine Spies are test doubles that can act as stubs, spies, fakes or when used in an expecation, mocks.
- *
- * Spies should be created in test setup, before expectations.  They can then be checked, using the standard Jasmine
- * expectation syntax. Spies can be checked if they were called or not and what the calling params were.
- *
- * A Spy has the following fields: wasCalled, callCount, mostRecentCall, and argsForCall (see docs).
- *
- * Spies are torn down at the end of every spec.
- *
- * Note: Do <b>not</b> call new jasmine.Spy() directly - a spy must be created using spyOn, jasmine.createSpy or jasmine.createSpyObj.
- *
- * @example
- * // a stub
- * var myStub = jasmine.createSpy('myStub');  // can be used anywhere
- *
- * // spy example
- * var foo = {
- *   not: function(bool) { return !bool; }
- * }
- *
- * // actual foo.not will not be called, execution stops
- * spyOn(foo, 'not');
-
- // foo.not spied upon, execution will continue to implementation
- * spyOn(foo, 'not').andCallThrough();
- *
- * // fake example
- * var foo = {
- *   not: function(bool) { return !bool; }
- * }
- *
- * // foo.not(val) will return val
- * spyOn(foo, 'not').andCallFake(function(value) {return value;});
- *
- * // mock example
- * foo.not(7 == 7);
- * expect(foo.not).toHaveBeenCalled();
- * expect(foo.not).toHaveBeenCalledWith(true);
- *
- * @constructor
- * @see spyOn, jasmine.createSpy, jasmine.createSpyObj
- * @param {String} name
- */
 jasmine.Spy = function(name) {
-  /**
-   * The name of the spy, if provided.
-   */
   this.identity = name || 'unknown';
-  /**
-   *  Is this Object a spy?
-   */
   this.isSpy = true;
-  /**
-   * The actual function this spy stubs.
-   */
   this.plan = function() {
   };
-  /**
-   * Tracking of the most recent call to the spy.
-   * @example
-   * var mySpy = jasmine.createSpy('foo');
-   * mySpy(1, 2);
-   * mySpy.mostRecentCall.args = [1, 2];
-   */
   this.mostRecentCall = {};
 
-  /**
-   * Holds arguments for each call to the spy, indexed by call count
-   * @example
-   * var mySpy = jasmine.createSpy('foo');
-   * mySpy(1, 2);
-   * mySpy(7, 8);
-   * mySpy.mostRecentCall.args = [7, 8];
-   * mySpy.argsForCall[0] = [1, 2];
-   * mySpy.argsForCall[1] = [7, 8];
-   */
   this.argsForCall = [];
   this.calls = [];
 };
 
-/**
- * Tells a spy to call through to the actual implemenatation.
- *
- * @example
- * var foo = {
- *   bar: function() { // do some stuff }
- * }
- *
- * // defining a spy on an existing property: foo.bar
- * spyOn(foo, 'bar').andCallThrough();
- */
 jasmine.Spy.prototype.andCallThrough = function() {
   this.plan = this.originalValue;
   return this;
 };
 
-/**
- * For setting the return value of a spy.
- *
- * @example
- * // defining a spy from scratch: foo() returns 'baz'
- * var foo = jasmine.createSpy('spy on foo').andReturn('baz');
- *
- * // defining a spy on an existing property: foo.bar() returns 'baz'
- * spyOn(foo, 'bar').andReturn('baz');
- *
- * @param {Object} value
- */
 jasmine.Spy.prototype.andReturn = function(value) {
   this.plan = function() {
     return value;
@@ -259,18 +84,6 @@ jasmine.Spy.prototype.andReturn = function(value) {
   return this;
 };
 
-/**
- * For throwing an exception when a spy is called.
- *
- * @example
- * // defining a spy from scratch: foo() throws an exception w/ message 'ouch'
- * var foo = jasmine.createSpy('spy on foo').andThrow('baz');
- *
- * // defining a spy on an existing property: foo.bar() throws an exception w/ message 'ouch'
- * spyOn(foo, 'bar').andThrow('baz');
- *
- * @param {String} exceptionMsg
- */
 jasmine.Spy.prototype.andThrow = function(exceptionMsg) {
   this.plan = function() {
     throw exceptionMsg;
@@ -278,40 +91,11 @@ jasmine.Spy.prototype.andThrow = function(exceptionMsg) {
   return this;
 };
 
-/**
- * Calls an alternate implementation when a spy is called.
- *
- * @example
- * var baz = function() {
- *   // do some stuff, return something
- * }
- * // defining a spy from scratch: foo() calls the function baz
- * var foo = jasmine.createSpy('spy on foo').andCall(baz);
- *
- * // defining a spy on an existing property: foo.bar() calls an anonymnous function
- * spyOn(foo, 'bar').andCall(function() { return 'baz';} );
- *
- * @param {Function} fakeFunc
- */
 jasmine.Spy.prototype.andCallFake = function(fakeFunc) {
   this.plan = fakeFunc;
   return this;
 };
 
-/**
- * Resets all of a spy's the tracking variables so that it can be used again.
- *
- * @example
- * spyOn(foo, 'bar');
- *
- * foo.bar();
- *
- * expect(foo.bar.callCount).toEqual(1);
- *
- * foo.bar.reset();
- *
- * expect(foo.bar.callCount).toEqual(0);
- */
 jasmine.Spy.prototype.reset = function() {
   this.wasCalled = false;
   this.callCount = 0;
@@ -344,23 +128,10 @@ jasmine.createSpy = function(name) {
   return spyObj;
 };
 
-/**
- * Determines whether an object is a spy.
- *
- * @param {jasmine.Spy|Object} putativeSpy
- * @returns {Boolean}
- */
 jasmine.isSpy = function(putativeSpy) {
   return putativeSpy && putativeSpy.isSpy;
 };
 
-/**
- * Creates a more complicated spy: an Object that has every property a function that is a spy.  Used for stubbing something
- * large in one call.
- *
- * @param {String} baseName name of spy class
- * @param {Array} methodNames array of names of methods to make spies
- */
 jasmine.createSpyObj = function(baseName, methodNames) {
   if (!jasmine.isArray_(methodNames) || methodNames.length === 0) {
     throw new Error('createSpyObj requires a non-empty array of method names to create spies for');