First step in order to redo the generated site

Author: BonsaiDen

doc/arrayctor.md renamed to doc/array/constructor.md

@@ -1,17 +1,17 @@
-## Arrays
+## Array iteration and properties
 
 Although arrays in JavaScript are objects, there are no good reasons to use
-the [for in loop](#forinloop) in for iteration on them. In fact there are a 
-number of good reasons **against** the use of `for in` on arrays.
+the [for in loop](#object.forinloop) in for iteration on them. In fact there are 
+a  number of good reasons **against** the use of `for in` on arrays.
 
 > **Note:** JavaScript arrays are **not** *associative arrays*. JavaScript only 
-> has [objects](#objects) for mapping keys to values. And while associative 
+> has [objects](#object.general) for mapping keys to values. And while associative 
 > arrays **preserve** order, objects do **not**.
 
 Since the `for in` loop enumerates all properties on the prototype chain and 
 the only way to exclude those properties is to use 
-[`hasOwnProperty`](#hasownproperty), it is already up to **twenty times** slower
-than a normal `for` loop.
+[`hasOwnProperty`](#object.hasownproperty), it is already up to **twenty times**
+slower than a normal `for` loop.
 
 ### Iteration
 

doc/arrays.md renamed to doc/array/general.md

@@ -29,9 +29,9 @@ achieved **without** it.
 
 ### `eval` in disguise
 
-The [timeout functions](#timeouts) `setTimeout` and `setInterval` can both take a string as
-their first argument. This string will **always** get executed in the global 
-scope since `eval` is not being called directly in that case.
+The [timeout functions](#other.timeouts) `setTimeout` and `setInterval` can both 
+take a string as their first argument. This string will **always** get executed 
+in the global scope since `eval` is not being called directly in that case.
 
 ### Security issues
 

doc/eval.md renamed to doc/core/eval.md

@@ -31,7 +31,7 @@ necessary to retrieve the value of `undefined` in the first place.
 
 In order to protect code against a possible overwritten `undefined` variable, a 
 common technique used is to add an additional parameter to the encapsulation
-[anonymous wrapper](#scopes), which gets no argument passed to it.
+[anonymous wrapper](#function.scopes), which gets no argument passed to it.
 
     var undefined = 123;
     (function(something, foo, undefined) {

doc/semicolon.md renamed to doc/core/semicolon.md

@@ -3,7 +3,7 @@
 One of JavaScript's most powerful features is the availability of *closures*,
 this means that scopes **always** keep access to the outer scope they were
 defined in. Since the only scope that JavaScript has is the 
-[function scope](#scopes), all functions, by default, act as closures.
+[function scope](#function.scopes), all functions, by default, act as closures.
 
 ### Emulating private variables
 
@@ -67,7 +67,7 @@ the value of `i`.
 ### Avoiding the reference problem
 
 In order to copy the value of the loop its index variable, it is best to use an 
-[anonymous wrapper](#scopes).
+[anonymous wrapper](#function.scopes).
 
     for(var i = 0; i < 10; i++) {
         (function(e) {

doc/undefined.md renamed to doc/core/undefined.md

@@ -4,8 +4,8 @@ Constructors in JavaScript are yet again different from many other languages. An
 function call that is preceded by the `new` keyword acts as a constructor.
 
 Inside the constructor (the called function) the value of `this` refers to a 
-newly created `Object`. The [`prototype`](#prototype) of this **new** object is 
-set to the `prototype` of the function object that was called.
+newly created `Object`. The [`prototype`](#object.prototype) of this **new** 
+object is set to the `prototype` of the function object that was called.
 
 If the function that was called has no explicit `return` statement, then it
 implicitly returns the value of `this` (the new object). Otherwise it returns
@@ -27,8 +27,8 @@ created object to `Foo.prototype`.
 
 Keep in mind that if you do not use the `new` keyword the function will **not**
 return a new object. While it might still work due to the workings of
-[`this`](#how-this-works-in-javascript) in JavaScript, it will use the *global*
-object as the value of `this`.
+[`this`](#function.this) in JavaScript, it will use the *global* object as the 
+value of `this`.
 
 ### Factories
 
@@ -51,7 +51,7 @@ explicitly return a value.
     Bar();
 
 Both these calls return the exact same thing, a newly create object which
-has a property called `method` which is a [Closure](#closures-and-references).
+has a property called `method` which is a [Closure](#function.closures).
 
 Also note that the call `new Bar()` does **not** affect the prototype of the
 returned object. While the prototype will be set on the newly created object,
@@ -85,7 +85,7 @@ object inside it.
     }
 
 While the above is robust against forgetting to use `new` and makes the use of
-[private variables](#closures) certainly easier, it comes with some down sides.
+[private variables](#function.closures) certainly easier, it comes with some down sides.
 
  1. It uses more memory since the created objects do **not** share the methods
  2. In order to inherit the factory needs to copy all the methods from another

doc/arguments.md renamed to doc/function/arguments.md

@@ -1,4 +1,4 @@
-## Functions
+## Function declarations and expressions
 
 Functions in JavaScript are first class objects, which means that they can be 
 passed around like any other value. One common use of this feature is to pass
@@ -30,7 +30,7 @@ declaration - creates the variable `foo` before the actual execution of the code
 starts, `foo` is already defined when the script gets executed.
 
 Since assignments only happens at runtime, the value of `Foo` will default
-to [undefined](#undefined) before the corresponding code is executed.
+to [undefined](#core.undefined) before the corresponding code is executed.
 
 ### Named function expression
 
@@ -43,7 +43,7 @@ Another special case is the assignment of named functions.
 
 Here `bar` is not available in the outer scope, since the function only gets
 assigned to `foo`; however, inside of `bar` it **is** available. This is due to 
-how [name resolution](#scopes) in JavaScript works, the name of the function
+how [name resolution](#function.scopes) in JavaScript works, the name of the function
 is always made available in the local scope of the function itself.
 
 ### The `var` statement
@@ -62,8 +62,8 @@ is always made available in the local scope of the function itself.
         var foo = 1;
     }
 
-Since there is **no** [block scope](#scopes) in JavaScript, the above will
-**not** assign the value `2` to the *global* variable `bar`. It will rather 
+Since there is **no** [block scope](#function.scopes) in JavaScript, the above 
+will **not** assign the value `2` to the *global* variable `bar`. It will rather 
 assign the value of `2` to the *local* variable `bar` of `test`. 
 
 Also, while the statements inside the `if` block never get executed, the variable

doc/closures.md renamed to doc/function/closures.md

@@ -14,7 +14,7 @@ is in the language is *function scope*.
 > **Note:** When not used in an assignment, return statement or as a function 
 > argument, the `{...}` notation will get interpreted as a block statement and 
 > **not** as an object literal. This, in conjunction with 
-> [automatic insertion of semicolons](#semicolon), can lead to subtle errors.
+> [automatic insertion of semicolons](#core.semicolon), can lead to subtle errors.
 
 There are also no distinct namespaces in JavaScript. This means that everything 
 gets defined in **one** globally shared namespace.
@@ -72,8 +72,9 @@ unless the desired effect **is** to affect the outer scope.
 
 ### Local variables
 
-The only source for local variables in JavaScript are [function](#functions)
-parameters and variables that were declared via the `var` statement.
+The only source for local variables in JavaScript are
+[function](#function.general) parameters and variables that were declared via the
+`var` statement.
 
     // global scope
     var foo = 1;
@@ -95,9 +96,9 @@ the assignment of `bar` will override the global variable with the same name.
 ### Name resolution order
 
 All scopes in JavaScript - including the global one - have the name 
-[this](#this) defined in them, which refers to the  "current object". 
+[this](#function.this) defined in them, which refers to the  "current object". 
 
-Function scopes also have the name [arguments](#arguments) defined, which 
+Function scopes also have the name [arguments](#function.arguments) defined, which 
 contains the arguments that were passed to a function.
 
 For example, when trying to access a variable named `foo` inside the scope of a 
@@ -127,8 +128,8 @@ easily avoided with the help of anonymous *function wrappers*.
     })(); // execute the function immediately
 
 
-Unnamed functions are considered [expressions](#functions); so in order to being
-callable, they must first be evaluated.
+Unnamed functions are considered [expressions](#function.general); so in order to
+being callable, they must first be evaluated.
 
     ( // evaluate the function inside the paranthesis
     function() {}

doc/constructors.md renamed to doc/function/constructors.md

@@ -1,8 +1,8 @@
 ## How `this` works
 
 JavaScript has a different concept of what `this` refers to than most other
-languages do. There are exactly **five** different ways in which the value of `this` 
-can be bound in the language.
+languages do. There are exactly **five** different ways in which the value of 
+`this` can be bound in the language.
 
 ### The global scope
 
@@ -17,8 +17,8 @@ When using `this` in global scope, it will simply refer to the *global* object.
 
 Here `this` will again refer to the *global* object.
 
-> **ES5 Note:** In strict mode, `this` will **no longer** refer to the global object. 
-> It will instead have the value of `undefined`.
+> **ES5 Note:** In strict mode, `this` will **no longer** refer to the global 
+> object. It will instead have the value of `undefined`.
 
 ### Calling a method
 
@@ -31,8 +31,8 @@ In this example `this` will refer to `test`.
     new foo(); 
 
 A function call that is preceded by the `new` keyword acts as
-a [constructor](#constructors). Inside the function `this` will refer to a newly
-created `Object`.
+a [constructor](#function.constructors). Inside the function `this` will refer 
+to a newly created `Object`.
 
 ### Explicit setting of `this`
 
@@ -80,8 +80,8 @@ local variable inside of `method` which refers to `Foo`.
     }
 
 `that` is just a normal name, but it is commonly used for the reference to an 
-outer `this`. In combination with [closures](#closures), it can also be used to 
-pass `this` values around.
+outer `this`. In combination with [closures](#function.closures), it can also 
+be used to pass `this` values around.
 
 ### Assigning methods
 
@@ -95,7 +95,7 @@ Again due to the first case `test` now acts like like a plain function call;
 therefore, `this` inside it will no longer refer to `someObject`.
 
 While the late binding of `this` might seem like a bad idea, it is in fact what
-makes [prototypical inheritance](#prototype) work. 
+makes [prototypical inheritance](#object.prototype) work. 
 
     function Foo() {}
     Foo.prototype.method = function() {};

doc/functions.md renamed to doc/function/general.md

@@ -0,0 +1,66 @@
+{
+    "title": "JavaScript Garden",
+    "description": "A Guide to JavaScript's Quirks and Flaws.",
+    "sections": [
+        {
+            "title": "Intro",
+            "dir": "intro"
+        },
+        {
+            "title": "Objects",
+            "dir": "object",
+            "articles": [
+                "general",
+                "prototype",
+                "hasownproperty",
+                "forinloop"
+            ]
+        },
+        {
+            "title": "Functions",
+            "dir": "function",
+            "articles": [
+                "general",
+                "this",
+                "closures",
+                "arguments",
+                "constructors",
+                "scopes"
+            ]
+        },
+        {
+            "title": "Arrays",
+            "dir": "array",
+            "articles": [
+                "general",
+                "constructor"
+            ]
+        },
+        {
+            "title": "Types",
+            "dir": "types",
+            "articles": [
+                "equality",
+                "typeof",
+                "instanceof",
+                "casting"
+            ]
+        },
+        {
+            "title": "Core",
+            "dir": "core",
+            "articles": [
+                "eval",
+                "undefined",
+                "semicolon"
+            ]
+        },
+        {
+            "title": "Other",
+            "dir": "other",
+            "articles": [
+                "timeouts"
+            ]
+        }
+    ]
+}

doc/scopes.md renamed to doc/function/scopes.md

@@ -17,7 +17,7 @@ chain when iterating over the properties of an object.
 
 Since it is not possible to change the behavior of the `for in` loop itself, it
 is necessary to filter out the unwanted properties inside the loop body itself, 
-this is done by using the [`hasOwnProperty`](#hasownproperty) method of 
+this is done by using the [`hasOwnProperty`](#object.hasownproperty) method of 
 objects. 
 
 > **Note:** Since the `for in` always traverses the complete prototype chain, it

doc/this.md renamed to doc/function/this.md

@@ -1,7 +1,7 @@
-## Objects
+## Object usage and properties
 
 Everything in JavaScript acts like an object, with the only two exceptions being 
-[`null`](#undefined) and [`undefined`](#undefined).
+[`null`](#core.undefined) and [`undefined`](#core.undefined).
 
     false.toString() // 'false'
     [1, 2, 3].toString(); // '1,2,3'
@@ -29,8 +29,8 @@ Objects in JavaScript can also be used as a [*Hashmap*][1], they mainly consist
 of named properties mapping to values.
 
 Using the curly brace notation `{}` one can create a plain object. This new
-object [inherits](#prototype) from `Object.prototype` and has no 
-[own properties](#hasownproperty) defined on it.
+object [inherits](#object.prototype) from `Object.prototype` and has no 
+[own properties](#object.hasownproperty) defined on it.
 
     var foo = {}; // a new empty object
 
@@ -96,3 +96,4 @@ therefore, it must be notated as a string literal in order to ensure working
 code under older JavaScript engines.
 
 [1]: http://en.wikipedia.org/wiki/Hashmap
+

doc/globals.md

@@ -1,7 +1,7 @@
 ## `hasOwnProperty`
 
 In order to check whether a object has a property defined on itself and **not** 
-somewhere on its [prototype chain](#prototype), it is necessary to use the 
+somewhere on its [prototype chain](#object.prototype), it is necessary to use the 
 `hasOwnProperty` method which all objects inherit from `Object.prototype`.
 
 > **Note:** It is **not** enough to check whether a property is `undefined`. The
@@ -30,6 +30,6 @@ somewhere on its prototype chain.
 
 When checking for the existence of a property on a object, `hasOwnProperty` is 
 the **only** method of doing so. It is also recommended to make `hasOwnProperty`
-part of **every** [`for in` loop](#forinloop), this will avoid errors from 
-extended native [prototypes](#prototype).
+part of **every** [`for in` loop](#object.forinloop), this will avoid errors from 
+extended native [prototypes](#object.prototype).