new 0.0.6 → 0.0.7

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (88) hide show
  1. checksums.yaml +4 -4
  2. data/.gitmodules +3 -0
  3. data/.new +1 -1
  4. data/Gemfile.lock +25 -20
  5. data/Guardfile +6 -4
  6. data/README.md +9 -2
  7. data/doc/.git +1 -0
  8. data/doc/Gemfile.html +125 -0
  9. data/doc/Gemfile_lock.html +198 -0
  10. data/doc/Guardfile.html +134 -0
  11. data/doc/InterpolateSpec.html +116 -0
  12. data/doc/LICENSE_txt.html +132 -0
  13. data/doc/New/Cli.html +290 -0
  14. data/doc/New/Dsl.html +185 -0
  15. data/doc/New/Interpolate.html +238 -0
  16. data/doc/New/Project.html +171 -0
  17. data/doc/New/Task/CustomBarTask.html +154 -0
  18. data/doc/New/Task/FooTask.html +168 -0
  19. data/doc/New/Task/Gem.html +197 -0
  20. data/doc/New/Task/TaskSpec.html +168 -0
  21. data/doc/New/Task.html +380 -0
  22. data/doc/New/Template.html +234 -0
  23. data/doc/New/Version.html +277 -0
  24. data/doc/New.html +377 -0
  25. data/doc/Object.html +200 -0
  26. data/doc/README_md.html +292 -0
  27. data/doc/VersionSpec.html +116 -0
  28. data/doc/created.rid +47 -0
  29. data/doc/fonts/Lato-Light.ttf +0 -0
  30. data/doc/fonts/Lato-LightItalic.ttf +0 -0
  31. data/doc/fonts/Lato-Regular.ttf +0 -0
  32. data/doc/fonts/Lato-RegularItalic.ttf +0 -0
  33. data/doc/fonts/SourceCodePro-Bold.ttf +0 -0
  34. data/doc/fonts/SourceCodePro-Regular.ttf +0 -0
  35. data/doc/fonts.css +167 -0
  36. data/doc/images/add.png +0 -0
  37. data/doc/images/arrow_up.png +0 -0
  38. data/doc/images/brick.png +0 -0
  39. data/doc/images/brick_link.png +0 -0
  40. data/doc/images/bug.png +0 -0
  41. data/doc/images/bullet_black.png +0 -0
  42. data/doc/images/bullet_toggle_minus.png +0 -0
  43. data/doc/images/bullet_toggle_plus.png +0 -0
  44. data/doc/images/date.png +0 -0
  45. data/doc/images/delete.png +0 -0
  46. data/doc/images/find.png +0 -0
  47. data/doc/images/loadingAnimation.gif +0 -0
  48. data/doc/images/macFFBgHack.png +0 -0
  49. data/doc/images/package.png +0 -0
  50. data/doc/images/page_green.png +0 -0
  51. data/doc/images/page_white_text.png +0 -0
  52. data/doc/images/page_white_width.png +0 -0
  53. data/doc/images/plugin.png +0 -0
  54. data/doc/images/ruby.png +0 -0
  55. data/doc/images/tag_blue.png +0 -0
  56. data/doc/images/tag_green.png +0 -0
  57. data/doc/images/transparent.png +0 -0
  58. data/doc/images/wrench.png +0 -0
  59. data/doc/images/wrench_orange.png +0 -0
  60. data/doc/images/zoom.png +0 -0
  61. data/doc/index.html +142 -0
  62. data/doc/js/darkfish.js +140 -0
  63. data/doc/js/jquery.js +18 -0
  64. data/doc/js/navigation.js +142 -0
  65. data/doc/js/search.js +109 -0
  66. data/doc/js/search_index.js +1 -0
  67. data/doc/js/searcher.js +228 -0
  68. data/doc/rdoc.css +580 -0
  69. data/doc/spec/fixtures/custom/templates/custom_bar_template/custom_bar_txt.html +110 -0
  70. data/doc/table_of_contents.html +324 -0
  71. data/doc/tasks/gem/README_md.html +150 -0
  72. data/doc/templates/js/Gemfile.html +147 -0
  73. data/doc/templates/js/Guardfile.html +117 -0
  74. data/doc/templates/js/lib/README_md.html +114 -0
  75. data/doc/templates/js/spec/spec_helper_js_coffee.html +110 -0
  76. data/doc/templates/js/spec/vendor/chai_js.html +3864 -0
  77. data/doc/templates/js/spec/vendor/sinon-chai_js.html +222 -0
  78. data/doc/templates/js/spec/vendor/sinon_js.html +4358 -0
  79. data/doc/templates/js/src/README_md.html +125 -0
  80. data/lib/new/task.rb +2 -4
  81. data/lib/new/template.rb +1 -1
  82. data/lib/new/version.rb +27 -19
  83. data/spec/fixtures/tasks/foo_task/Gemfile +5 -0
  84. data/spec/lib/new/version_spec.rb +10 -15
  85. data/spec/spec_helper.rb +22 -1
  86. data/tasks/gem/gem.rb +44 -8
  87. data/tasks/gem/gem_spec.rb +139 -0
  88. metadata +233 -3
@@ -0,0 +1,3864 @@
1
+ <!DOCTYPE html>
2
+
3
+ <html>
4
+ <head>
5
+ <meta charset="UTF-8">
6
+
7
+ <title>chai.js - RDoc Documentation</title>
8
+
9
+ <link href="../../../../fonts.css" rel="stylesheet">
10
+ <link href="../../../../rdoc.css" rel="stylesheet">
11
+
12
+ <script type="text/javascript">
13
+ var rdoc_rel_prefix = "../../../../";
14
+ </script>
15
+
16
+ <script src="../../../../js/jquery.js"></script>
17
+ <script src="../../../../js/navigation.js"></script>
18
+ <script src="../../../../js/search_index.js"></script>
19
+ <script src="../../../../js/search.js"></script>
20
+ <script src="../../../../js/searcher.js"></script>
21
+ <script src="../../../../js/darkfish.js"></script>
22
+
23
+
24
+ <body id="top" role="document" class="file">
25
+ <nav role="navigation">
26
+ <div id="project-navigation">
27
+ <div id="home-section" role="region" title="Quick navigation" class="nav-section">
28
+ <h2>
29
+ <a href="../../../../index.html" rel="home">Home</a>
30
+ </h2>
31
+
32
+ <div id="table-of-contents-navigation">
33
+ <a href="../../../../table_of_contents.html#pages">Pages</a>
34
+ <a href="../../../../table_of_contents.html#classes">Classes</a>
35
+ <a href="../../../../table_of_contents.html#methods">Methods</a>
36
+ </div>
37
+ </div>
38
+
39
+ <div id="search-section" role="search" class="project-section initially-hidden">
40
+ <form action="#" method="get" accept-charset="utf-8">
41
+ <div id="search-field-wrapper">
42
+ <input id="search-field" role="combobox" aria-label="Search"
43
+ aria-autocomplete="list" aria-controls="search-results"
44
+ type="text" name="search" placeholder="Search" spellcheck="false"
45
+ title="Type to search, Up and Down to navigate, Enter to load">
46
+ </div>
47
+
48
+ <ul id="search-results" aria-label="Search Results"
49
+ aria-busy="false" aria-expanded="false"
50
+ aria-atomic="false" class="initially-hidden"></ul>
51
+ </form>
52
+ </div>
53
+
54
+ </div>
55
+
56
+
57
+
58
+ <div id="project-metadata">
59
+ <div id="fileindex-section" class="nav-section">
60
+ <h3>Pages</h3>
61
+
62
+ <ul class="link-list">
63
+
64
+ <li><a href="../../../../Gemfile.html">Gemfile</a>
65
+
66
+ <li><a href="../../../../Gemfile_lock.html">Gemfile.lock</a>
67
+
68
+ <li><a href="../../../../Guardfile.html">Guardfile</a>
69
+
70
+ <li><a href="../../../../LICENSE_txt.html">LICENSE</a>
71
+
72
+ <li><a href="../../../../README_md.html">README</a>
73
+
74
+ <li><a href="../../../../spec/fixtures/custom/templates/custom_bar_template/custom_bar_txt.html">custom_bar</a>
75
+
76
+ <li><a href="../../../../tasks/gem/README_md.html">README</a>
77
+
78
+ <li><a href="../../../../templates/js/Gemfile.html">Gemfile</a>
79
+
80
+ <li><a href="../../../../templates/js/Guardfile.html">Guardfile</a>
81
+
82
+ <li><a href="../../../../templates/js/lib/README_md.html">README</a>
83
+
84
+ <li><a href="../../../../templates/js/spec/spec_helper_js_coffee.html">spec_helper.js.coffee</a>
85
+
86
+ <li><a href="../../../../templates/js/spec/vendor/chai_js.html">chai.js</a>
87
+
88
+ <li><a href="../../../../templates/js/spec/vendor/sinon-chai_js.html">sinon-chai.js</a>
89
+
90
+ <li><a href="../../../../templates/js/spec/vendor/sinon_js.html">sinon.js</a>
91
+
92
+ <li><a href="../../../../templates/js/src/README_md.html">README</a>
93
+
94
+ </ul>
95
+ </div>
96
+
97
+ </div>
98
+ </nav>
99
+
100
+ <main role="main" aria-label="Page templates/js/spec/vendor/chai.js">
101
+
102
+ <p>! function(name, context, definition) {</p>
103
+
104
+ <pre class="ruby"><span class="ruby-keyword">if</span> (<span class="ruby-identifier">typeof</span> <span class="ruby-identifier">require</span> <span class="ruby-operator">===</span> <span class="ruby-string">&#39;function&#39;</span> <span class="ruby-operator">&amp;&amp;</span> <span class="ruby-identifier">typeof</span> <span class="ruby-identifier">exports</span> <span class="ruby-operator">===</span> <span class="ruby-string">&#39;object&#39;</span> <span class="ruby-operator">&amp;&amp;</span> <span class="ruby-identifier">typeof</span> <span class="ruby-identifier">module</span> <span class="ruby-operator">===</span> <span class="ruby-string">&#39;object&#39;</span>) {
105
+ <span class="ruby-keyword">module</span>.<span class="ruby-identifier">exports</span> = <span class="ruby-identifier">definition</span>();
106
+ } <span class="ruby-keyword">else</span> <span class="ruby-keyword">if</span> (<span class="ruby-identifier">typeof</span> <span class="ruby-identifier">define</span> <span class="ruby-operator">===</span> <span class="ruby-string">&#39;function&#39;</span> <span class="ruby-operator">&amp;&amp;</span> <span class="ruby-identifier">typeof</span> <span class="ruby-identifier">define</span>.<span class="ruby-identifier">amd</span> <span class="ruby-operator">===</span> <span class="ruby-string">&#39;object&#39;</span>) {
107
+ <span class="ruby-identifier">define</span>(<span class="ruby-identifier">function</span>() {
108
+ <span class="ruby-keyword">return</span> <span class="ruby-identifier">definition</span>();
109
+ });
110
+ } <span class="ruby-keyword">else</span> {
111
+ <span class="ruby-identifier">context</span>[<span class="ruby-identifier">name</span>] = <span class="ruby-identifier">definition</span>();
112
+ }
113
+ </pre>
114
+
115
+ <p>}(&#39;chai&#39;, this, function() {</p>
116
+
117
+ <pre class="ruby"><span class="ruby-identifier">function</span> <span class="ruby-identifier">require</span>(<span class="ruby-identifier">p</span>) {
118
+ <span class="ruby-identifier">var</span> <span class="ruby-identifier">path</span> = <span class="ruby-identifier">require</span>.<span class="ruby-identifier">resolve</span>(<span class="ruby-identifier">p</span>),
119
+ <span class="ruby-identifier">mod</span> = <span class="ruby-identifier">require</span>.<span class="ruby-identifier">modules</span>[<span class="ruby-identifier">path</span>];
120
+ <span class="ruby-keyword">if</span> (<span class="ruby-operator">!</span><span class="ruby-identifier">mod</span>) <span class="ruby-identifier">throw</span> <span class="ruby-identifier">new</span> <span class="ruby-constant">Error</span>(<span class="ruby-string">&#39;failed to require &quot;&#39;</span> <span class="ruby-operator">+</span> <span class="ruby-identifier">p</span> <span class="ruby-operator">+</span> <span class="ruby-string">&#39;&quot;&#39;</span>);
121
+ <span class="ruby-keyword">if</span> (<span class="ruby-operator">!</span><span class="ruby-identifier">mod</span>.<span class="ruby-identifier">exports</span>) {
122
+ <span class="ruby-identifier">mod</span>.<span class="ruby-identifier">exports</span> = {};
123
+ <span class="ruby-identifier">mod</span>.<span class="ruby-identifier">call</span>(<span class="ruby-identifier">mod</span>.<span class="ruby-identifier">exports</span>, <span class="ruby-identifier">mod</span>, <span class="ruby-identifier">mod</span>.<span class="ruby-identifier">exports</span>, <span class="ruby-identifier">require</span>.<span class="ruby-identifier">relative</span>(<span class="ruby-identifier">path</span>));
124
+ }
125
+ <span class="ruby-keyword">return</span> <span class="ruby-identifier">mod</span>.<span class="ruby-identifier">exports</span>;
126
+ }
127
+
128
+ <span class="ruby-identifier">require</span>.<span class="ruby-identifier">modules</span> = {};
129
+
130
+ <span class="ruby-identifier">require</span>.<span class="ruby-identifier">resolve</span> = <span class="ruby-identifier">function</span>(<span class="ruby-identifier">path</span>) {
131
+ <span class="ruby-identifier">var</span> <span class="ruby-identifier">orig</span> = <span class="ruby-identifier">path</span>,
132
+ <span class="ruby-identifier">reg</span> = <span class="ruby-identifier">path</span> <span class="ruby-operator">+</span> <span class="ruby-string">&#39;.js&#39;</span>,
133
+ <span class="ruby-identifier">index</span> = <span class="ruby-identifier">path</span> <span class="ruby-operator">+</span> <span class="ruby-string">&#39;/index.js&#39;</span>;
134
+ <span class="ruby-keyword">return</span> <span class="ruby-identifier">require</span>.<span class="ruby-identifier">modules</span>[<span class="ruby-identifier">reg</span>] <span class="ruby-operator">&amp;&amp;</span> <span class="ruby-identifier">reg</span> <span class="ruby-operator">||</span> <span class="ruby-identifier">require</span>.<span class="ruby-identifier">modules</span>[<span class="ruby-identifier">index</span>] <span class="ruby-operator">&amp;&amp;</span> <span class="ruby-identifier">index</span> <span class="ruby-operator">||</span> <span class="ruby-identifier">orig</span>;
135
+ };
136
+
137
+ <span class="ruby-identifier">require</span>.<span class="ruby-identifier">register</span> = <span class="ruby-identifier">function</span>(<span class="ruby-identifier">path</span>, <span class="ruby-identifier">fn</span>) {
138
+ <span class="ruby-identifier">require</span>.<span class="ruby-identifier">modules</span>[<span class="ruby-identifier">path</span>] = <span class="ruby-identifier">fn</span>;
139
+ };
140
+
141
+ <span class="ruby-identifier">require</span>.<span class="ruby-identifier">relative</span> = <span class="ruby-identifier">function</span>(<span class="ruby-identifier">parent</span>) {
142
+ <span class="ruby-keyword">return</span> <span class="ruby-identifier">function</span>(<span class="ruby-identifier">p</span>) {
143
+ <span class="ruby-keyword">if</span> (<span class="ruby-string">&#39;.&#39;</span> <span class="ruby-operator">!=</span> <span class="ruby-identifier">p</span>.<span class="ruby-identifier">charAt</span>(<span class="ruby-value">0</span>)) <span class="ruby-keyword">return</span> <span class="ruby-identifier">require</span>(<span class="ruby-identifier">p</span>);
144
+
145
+ <span class="ruby-identifier">var</span> <span class="ruby-identifier">path</span> = <span class="ruby-identifier">parent</span>.<span class="ruby-identifier">split</span>(<span class="ruby-string">&#39;/&#39;</span>),
146
+ <span class="ruby-identifier">segs</span> = <span class="ruby-identifier">p</span>.<span class="ruby-identifier">split</span>(<span class="ruby-string">&#39;/&#39;</span>);
147
+ <span class="ruby-identifier">path</span>.<span class="ruby-identifier">pop</span>();
148
+
149
+ <span class="ruby-keyword">for</span> (<span class="ruby-identifier">var</span> <span class="ruby-identifier">i</span> = <span class="ruby-value">0</span>; <span class="ruby-identifier">i</span> <span class="ruby-operator">&lt;</span> <span class="ruby-identifier">segs</span>.<span class="ruby-identifier">length</span>; <span class="ruby-identifier">i</span><span class="ruby-operator">+</span><span class="ruby-operator">+</span>) {
150
+ <span class="ruby-identifier">var</span> <span class="ruby-identifier">seg</span> = <span class="ruby-identifier">segs</span>[<span class="ruby-identifier">i</span>];
151
+ <span class="ruby-keyword">if</span> (<span class="ruby-string">&#39;..&#39;</span> <span class="ruby-operator">==</span> <span class="ruby-identifier">seg</span>) <span class="ruby-identifier">path</span>.<span class="ruby-identifier">pop</span>();
152
+ <span class="ruby-keyword">else</span> <span class="ruby-keyword">if</span> (<span class="ruby-string">&#39;.&#39;</span> <span class="ruby-operator">!=</span> <span class="ruby-identifier">seg</span>) <span class="ruby-identifier">path</span>.<span class="ruby-identifier">push</span>(<span class="ruby-identifier">seg</span>);
153
+ }
154
+
155
+ <span class="ruby-keyword">return</span> <span class="ruby-identifier">require</span>(<span class="ruby-identifier">path</span>.<span class="ruby-identifier">join</span>(<span class="ruby-string">&#39;/&#39;</span>));
156
+ };
157
+ };
158
+
159
+ <span class="ruby-identifier">require</span>.<span class="ruby-identifier">alias</span> = <span class="ruby-identifier">function</span>(<span class="ruby-identifier">from</span>, <span class="ruby-identifier">to</span>) {
160
+ <span class="ruby-identifier">var</span> <span class="ruby-identifier">fn</span> = <span class="ruby-identifier">require</span>.<span class="ruby-identifier">modules</span>[<span class="ruby-identifier">from</span>];
161
+ <span class="ruby-identifier">require</span>.<span class="ruby-identifier">modules</span>[<span class="ruby-identifier">to</span>] = <span class="ruby-identifier">fn</span>;
162
+ };
163
+
164
+ <span class="ruby-identifier">require</span>.<span class="ruby-identifier">register</span>(<span class="ruby-string">&quot;chai.js&quot;</span>, <span class="ruby-identifier">function</span>(<span class="ruby-keyword">module</span>, <span class="ruby-identifier">exports</span>, <span class="ruby-identifier">require</span>) {
165
+ <span class="ruby-operator">!</span>
166
+ <span class="ruby-identifier">chai</span>
167
+ <span class="ruby-constant">Copyright</span>(<span class="ruby-identifier">c</span>) <span class="ruby-value">2011</span><span class="ruby-operator">-</span><span class="ruby-value">2013</span> <span class="ruby-constant">Jake</span> <span class="ruby-constant">Luer</span> <span class="ruby-operator">&lt;</span><span class="ruby-identifier">jake</span><span class="ruby-ivar">@alogicalparadox</span>.<span class="ruby-identifier">com</span><span class="ruby-operator">&gt;</span>
168
+ <span class="ruby-constant">MIT</span> <span class="ruby-constant">Licensed</span>
169
+
170
+ <span class="ruby-identifier">var</span> <span class="ruby-identifier">used</span> = [],
171
+ <span class="ruby-identifier">exports</span> = <span class="ruby-keyword">module</span>.<span class="ruby-identifier">exports</span> = {};
172
+
173
+ <span class="ruby-regexp">/*!
174
+ Chai version
175
+ /</span>
176
+
177
+ <span class="ruby-identifier">exports</span>.<span class="ruby-identifier">version</span> = <span class="ruby-string">&#39;1.5.0&#39;</span>;
178
+
179
+ <span class="ruby-regexp">/*!
180
+ Primary `Assertion` prototype
181
+ /</span>
182
+
183
+ <span class="ruby-identifier">exports</span>.<span class="ruby-constant">Assertion</span> = <span class="ruby-identifier">require</span>(<span class="ruby-string">&#39;./chai/assertion&#39;</span>);
184
+
185
+ <span class="ruby-regexp">/*!
186
+ Assertion Error
187
+ /</span>
188
+
189
+ <span class="ruby-identifier">exports</span>.<span class="ruby-constant">AssertionError</span> = <span class="ruby-identifier">require</span>(<span class="ruby-string">&#39;./chai/error&#39;</span>);
190
+
191
+ <span class="ruby-regexp">/*!
192
+ Utils for plugins (not exported)
193
+ /</span>
194
+
195
+ <span class="ruby-identifier">var</span> <span class="ruby-identifier">util</span> = <span class="ruby-identifier">require</span>(<span class="ruby-string">&#39;./chai/utils&#39;</span>);
196
+
197
+ <span class="ruby-node">/**
198
+ # .use(function)
199
+
200
+ Provides a way to extend the internals of Chai
201
+
202
+ @param {Function}
203
+ @returns {this} for chaining
204
+ @api public
205
+ /</span>
206
+
207
+ <span class="ruby-identifier">exports</span>.<span class="ruby-identifier">use</span> = <span class="ruby-identifier">function</span>(<span class="ruby-identifier">fn</span>) {
208
+ <span class="ruby-keyword">if</span> (<span class="ruby-operator">!~</span><span class="ruby-identifier">used</span>.<span class="ruby-identifier">indexOf</span>(<span class="ruby-identifier">fn</span>)) {
209
+ <span class="ruby-identifier">fn</span>(<span class="ruby-identifier">this</span>, <span class="ruby-identifier">util</span>);
210
+ <span class="ruby-identifier">used</span>.<span class="ruby-identifier">push</span>(<span class="ruby-identifier">fn</span>);
211
+ }
212
+
213
+ <span class="ruby-keyword">return</span> <span class="ruby-identifier">this</span>;
214
+ };
215
+
216
+ <span class="ruby-regexp">/*!
217
+ Core Assertions
218
+ /</span>
219
+
220
+ <span class="ruby-identifier">var</span> <span class="ruby-identifier">core</span> = <span class="ruby-identifier">require</span>(<span class="ruby-string">&#39;./chai/core/assertions&#39;</span>);
221
+ <span class="ruby-identifier">exports</span>.<span class="ruby-identifier">use</span>(<span class="ruby-identifier">core</span>);
222
+
223
+ <span class="ruby-regexp">/*!
224
+ Expect interface
225
+ /</span>
226
+
227
+ <span class="ruby-identifier">var</span> <span class="ruby-identifier">expect</span> = <span class="ruby-identifier">require</span>(<span class="ruby-string">&#39;./chai/interface/expect&#39;</span>);
228
+ <span class="ruby-identifier">exports</span>.<span class="ruby-identifier">use</span>(<span class="ruby-identifier">expect</span>);
229
+
230
+ <span class="ruby-regexp">/*!
231
+ Should interface
232
+ /</span>
233
+
234
+ <span class="ruby-identifier">var</span> <span class="ruby-identifier">should</span> = <span class="ruby-identifier">require</span>(<span class="ruby-string">&#39;./chai/interface/should&#39;</span>);
235
+ <span class="ruby-identifier">exports</span>.<span class="ruby-identifier">use</span>(<span class="ruby-identifier">should</span>);
236
+
237
+ <span class="ruby-regexp">/*!
238
+ Assert interface
239
+ /</span>
240
+
241
+ <span class="ruby-identifier">var</span> <span class="ruby-identifier">assert</span> = <span class="ruby-identifier">require</span>(<span class="ruby-string">&#39;./chai/interface/assert&#39;</span>);
242
+ <span class="ruby-identifier">exports</span>.<span class="ruby-identifier">use</span>(<span class="ruby-identifier">assert</span>);
243
+
244
+ }); <span class="ruby-regexp">//</span> <span class="ruby-identifier">module</span><span class="ruby-operator">:</span> <span class="ruby-identifier">chai</span>.<span class="ruby-identifier">js</span>
245
+ <span class="ruby-identifier">require</span>.<span class="ruby-identifier">register</span>(<span class="ruby-string">&quot;chai/assertion.js&quot;</span>, <span class="ruby-identifier">function</span>(<span class="ruby-keyword">module</span>, <span class="ruby-identifier">exports</span>, <span class="ruby-identifier">require</span>) {
246
+ <span class="ruby-regexp">/*!
247
+ chai
248
+ http:/</span><span class="ruby-operator">/</span><span class="ruby-identifier">chaijs</span>.<span class="ruby-identifier">com</span>
249
+ <span class="ruby-constant">Copyright</span>(<span class="ruby-identifier">c</span>) <span class="ruby-value">2011</span><span class="ruby-operator">-</span><span class="ruby-value">2013</span> <span class="ruby-constant">Jake</span> <span class="ruby-constant">Luer</span> <span class="ruby-operator">&lt;</span><span class="ruby-identifier">jake</span><span class="ruby-ivar">@alogicalparadox</span>.<span class="ruby-identifier">com</span><span class="ruby-operator">&gt;</span>
250
+ <span class="ruby-constant">MIT</span> <span class="ruby-constant">Licensed</span>
251
+ <span class="ruby-regexp">/
252
+
253
+ /</span><span class="ruby-operator">*</span><span class="ruby-operator">!</span>
254
+ <span class="ruby-constant">Module</span> <span class="ruby-identifier">dependencies</span>.
255
+ <span class="ruby-operator">/</span>
256
+
257
+ <span class="ruby-identifier">var</span> <span class="ruby-constant">AssertionError</span> = <span class="ruby-identifier">require</span>(<span class="ruby-string">&#39;./error&#39;</span>),
258
+ <span class="ruby-identifier">util</span> = <span class="ruby-identifier">require</span>(<span class="ruby-string">&#39;./utils&#39;</span>),
259
+ <span class="ruby-identifier">flag</span> = <span class="ruby-identifier">util</span>.<span class="ruby-identifier">flag</span>;
260
+
261
+ <span class="ruby-regexp">/*!
262
+ Module export.
263
+ /</span>
264
+
265
+ <span class="ruby-keyword">module</span>.<span class="ruby-identifier">exports</span> = <span class="ruby-constant">Assertion</span>;
266
+
267
+ <span class="ruby-regexp">/*!
268
+ Assertion Constructor
269
+
270
+ Creates object for chaining.
271
+
272
+ @api private
273
+ /</span>
274
+
275
+ <span class="ruby-identifier">function</span> <span class="ruby-constant">Assertion</span>(<span class="ruby-identifier">obj</span>, <span class="ruby-identifier">msg</span>, <span class="ruby-identifier">stack</span>) {
276
+ <span class="ruby-identifier">flag</span>(<span class="ruby-identifier">this</span>, <span class="ruby-string">&#39;ssfi&#39;</span>, <span class="ruby-identifier">stack</span> <span class="ruby-operator">||</span> <span class="ruby-identifier">arguments</span>.<span class="ruby-identifier">callee</span>);
277
+ <span class="ruby-identifier">flag</span>(<span class="ruby-identifier">this</span>, <span class="ruby-string">&#39;object&#39;</span>, <span class="ruby-identifier">obj</span>);
278
+ <span class="ruby-identifier">flag</span>(<span class="ruby-identifier">this</span>, <span class="ruby-string">&#39;message&#39;</span>, <span class="ruby-identifier">msg</span>);
279
+ }
280
+
281
+ <span class="ruby-node">/*!
282
+ ### Assertion.includeStack
283
+
284
+ User configurable property, influences whether stack trace
285
+ is included in Assertion error message. Default of false
286
+ suppresses stack trace in the error message
287
+
288
+ Assertion.includeStack = true; /</span><span class="ruby-operator">/</span> <span class="ruby-identifier">enable</span> <span class="ruby-identifier">stack</span> <span class="ruby-identifier">on</span> <span class="ruby-identifier">error</span>
289
+
290
+ <span class="ruby-ivar">@api</span> <span class="ruby-identifier">public</span>
291
+ <span class="ruby-regexp">/
292
+
293
+ Assertion.includeStack = false;
294
+
295
+ /</span><span class="ruby-operator">*</span><span class="ruby-operator">!</span>
296
+ <span class="ruby-comment">### Assertion.showDiff</span>
297
+
298
+ <span class="ruby-constant">User</span> <span class="ruby-identifier">configurable</span> <span class="ruby-identifier">property</span>, <span class="ruby-identifier">influences</span> <span class="ruby-identifier">whether</span> <span class="ruby-keyword">or</span> <span class="ruby-keyword">not</span>
299
+ <span class="ruby-identifier">the</span> <span class="ruby-value">%xshowDiff`</span> <span class="ruby-identifier">flag</span> <span class="ruby-identifier">should</span> <span class="ruby-identifier">be</span> <span class="ruby-identifier">included</span> <span class="ruby-keyword">in</span> <span class="ruby-identifier">the</span> <span class="ruby-identifier">thrown</span>
300
+ <span class="ruby-constant">AssertionErrors</span>. <span class="ruby-value">%xfalse`</span> <span class="ruby-identifier">will</span> <span class="ruby-identifier">always</span> <span class="ruby-identifier">be</span> <span class="ruby-value">%xfalse`</span>; <span class="ruby-value">%xtrue`</span>
301
+ <span class="ruby-identifier">will</span> <span class="ruby-identifier">be</span> <span class="ruby-keyword">true</span> <span class="ruby-keyword">when</span> <span class="ruby-identifier">the</span> <span class="ruby-identifier">assertion</span> <span class="ruby-identifier">has</span> <span class="ruby-identifier">requested</span> <span class="ruby-identifier">a</span> <span class="ruby-identifier">diff</span>
302
+ <span class="ruby-identifier">be</span> <span class="ruby-identifier">shown</span>.
303
+
304
+ <span class="ruby-ivar">@api</span> <span class="ruby-identifier">public</span>
305
+ <span class="ruby-regexp">/
306
+
307
+ Assertion.showDiff = true;
308
+
309
+ Assertion.addProperty = function(name, fn) {
310
+ util.addProperty(this.prototype, name, fn);
311
+ };
312
+
313
+ Assertion.addMethod = function(name, fn) {
314
+ util.addMethod(this.prototype, name, fn);
315
+ };
316
+
317
+ Assertion.addChainableMethod = function(name, fn, chainingBehavior) {
318
+ util.addChainableMethod(this.prototype, name, fn, chainingBehavior);
319
+ };
320
+
321
+ Assertion.overwriteProperty = function(name, fn) {
322
+ util.overwriteProperty(this.prototype, name, fn);
323
+ };
324
+
325
+ Assertion.overwriteMethod = function(name, fn) {
326
+ util.overwriteMethod(this.prototype, name, fn);
327
+ };
328
+
329
+ /</span><span class="ruby-operator">*</span><span class="ruby-operator">!</span>
330
+ <span class="ruby-comment">### .assert(expression, message, negateMessage, expected, actual)</span>
331
+
332
+ <span class="ruby-constant">Executes</span> <span class="ruby-identifier">an</span> <span class="ruby-identifier">expression</span> <span class="ruby-keyword">and</span> <span class="ruby-identifier">check</span> <span class="ruby-identifier">expectations</span>. <span class="ruby-constant">Throws</span> <span class="ruby-constant">AssertionError</span> <span class="ruby-keyword">for</span> <span class="ruby-identifier">reporting</span> <span class="ruby-keyword">if</span> <span class="ruby-identifier">test</span> <span class="ruby-identifier">doesn</span><span class="ruby-string">&#39;t pass.
333
+
334
+ @name assert
335
+ @param {Philosophical} expression to be tested
336
+ @param {String} message to display if fails
337
+ @param {String} negatedMessage to display if negated expression fails
338
+ @param {Mixed} expected value (remember to check for negation)
339
+ @param {Mixed} actual (optional) will default to `this.obj`
340
+ @api private
341
+ /
342
+
343
+ Assertion.prototype.assert = function(expr, msg, negateMsg, expected, _actual, showDiff) {
344
+ var ok = util.test(this, arguments);
345
+ if (true !== showDiff) showDiff = false;
346
+ if (true !== Assertion.showDiff) showDiff = false;
347
+
348
+ if (!ok) {
349
+ var msg = util.getMessage(this, arguments),
350
+ actual = util.getActual(this, arguments);
351
+ throw new AssertionError({
352
+ message: msg,
353
+ actual: actual,
354
+ expected: expected,
355
+ stackStartFunction: (Assertion.includeStack) ? this.assert : flag(this, &#39;</span><span class="ruby-identifier">ssfi</span><span class="ruby-string">&#39;),
356
+ showDiff: showDiff
357
+ });
358
+ }
359
+ };
360
+
361
+ /*!
362
+ ### ._obj
363
+
364
+ Quick reference to stored `actual` value for plugin developers.
365
+
366
+ @api private
367
+ /
368
+
369
+ Object.defineProperty(Assertion.prototype, &#39;</span><span class="ruby-identifier">_obj</span><span class="ruby-string">&#39;, {
370
+ get: function() {
371
+ return flag(this, &#39;</span><span class="ruby-identifier">object</span><span class="ruby-string">&#39;);
372
+ },
373
+ set: function(val) {
374
+ flag(this, &#39;</span><span class="ruby-identifier">object</span><span class="ruby-string">&#39;, val);
375
+ }
376
+ });
377
+
378
+ }); // module: chai/assertion.js
379
+ require.register(&quot;chai/core/assertions.js&quot;, function(module, exports, require) {
380
+ /*!
381
+ chai
382
+ http://chaijs.com
383
+ Copyright(c) 2011-2013 Jake Luer &lt;jake@alogicalparadox.com&gt;
384
+ MIT Licensed
385
+ /
386
+
387
+ module.exports = function(chai, _) {
388
+ var Assertion = chai.Assertion,
389
+ toString = Object.prototype.toString,
390
+ flag = _.flag;
391
+
392
+ /**
393
+ ### Language Chains
394
+
395
+ The following are provide as chainable getters to
396
+ improve the readability of your assertions. They
397
+ do not provide an testing capability unless they
398
+ have been overwritten by a plugin.
399
+
400
+ **Chains**
401
+
402
+ - to
403
+ - be
404
+ - been
405
+ - is
406
+ - that
407
+ - and
408
+ - have
409
+ - with
410
+ - at
411
+ - of
412
+
413
+ @name language chains
414
+ @api public
415
+ /
416
+
417
+ [&#39;</span><span class="ruby-identifier">to</span><span class="ruby-string">&#39;, &#39;</span><span class="ruby-identifier">be</span><span class="ruby-string">&#39;, &#39;</span><span class="ruby-identifier">been</span><span class="ruby-string">&#39;, &#39;</span><span class="ruby-identifier">is</span><span class="ruby-string">&#39;, &#39;</span><span class="ruby-keyword">and</span><span class="ruby-string">&#39;, &#39;</span><span class="ruby-identifier">have</span><span class="ruby-string">&#39;, &#39;</span><span class="ruby-identifier">with</span><span class="ruby-string">&#39;, &#39;</span><span class="ruby-identifier">that</span><span class="ruby-string">&#39;, &#39;</span><span class="ruby-identifier">at</span><span class="ruby-string">&#39;, &#39;</span><span class="ruby-identifier">of</span><span class="ruby-string">&#39;].forEach(function(chain) {
418
+ Assertion.addProperty(chain, function() {
419
+ return this;
420
+ });
421
+ });
422
+
423
+ /**
424
+ ### .not
425
+
426
+ Negates any of assertions following in the chain.
427
+
428
+ expect(foo).to.not.equal(&#39;</span><span class="ruby-identifier">bar</span><span class="ruby-string">&#39;);
429
+ expect(goodFn).to.not.throw(Error);
430
+ expect({ foo: &#39;</span><span class="ruby-identifier">baz</span><span class="ruby-string">&#39; }).to.have.property(&#39;</span><span class="ruby-identifier">foo</span><span class="ruby-string">&#39;)
431
+ .and.not.equal(&#39;</span><span class="ruby-identifier">bar</span><span class="ruby-string">&#39;);
432
+
433
+ @name not
434
+ @api public
435
+ /
436
+
437
+ Assertion.addProperty(&#39;</span><span class="ruby-keyword">not</span><span class="ruby-string">&#39;, function() {
438
+ flag(this, &#39;</span><span class="ruby-identifier">negate</span><span class="ruby-string">&#39;, true);
439
+ });
440
+
441
+ /**
442
+ ### .deep
443
+
444
+ Sets the `deep` flag, later used by the `equal` and
445
+ `property` assertions.
446
+
447
+ expect(foo).to.deep.equal({ bar: &#39;</span><span class="ruby-identifier">baz</span><span class="ruby-string">&#39; });
448
+ expect({ foo: { bar: { baz: &#39;</span><span class="ruby-identifier">quux</span><span class="ruby-string">&#39; } } })
449
+ .to.have.deep.property(&#39;</span><span class="ruby-identifier">foo</span>.<span class="ruby-identifier">bar</span>.<span class="ruby-identifier">baz</span><span class="ruby-string">&#39;, &#39;</span><span class="ruby-identifier">quux</span><span class="ruby-string">&#39;);
450
+
451
+ @name deep
452
+ @api public
453
+ /
454
+
455
+ Assertion.addProperty(&#39;</span><span class="ruby-identifier">deep</span><span class="ruby-string">&#39;, function() {
456
+ flag(this, &#39;</span><span class="ruby-identifier">deep</span><span class="ruby-string">&#39;, true);
457
+ });
458
+
459
+ /**
460
+ ### .a(type)
461
+
462
+ The `a` and `an` assertions are aliases that can be
463
+ used either as language chains or to assert a value&#39;</span><span class="ruby-identifier">s</span>
464
+ <span class="ruby-identifier">type</span>.
465
+
466
+ <span class="ruby-operator">/</span><span class="ruby-regexp">/ typeof
467
+ expect(&#39;test&#39;).to.be.a(&#39;string&#39;);
468
+ expect({ foo: &#39;bar&#39; }).to.be.an(&#39;object&#39;);
469
+ expect(null).to.be.a(&#39;null&#39;);
470
+ expect(undefined).to.be.an(&#39;undefined&#39;);
471
+
472
+ /</span><span class="ruby-operator">/</span> <span class="ruby-identifier">language</span> <span class="ruby-identifier">chain</span>
473
+ <span class="ruby-identifier">expect</span>(<span class="ruby-identifier">foo</span>).<span class="ruby-identifier">to</span>.<span class="ruby-identifier">be</span>.<span class="ruby-identifier">an</span>.<span class="ruby-identifier">instanceof</span>(<span class="ruby-constant">Foo</span>);
474
+
475
+ <span class="ruby-ivar">@name</span> <span class="ruby-identifier">a</span>
476
+ <span class="ruby-ivar">@alias</span> <span class="ruby-identifier">an</span>
477
+ <span class="ruby-ivar">@param</span> {<span class="ruby-constant">String</span>} <span class="ruby-identifier">type</span>
478
+ <span class="ruby-ivar">@param</span> {<span class="ruby-constant">String</span>} <span class="ruby-identifier">message</span> <span class="ruby-identifier">_optional_</span>
479
+ <span class="ruby-ivar">@api</span> <span class="ruby-identifier">public</span>
480
+ <span class="ruby-node">/
481
+
482
+ function an(type, msg) {
483
+ if (msg) flag(this, &#39;message&#39;, msg);
484
+ type = type.toLowerCase();
485
+ var obj = flag(this, &#39;object&#39;),
486
+ article = ~ [&#39;a&#39;, &#39;e&#39;, &#39;i&#39;, &#39;o&#39;, &#39;u&#39;].indexOf(type.charAt(0)) ? &#39;an &#39; : &#39;a &#39;;
487
+
488
+ this.assert(
489
+ type === _.type(obj), &#39;expected #{this} to be &#39; + article + type, &#39;expected #{this} not to be &#39; + article + type);
490
+ }
491
+
492
+ Assertion.addChainableMethod(&#39;an&#39;, an);
493
+ Assertion.addChainableMethod(&#39;a&#39;, an);
494
+
495
+ /</span><span class="ruby-operator">**</span>
496
+ <span class="ruby-comment">### .include(value)</span>
497
+
498
+ <span class="ruby-constant">The</span> <span class="ruby-value">%xinclude`</span> <span class="ruby-keyword">and</span> <span class="ruby-value">%xcontain`</span> <span class="ruby-identifier">assertions</span> <span class="ruby-identifier">can</span> <span class="ruby-identifier">be</span> <span class="ruby-identifier">used</span> <span class="ruby-identifier">as</span> <span class="ruby-identifier">either</span> <span class="ruby-identifier">property</span>
499
+ <span class="ruby-identifier">based</span> <span class="ruby-identifier">language</span> <span class="ruby-identifier">chains</span> <span class="ruby-keyword">or</span> <span class="ruby-identifier">as</span> <span class="ruby-identifier">methods</span> <span class="ruby-identifier">to</span> <span class="ruby-identifier">assert</span> <span class="ruby-identifier">the</span> <span class="ruby-identifier">inclusion</span> <span class="ruby-identifier">of</span> <span class="ruby-identifier">an</span> <span class="ruby-identifier">object</span>
500
+ <span class="ruby-keyword">in</span> <span class="ruby-identifier">an</span> <span class="ruby-identifier">array</span> <span class="ruby-keyword">or</span> <span class="ruby-identifier">a</span> <span class="ruby-identifier">substring</span> <span class="ruby-keyword">in</span> <span class="ruby-identifier">a</span> <span class="ruby-identifier">string</span>. <span class="ruby-constant">When</span> <span class="ruby-identifier">used</span> <span class="ruby-identifier">as</span> <span class="ruby-identifier">language</span> <span class="ruby-identifier">chains</span>,
501
+ <span class="ruby-identifier">they</span> <span class="ruby-identifier">toggle</span> <span class="ruby-identifier">the</span> <span class="ruby-value">%xcontain`</span> <span class="ruby-identifier">flag</span> <span class="ruby-keyword">for</span> <span class="ruby-identifier">the</span> <span class="ruby-value">%xkeys`</span> <span class="ruby-identifier">assertion</span>.
502
+
503
+ <span class="ruby-identifier">expect</span>([<span class="ruby-value">1</span>,<span class="ruby-value">2</span>,<span class="ruby-value">3</span>]).<span class="ruby-identifier">to</span>.<span class="ruby-identifier">include</span>(<span class="ruby-value">2</span>);
504
+ <span class="ruby-identifier">expect</span>(<span class="ruby-string">&#39;foobar&#39;</span>).<span class="ruby-identifier">to</span>.<span class="ruby-identifier">contain</span>(<span class="ruby-string">&#39;foo&#39;</span>);
505
+ <span class="ruby-identifier">expect</span>({ <span class="ruby-identifier">foo</span><span class="ruby-operator">:</span> <span class="ruby-string">&#39;bar&#39;</span>, <span class="ruby-identifier">hello</span><span class="ruby-operator">:</span> <span class="ruby-string">&#39;universe&#39;</span> }).<span class="ruby-identifier">to</span>.<span class="ruby-identifier">include</span>.<span class="ruby-identifier">keys</span>(<span class="ruby-string">&#39;foo&#39;</span>);
506
+
507
+ <span class="ruby-ivar">@name</span> <span class="ruby-identifier">include</span>
508
+ <span class="ruby-ivar">@alias</span> <span class="ruby-identifier">contain</span>
509
+ <span class="ruby-ivar">@param</span> {<span class="ruby-constant">Object</span><span class="ruby-operator">|</span><span class="ruby-constant">String</span><span class="ruby-operator">|</span><span class="ruby-constant">Number</span>} <span class="ruby-identifier">obj</span>
510
+ <span class="ruby-ivar">@param</span> {<span class="ruby-constant">String</span>} <span class="ruby-identifier">message</span> <span class="ruby-identifier">_optional_</span>
511
+ <span class="ruby-ivar">@api</span> <span class="ruby-identifier">public</span>
512
+ <span class="ruby-node">/
513
+
514
+ function includeChainingBehavior() {
515
+ flag(this, &#39;contains&#39;, true);
516
+ }
517
+
518
+ function include(val, msg) {
519
+ if (msg) flag(this, &#39;message&#39;, msg);
520
+ var obj = flag(this, &#39;object&#39;)
521
+ this.assert(~obj.indexOf(val), &#39;expected #{this} to include &#39; + _.inspect(val), &#39;expected #{this} to not include &#39; + _.inspect(val));
522
+ }
523
+
524
+ Assertion.addChainableMethod(&#39;include&#39;, include, includeChainingBehavior);
525
+ Assertion.addChainableMethod(&#39;contain&#39;, include, includeChainingBehavior);
526
+
527
+ /</span><span class="ruby-operator">**</span>
528
+ <span class="ruby-comment">### .ok</span>
529
+
530
+ <span class="ruby-constant">Asserts</span> <span class="ruby-identifier">that</span> <span class="ruby-identifier">the</span> <span class="ruby-identifier">target</span> <span class="ruby-identifier">is</span> <span class="ruby-identifier">truthy</span>.
531
+
532
+ <span class="ruby-identifier">expect</span>(<span class="ruby-string">&#39;everthing&#39;</span>).<span class="ruby-identifier">to</span>.<span class="ruby-identifier">be</span>.<span class="ruby-identifier">ok</span>;
533
+ <span class="ruby-identifier">expect</span>(<span class="ruby-value">1</span>).<span class="ruby-identifier">to</span>.<span class="ruby-identifier">be</span>.<span class="ruby-identifier">ok</span>;
534
+ <span class="ruby-identifier">expect</span>(<span class="ruby-keyword">false</span>).<span class="ruby-identifier">to</span>.<span class="ruby-identifier">not</span>.<span class="ruby-identifier">be</span>.<span class="ruby-identifier">ok</span>;
535
+ <span class="ruby-identifier">expect</span>(<span class="ruby-identifier">undefined</span>).<span class="ruby-identifier">to</span>.<span class="ruby-identifier">not</span>.<span class="ruby-identifier">be</span>.<span class="ruby-identifier">ok</span>;
536
+ <span class="ruby-identifier">expect</span>(<span class="ruby-identifier">null</span>).<span class="ruby-identifier">to</span>.<span class="ruby-identifier">not</span>.<span class="ruby-identifier">be</span>.<span class="ruby-identifier">ok</span>;
537
+
538
+ <span class="ruby-ivar">@name</span> <span class="ruby-identifier">ok</span>
539
+ <span class="ruby-ivar">@api</span> <span class="ruby-identifier">public</span>
540
+ <span class="ruby-node">/
541
+
542
+ Assertion.addProperty(&#39;ok&#39;, function() {
543
+ this.assert(
544
+ flag(this, &#39;object&#39;), &#39;expected #{this} to be truthy&#39;, &#39;expected #{this} to be falsy&#39;);
545
+ });
546
+
547
+ /</span><span class="ruby-operator">**</span>
548
+ <span class="ruby-comment">### .true</span>
549
+
550
+ <span class="ruby-constant">Asserts</span> <span class="ruby-identifier">that</span> <span class="ruby-identifier">the</span> <span class="ruby-identifier">target</span> <span class="ruby-identifier">is</span> <span class="ruby-value">%xtrue`</span>.
551
+
552
+ <span class="ruby-identifier">expect</span>(<span class="ruby-keyword">true</span>).<span class="ruby-identifier">to</span>.<span class="ruby-identifier">be</span>.<span class="ruby-identifier">true</span>;
553
+ <span class="ruby-identifier">expect</span>(<span class="ruby-value">1</span>).<span class="ruby-identifier">to</span>.<span class="ruby-identifier">not</span>.<span class="ruby-identifier">be</span>.<span class="ruby-identifier">true</span>;
554
+
555
+ <span class="ruby-ivar">@name</span> <span class="ruby-keyword">true</span>
556
+ <span class="ruby-ivar">@api</span> <span class="ruby-identifier">public</span>
557
+ <span class="ruby-node">/
558
+
559
+ Assertion.addProperty(&#39;true&#39;, function() {
560
+ this.assert(
561
+ true === flag(this, &#39;object&#39;), &#39;expected #{this} to be true&#39;, &#39;expected #{this} to be false&#39;, this.negate ? false : true);
562
+ });
563
+
564
+ /</span><span class="ruby-operator">**</span>
565
+ <span class="ruby-comment">### .false</span>
566
+
567
+ <span class="ruby-constant">Asserts</span> <span class="ruby-identifier">that</span> <span class="ruby-identifier">the</span> <span class="ruby-identifier">target</span> <span class="ruby-identifier">is</span> <span class="ruby-value">%xfalse`</span>.
568
+
569
+ <span class="ruby-identifier">expect</span>(<span class="ruby-keyword">false</span>).<span class="ruby-identifier">to</span>.<span class="ruby-identifier">be</span>.<span class="ruby-identifier">false</span>;
570
+ <span class="ruby-identifier">expect</span>(<span class="ruby-value">0</span>).<span class="ruby-identifier">to</span>.<span class="ruby-identifier">not</span>.<span class="ruby-identifier">be</span>.<span class="ruby-identifier">false</span>;
571
+
572
+ <span class="ruby-ivar">@name</span> <span class="ruby-keyword">false</span>
573
+ <span class="ruby-ivar">@api</span> <span class="ruby-identifier">public</span>
574
+ <span class="ruby-node">/
575
+
576
+ Assertion.addProperty(&#39;false&#39;, function() {
577
+ this.assert(
578
+ false === flag(this, &#39;object&#39;), &#39;expected #{this} to be false&#39;, &#39;expected #{this} to be true&#39;, this.negate ? true : false);
579
+ });
580
+
581
+ /</span><span class="ruby-operator">**</span>
582
+ <span class="ruby-comment">### .null</span>
583
+
584
+ <span class="ruby-constant">Asserts</span> <span class="ruby-identifier">that</span> <span class="ruby-identifier">the</span> <span class="ruby-identifier">target</span> <span class="ruby-identifier">is</span> <span class="ruby-value">%xnull`</span>.
585
+
586
+ <span class="ruby-identifier">expect</span>(<span class="ruby-identifier">null</span>).<span class="ruby-identifier">to</span>.<span class="ruby-identifier">be</span>.<span class="ruby-identifier">null</span>;
587
+ <span class="ruby-identifier">expect</span>(<span class="ruby-identifier">undefined</span>).<span class="ruby-identifier">not</span>.<span class="ruby-identifier">to</span>.<span class="ruby-identifier">be</span>.<span class="ruby-identifier">null</span>;
588
+
589
+ <span class="ruby-ivar">@name</span> <span class="ruby-identifier">null</span>
590
+ <span class="ruby-ivar">@api</span> <span class="ruby-identifier">public</span>
591
+ <span class="ruby-node">/
592
+
593
+ Assertion.addProperty(&#39;null&#39;, function() {
594
+ this.assert(
595
+ null === flag(this, &#39;object&#39;), &#39;expected #{this} to be null&#39;, &#39;expected #{this} not to be null&#39;);
596
+ });
597
+
598
+ /</span><span class="ruby-operator">**</span>
599
+ <span class="ruby-comment">### .undefined</span>
600
+
601
+ <span class="ruby-constant">Asserts</span> <span class="ruby-identifier">that</span> <span class="ruby-identifier">the</span> <span class="ruby-identifier">target</span> <span class="ruby-identifier">is</span> <span class="ruby-value">%xundefined`</span>.
602
+
603
+ <span class="ruby-identifier">expect</span>(<span class="ruby-identifier">undefined</span>).<span class="ruby-identifier">to</span>.<span class="ruby-identifier">be</span>.<span class="ruby-identifier">undefined</span>;
604
+ <span class="ruby-identifier">expect</span>(<span class="ruby-identifier">null</span>).<span class="ruby-identifier">to</span>.<span class="ruby-identifier">not</span>.<span class="ruby-identifier">be</span>.<span class="ruby-identifier">undefined</span>;
605
+
606
+ <span class="ruby-ivar">@name</span> <span class="ruby-identifier">undefined</span>
607
+ <span class="ruby-ivar">@api</span> <span class="ruby-identifier">public</span>
608
+ <span class="ruby-node">/
609
+
610
+ Assertion.addProperty(&#39;undefined&#39;, function() {
611
+ this.assert(
612
+ undefined === flag(this, &#39;object&#39;), &#39;expected #{this} to be undefined&#39;, &#39;expected #{this} not to be undefined&#39;);
613
+ });
614
+
615
+ /</span><span class="ruby-operator">**</span>
616
+ <span class="ruby-comment">### .exist</span>
617
+
618
+ <span class="ruby-constant">Asserts</span> <span class="ruby-identifier">that</span> <span class="ruby-identifier">the</span> <span class="ruby-identifier">target</span> <span class="ruby-identifier">is</span> <span class="ruby-identifier">neither</span> <span class="ruby-value">%xnull`</span> <span class="ruby-identifier">nor</span> <span class="ruby-value">%xundefined`</span>.
619
+
620
+ <span class="ruby-identifier">var</span> <span class="ruby-identifier">foo</span> = <span class="ruby-string">&#39;hi&#39;</span>
621
+ , <span class="ruby-identifier">bar</span> = <span class="ruby-identifier">null</span>
622
+ , <span class="ruby-identifier">baz</span>;
623
+
624
+ <span class="ruby-identifier">expect</span>(<span class="ruby-identifier">foo</span>).<span class="ruby-identifier">to</span>.<span class="ruby-identifier">exist</span>;
625
+ <span class="ruby-identifier">expect</span>(<span class="ruby-identifier">bar</span>).<span class="ruby-identifier">to</span>.<span class="ruby-identifier">not</span>.<span class="ruby-identifier">exist</span>;
626
+ <span class="ruby-identifier">expect</span>(<span class="ruby-identifier">baz</span>).<span class="ruby-identifier">to</span>.<span class="ruby-identifier">not</span>.<span class="ruby-identifier">exist</span>;
627
+
628
+ <span class="ruby-ivar">@name</span> <span class="ruby-identifier">exist</span>
629
+ <span class="ruby-ivar">@api</span> <span class="ruby-identifier">public</span>
630
+ <span class="ruby-node">/
631
+
632
+ Assertion.addProperty(&#39;exist&#39;, function() {
633
+ this.assert(
634
+ null != flag(this, &#39;object&#39;), &#39;expected #{this} to exist&#39;, &#39;expected #{this} to not exist&#39;);
635
+ });
636
+
637
+ /</span><span class="ruby-operator">**</span>
638
+ <span class="ruby-comment">### .empty</span>
639
+
640
+ <span class="ruby-constant">Asserts</span> <span class="ruby-identifier">that</span> <span class="ruby-identifier">the</span> <span class="ruby-identifier">target</span><span class="ruby-string">&#39;s length is `0`. For arrays, it checks
641
+ the `length` property. For objects, it gets the count of
642
+ enumerable keys.
643
+
644
+ expect([]).to.be.empty;
645
+ expect(&#39;</span><span class="ruby-string">&#39;).to.be.empty;
646
+ expect({}).to.be.empty;
647
+
648
+ @name empty
649
+ @api public
650
+ /
651
+
652
+ Assertion.addProperty(&#39;</span><span class="ruby-identifier">empty</span><span class="ruby-string">&#39;, function() {
653
+ var obj = flag(this, &#39;</span><span class="ruby-identifier">object</span><span class="ruby-string">&#39;),
654
+ expected = obj;
655
+
656
+ if (Array.isArray(obj) || &#39;</span><span class="ruby-identifier">string</span><span class="ruby-string">&#39; === typeof object) {
657
+ expected = obj.length;
658
+ } else if (typeof obj === &#39;</span><span class="ruby-identifier">object</span><span class="ruby-string">&#39;) {
659
+ expected = Object.keys(obj).length;
660
+ }
661
+
662
+ this.assert(!expected, &#39;</span><span class="ruby-identifier">expected</span> <span class="ruby-comment">#{this} to be empty&#39;, &#39;expected #{this} not to be empty&#39;);</span>
663
+ });
664
+
665
+ <span class="ruby-node">/**
666
+ ### .arguments
667
+
668
+ Asserts that the target is an arguments object.
669
+
670
+ function test () {
671
+ expect(arguments).to.be.arguments;
672
+ }
673
+
674
+ @name arguments
675
+ @alias Arguments
676
+ @api public
677
+ /</span>
678
+
679
+ <span class="ruby-identifier">function</span> <span class="ruby-identifier">checkArguments</span>() {
680
+ <span class="ruby-identifier">var</span> <span class="ruby-identifier">obj</span> = <span class="ruby-identifier">flag</span>(<span class="ruby-identifier">this</span>, <span class="ruby-string">&#39;object&#39;</span>),
681
+ <span class="ruby-identifier">type</span> = <span class="ruby-constant">Object</span>.<span class="ruby-identifier">prototype</span>.<span class="ruby-identifier">toString</span>.<span class="ruby-identifier">call</span>(<span class="ruby-identifier">obj</span>);
682
+ <span class="ruby-identifier">this</span>.<span class="ruby-identifier">assert</span>(<span class="ruby-string">&#39;[object Arguments]&#39;</span> <span class="ruby-operator">===</span> <span class="ruby-identifier">type</span>, <span class="ruby-string">&#39;expected #{this} to be arguments but got &#39;</span> <span class="ruby-operator">+</span> <span class="ruby-identifier">type</span>, <span class="ruby-string">&#39;expected #{this} to not be arguments&#39;</span>);
683
+ }
684
+
685
+ <span class="ruby-constant">Assertion</span>.<span class="ruby-identifier">addProperty</span>(<span class="ruby-string">&#39;arguments&#39;</span>, <span class="ruby-identifier">checkArguments</span>);
686
+ <span class="ruby-constant">Assertion</span>.<span class="ruby-identifier">addProperty</span>(<span class="ruby-string">&#39;Arguments&#39;</span>, <span class="ruby-identifier">checkArguments</span>);
687
+
688
+ <span class="ruby-node">/**
689
+ ### .equal(value)
690
+
691
+ Asserts that the target is strictly equal (`===`) to `value`.
692
+ Alternately, if the `deep` flag is set, asserts that
693
+ the target is deeply equal to `value`.
694
+
695
+ expect(&#39;hello&#39;).to.equal(&#39;hello&#39;);
696
+ expect(42).to.equal(42);
697
+ expect(1).to.not.equal(true);
698
+ expect({ foo: &#39;bar&#39; }).to.not.equal({ foo: &#39;bar&#39; });
699
+ expect({ foo: &#39;bar&#39; }).to.deep.equal({ foo: &#39;bar&#39; });
700
+
701
+ @name equal
702
+ @alias equals
703
+ @alias eq
704
+ @alias deep.equal
705
+ @param {Mixed} value
706
+ @param {String} message _optional_
707
+ @api public
708
+ /</span>
709
+
710
+ <span class="ruby-identifier">function</span> <span class="ruby-identifier">assertEqual</span>(<span class="ruby-identifier">val</span>, <span class="ruby-identifier">msg</span>) {
711
+ <span class="ruby-keyword">if</span> (<span class="ruby-identifier">msg</span>) <span class="ruby-identifier">flag</span>(<span class="ruby-identifier">this</span>, <span class="ruby-string">&#39;message&#39;</span>, <span class="ruby-identifier">msg</span>);
712
+ <span class="ruby-identifier">var</span> <span class="ruby-identifier">obj</span> = <span class="ruby-identifier">flag</span>(<span class="ruby-identifier">this</span>, <span class="ruby-string">&#39;object&#39;</span>);
713
+ <span class="ruby-keyword">if</span> (<span class="ruby-identifier">flag</span>(<span class="ruby-identifier">this</span>, <span class="ruby-string">&#39;deep&#39;</span>)) {
714
+ <span class="ruby-keyword">return</span> <span class="ruby-identifier">this</span>.<span class="ruby-identifier">eql</span>(<span class="ruby-identifier">val</span>);
715
+ } <span class="ruby-keyword">else</span> {
716
+ <span class="ruby-identifier">this</span>.<span class="ruby-identifier">assert</span>(
717
+ <span class="ruby-identifier">val</span> <span class="ruby-operator">===</span> <span class="ruby-identifier">obj</span>, <span class="ruby-string">&#39;expected #{this} to equal #{exp}&#39;</span>, <span class="ruby-string">&#39;expected #{this} to not equal #{exp}&#39;</span>, <span class="ruby-identifier">val</span>, <span class="ruby-identifier">this</span>.<span class="ruby-identifier">_obj</span>, <span class="ruby-keyword">true</span>);
718
+ }
719
+ }
720
+
721
+ <span class="ruby-constant">Assertion</span>.<span class="ruby-identifier">addMethod</span>(<span class="ruby-string">&#39;equal&#39;</span>, <span class="ruby-identifier">assertEqual</span>);
722
+ <span class="ruby-constant">Assertion</span>.<span class="ruby-identifier">addMethod</span>(<span class="ruby-string">&#39;equals&#39;</span>, <span class="ruby-identifier">assertEqual</span>);
723
+ <span class="ruby-constant">Assertion</span>.<span class="ruby-identifier">addMethod</span>(<span class="ruby-string">&#39;eq&#39;</span>, <span class="ruby-identifier">assertEqual</span>);
724
+
725
+ <span class="ruby-node">/**
726
+ ### .eql(value)
727
+
728
+ Asserts that the target is deeply equal to `value`.
729
+
730
+ expect({ foo: &#39;bar&#39; }).to.eql({ foo: &#39;bar&#39; });
731
+ expect([ 1, 2, 3 ]).to.eql([ 1, 2, 3 ]);
732
+
733
+ @name eql
734
+ @alias eqls
735
+ @param {Mixed} value
736
+ @param {String} message _optional_
737
+ @api public
738
+ /</span>
739
+
740
+ <span class="ruby-identifier">function</span> <span class="ruby-identifier">assertEql</span>(<span class="ruby-identifier">obj</span>, <span class="ruby-identifier">msg</span>) {
741
+ <span class="ruby-keyword">if</span> (<span class="ruby-identifier">msg</span>) <span class="ruby-identifier">flag</span>(<span class="ruby-identifier">this</span>, <span class="ruby-string">&#39;message&#39;</span>, <span class="ruby-identifier">msg</span>);
742
+ <span class="ruby-identifier">this</span>.<span class="ruby-identifier">assert</span>(
743
+ <span class="ruby-identifier">_</span>.<span class="ruby-identifier">eql</span>(<span class="ruby-identifier">obj</span>, <span class="ruby-identifier">flag</span>(<span class="ruby-identifier">this</span>, <span class="ruby-string">&#39;object&#39;</span>)), <span class="ruby-string">&#39;expected #{this} to deeply equal #{exp}&#39;</span>, <span class="ruby-string">&#39;expected #{this} to not deeply equal #{exp}&#39;</span>, <span class="ruby-identifier">obj</span>, <span class="ruby-identifier">this</span>.<span class="ruby-identifier">_obj</span>, <span class="ruby-keyword">true</span>);
744
+ }
745
+
746
+ <span class="ruby-constant">Assertion</span>.<span class="ruby-identifier">addMethod</span>(<span class="ruby-string">&#39;eql&#39;</span>, <span class="ruby-identifier">assertEql</span>);
747
+ <span class="ruby-constant">Assertion</span>.<span class="ruby-identifier">addMethod</span>(<span class="ruby-string">&#39;eqls&#39;</span>, <span class="ruby-identifier">assertEql</span>);
748
+
749
+ <span class="ruby-node">/**
750
+ ### .above(value)
751
+
752
+ Asserts that the target is greater than `value`.
753
+
754
+ expect(10).to.be.above(5);
755
+
756
+ Can also be used in conjunction with `length` to
757
+ assert a minimum length. The benefit being a
758
+ more informative error message than if the length
759
+ was supplied directly.
760
+
761
+ expect(&#39;foo&#39;).to.have.length.above(2);
762
+ expect([ 1, 2, 3 ]).to.have.length.above(2);
763
+
764
+ @name above
765
+ @alias gt
766
+ @alias greaterThan
767
+ @param {Number} value
768
+ @param {String} message _optional_
769
+ @api public
770
+ /</span>
771
+
772
+ <span class="ruby-identifier">function</span> <span class="ruby-identifier">assertAbove</span>(<span class="ruby-identifier">n</span>, <span class="ruby-identifier">msg</span>) {
773
+ <span class="ruby-keyword">if</span> (<span class="ruby-identifier">msg</span>) <span class="ruby-identifier">flag</span>(<span class="ruby-identifier">this</span>, <span class="ruby-string">&#39;message&#39;</span>, <span class="ruby-identifier">msg</span>);
774
+ <span class="ruby-identifier">var</span> <span class="ruby-identifier">obj</span> = <span class="ruby-identifier">flag</span>(<span class="ruby-identifier">this</span>, <span class="ruby-string">&#39;object&#39;</span>);
775
+ <span class="ruby-keyword">if</span> (<span class="ruby-identifier">flag</span>(<span class="ruby-identifier">this</span>, <span class="ruby-string">&#39;doLength&#39;</span>)) {
776
+ <span class="ruby-identifier">new</span> <span class="ruby-constant">Assertion</span>(<span class="ruby-identifier">obj</span>, <span class="ruby-identifier">msg</span>).<span class="ruby-identifier">to</span>.<span class="ruby-identifier">have</span>.<span class="ruby-identifier">property</span>(<span class="ruby-string">&#39;length&#39;</span>);
777
+ <span class="ruby-identifier">var</span> <span class="ruby-identifier">len</span> = <span class="ruby-identifier">obj</span>.<span class="ruby-identifier">length</span>;
778
+ <span class="ruby-identifier">this</span>.<span class="ruby-identifier">assert</span>(
779
+ <span class="ruby-identifier">len</span> <span class="ruby-operator">&gt;</span> <span class="ruby-identifier">n</span>, <span class="ruby-string">&#39;expected #{this} to have a length above #{exp} but got #{act}&#39;</span>, <span class="ruby-string">&#39;expected #{this} to not have a length above #{exp}&#39;</span>, <span class="ruby-identifier">n</span>, <span class="ruby-identifier">len</span>);
780
+ } <span class="ruby-keyword">else</span> {
781
+ <span class="ruby-identifier">this</span>.<span class="ruby-identifier">assert</span>(
782
+ <span class="ruby-identifier">obj</span> <span class="ruby-operator">&gt;</span> <span class="ruby-identifier">n</span>, <span class="ruby-string">&#39;expected #{this} to be above &#39;</span> <span class="ruby-operator">+</span> <span class="ruby-identifier">n</span>, <span class="ruby-string">&#39;expected #{this} to be at most &#39;</span> <span class="ruby-operator">+</span> <span class="ruby-identifier">n</span>);
783
+ }
784
+ }
785
+
786
+ <span class="ruby-constant">Assertion</span>.<span class="ruby-identifier">addMethod</span>(<span class="ruby-string">&#39;above&#39;</span>, <span class="ruby-identifier">assertAbove</span>);
787
+ <span class="ruby-constant">Assertion</span>.<span class="ruby-identifier">addMethod</span>(<span class="ruby-string">&#39;gt&#39;</span>, <span class="ruby-identifier">assertAbove</span>);
788
+ <span class="ruby-constant">Assertion</span>.<span class="ruby-identifier">addMethod</span>(<span class="ruby-string">&#39;greaterThan&#39;</span>, <span class="ruby-identifier">assertAbove</span>);
789
+
790
+ <span class="ruby-node">/**
791
+ ### .least(value)
792
+
793
+ Asserts that the target is greater than or equal to `value`.
794
+
795
+ expect(10).to.be.at.least(10);
796
+
797
+ Can also be used in conjunction with `length` to
798
+ assert a minimum length. The benefit being a
799
+ more informative error message than if the length
800
+ was supplied directly.
801
+
802
+ expect(&#39;foo&#39;).to.have.length.of.at.least(2);
803
+ expect([ 1, 2, 3 ]).to.have.length.of.at.least(3);
804
+
805
+ @name least
806
+ @alias gte
807
+ @param {Number} value
808
+ @param {String} message _optional_
809
+ @api public
810
+ /</span>
811
+
812
+ <span class="ruby-identifier">function</span> <span class="ruby-identifier">assertLeast</span>(<span class="ruby-identifier">n</span>, <span class="ruby-identifier">msg</span>) {
813
+ <span class="ruby-keyword">if</span> (<span class="ruby-identifier">msg</span>) <span class="ruby-identifier">flag</span>(<span class="ruby-identifier">this</span>, <span class="ruby-string">&#39;message&#39;</span>, <span class="ruby-identifier">msg</span>);
814
+ <span class="ruby-identifier">var</span> <span class="ruby-identifier">obj</span> = <span class="ruby-identifier">flag</span>(<span class="ruby-identifier">this</span>, <span class="ruby-string">&#39;object&#39;</span>);
815
+ <span class="ruby-keyword">if</span> (<span class="ruby-identifier">flag</span>(<span class="ruby-identifier">this</span>, <span class="ruby-string">&#39;doLength&#39;</span>)) {
816
+ <span class="ruby-identifier">new</span> <span class="ruby-constant">Assertion</span>(<span class="ruby-identifier">obj</span>, <span class="ruby-identifier">msg</span>).<span class="ruby-identifier">to</span>.<span class="ruby-identifier">have</span>.<span class="ruby-identifier">property</span>(<span class="ruby-string">&#39;length&#39;</span>);
817
+ <span class="ruby-identifier">var</span> <span class="ruby-identifier">len</span> = <span class="ruby-identifier">obj</span>.<span class="ruby-identifier">length</span>;
818
+ <span class="ruby-identifier">this</span>.<span class="ruby-identifier">assert</span>(
819
+ <span class="ruby-identifier">len</span> <span class="ruby-operator">&gt;=</span> <span class="ruby-identifier">n</span>, <span class="ruby-string">&#39;expected #{this} to have a length at least #{exp} but got #{act}&#39;</span>, <span class="ruby-string">&#39;expected #{this} to have a length below #{exp}&#39;</span>, <span class="ruby-identifier">n</span>, <span class="ruby-identifier">len</span>);
820
+ } <span class="ruby-keyword">else</span> {
821
+ <span class="ruby-identifier">this</span>.<span class="ruby-identifier">assert</span>(
822
+ <span class="ruby-identifier">obj</span> <span class="ruby-operator">&gt;=</span> <span class="ruby-identifier">n</span>, <span class="ruby-string">&#39;expected #{this} to be at least &#39;</span> <span class="ruby-operator">+</span> <span class="ruby-identifier">n</span>, <span class="ruby-string">&#39;expected #{this} to be below &#39;</span> <span class="ruby-operator">+</span> <span class="ruby-identifier">n</span>);
823
+ }
824
+ }
825
+
826
+ <span class="ruby-constant">Assertion</span>.<span class="ruby-identifier">addMethod</span>(<span class="ruby-string">&#39;least&#39;</span>, <span class="ruby-identifier">assertLeast</span>);
827
+ <span class="ruby-constant">Assertion</span>.<span class="ruby-identifier">addMethod</span>(<span class="ruby-string">&#39;gte&#39;</span>, <span class="ruby-identifier">assertLeast</span>);
828
+
829
+ <span class="ruby-node">/**
830
+ ### .below(value)
831
+
832
+ Asserts that the target is less than `value`.
833
+
834
+ expect(5).to.be.below(10);
835
+
836
+ Can also be used in conjunction with `length` to
837
+ assert a maximum length. The benefit being a
838
+ more informative error message than if the length
839
+ was supplied directly.
840
+
841
+ expect(&#39;foo&#39;).to.have.length.below(4);
842
+ expect([ 1, 2, 3 ]).to.have.length.below(4);
843
+
844
+ @name below
845
+ @alias lt
846
+ @alias lessThan
847
+ @param {Number} value
848
+ @param {String} message _optional_
849
+ @api public
850
+ /</span>
851
+
852
+ <span class="ruby-identifier">function</span> <span class="ruby-identifier">assertBelow</span>(<span class="ruby-identifier">n</span>, <span class="ruby-identifier">msg</span>) {
853
+ <span class="ruby-keyword">if</span> (<span class="ruby-identifier">msg</span>) <span class="ruby-identifier">flag</span>(<span class="ruby-identifier">this</span>, <span class="ruby-string">&#39;message&#39;</span>, <span class="ruby-identifier">msg</span>);
854
+ <span class="ruby-identifier">var</span> <span class="ruby-identifier">obj</span> = <span class="ruby-identifier">flag</span>(<span class="ruby-identifier">this</span>, <span class="ruby-string">&#39;object&#39;</span>);
855
+ <span class="ruby-keyword">if</span> (<span class="ruby-identifier">flag</span>(<span class="ruby-identifier">this</span>, <span class="ruby-string">&#39;doLength&#39;</span>)) {
856
+ <span class="ruby-identifier">new</span> <span class="ruby-constant">Assertion</span>(<span class="ruby-identifier">obj</span>, <span class="ruby-identifier">msg</span>).<span class="ruby-identifier">to</span>.<span class="ruby-identifier">have</span>.<span class="ruby-identifier">property</span>(<span class="ruby-string">&#39;length&#39;</span>);
857
+ <span class="ruby-identifier">var</span> <span class="ruby-identifier">len</span> = <span class="ruby-identifier">obj</span>.<span class="ruby-identifier">length</span>;
858
+ <span class="ruby-identifier">this</span>.<span class="ruby-identifier">assert</span>(
859
+ <span class="ruby-identifier">len</span> <span class="ruby-operator">&lt;</span> <span class="ruby-identifier">n</span>, <span class="ruby-string">&#39;expected #{this} to have a length below #{exp} but got #{act}&#39;</span>, <span class="ruby-string">&#39;expected #{this} to not have a length below #{exp}&#39;</span>, <span class="ruby-identifier">n</span>, <span class="ruby-identifier">len</span>);
860
+ } <span class="ruby-keyword">else</span> {
861
+ <span class="ruby-identifier">this</span>.<span class="ruby-identifier">assert</span>(
862
+ <span class="ruby-identifier">obj</span> <span class="ruby-operator">&lt;</span> <span class="ruby-identifier">n</span>, <span class="ruby-string">&#39;expected #{this} to be below &#39;</span> <span class="ruby-operator">+</span> <span class="ruby-identifier">n</span>, <span class="ruby-string">&#39;expected #{this} to be at least &#39;</span> <span class="ruby-operator">+</span> <span class="ruby-identifier">n</span>);
863
+ }
864
+ }
865
+
866
+ <span class="ruby-constant">Assertion</span>.<span class="ruby-identifier">addMethod</span>(<span class="ruby-string">&#39;below&#39;</span>, <span class="ruby-identifier">assertBelow</span>);
867
+ <span class="ruby-constant">Assertion</span>.<span class="ruby-identifier">addMethod</span>(<span class="ruby-string">&#39;lt&#39;</span>, <span class="ruby-identifier">assertBelow</span>);
868
+ <span class="ruby-constant">Assertion</span>.<span class="ruby-identifier">addMethod</span>(<span class="ruby-string">&#39;lessThan&#39;</span>, <span class="ruby-identifier">assertBelow</span>);
869
+
870
+ <span class="ruby-node">/**
871
+ ### .most(value)
872
+
873
+ Asserts that the target is less than or equal to `value`.
874
+
875
+ expect(5).to.be.at.most(5);
876
+
877
+ Can also be used in conjunction with `length` to
878
+ assert a maximum length. The benefit being a
879
+ more informative error message than if the length
880
+ was supplied directly.
881
+
882
+ expect(&#39;foo&#39;).to.have.length.of.at.most(4);
883
+ expect([ 1, 2, 3 ]).to.have.length.of.at.most(3);
884
+
885
+ @name most
886
+ @alias lte
887
+ @param {Number} value
888
+ @param {String} message _optional_
889
+ @api public
890
+ /</span>
891
+
892
+ <span class="ruby-identifier">function</span> <span class="ruby-identifier">assertMost</span>(<span class="ruby-identifier">n</span>, <span class="ruby-identifier">msg</span>) {
893
+ <span class="ruby-keyword">if</span> (<span class="ruby-identifier">msg</span>) <span class="ruby-identifier">flag</span>(<span class="ruby-identifier">this</span>, <span class="ruby-string">&#39;message&#39;</span>, <span class="ruby-identifier">msg</span>);
894
+ <span class="ruby-identifier">var</span> <span class="ruby-identifier">obj</span> = <span class="ruby-identifier">flag</span>(<span class="ruby-identifier">this</span>, <span class="ruby-string">&#39;object&#39;</span>);
895
+ <span class="ruby-keyword">if</span> (<span class="ruby-identifier">flag</span>(<span class="ruby-identifier">this</span>, <span class="ruby-string">&#39;doLength&#39;</span>)) {
896
+ <span class="ruby-identifier">new</span> <span class="ruby-constant">Assertion</span>(<span class="ruby-identifier">obj</span>, <span class="ruby-identifier">msg</span>).<span class="ruby-identifier">to</span>.<span class="ruby-identifier">have</span>.<span class="ruby-identifier">property</span>(<span class="ruby-string">&#39;length&#39;</span>);
897
+ <span class="ruby-identifier">var</span> <span class="ruby-identifier">len</span> = <span class="ruby-identifier">obj</span>.<span class="ruby-identifier">length</span>;
898
+ <span class="ruby-identifier">this</span>.<span class="ruby-identifier">assert</span>(
899
+ <span class="ruby-identifier">len</span> <span class="ruby-operator">&lt;=</span> <span class="ruby-identifier">n</span>, <span class="ruby-string">&#39;expected #{this} to have a length at most #{exp} but got #{act}&#39;</span>, <span class="ruby-string">&#39;expected #{this} to have a length above #{exp}&#39;</span>, <span class="ruby-identifier">n</span>, <span class="ruby-identifier">len</span>);
900
+ } <span class="ruby-keyword">else</span> {
901
+ <span class="ruby-identifier">this</span>.<span class="ruby-identifier">assert</span>(
902
+ <span class="ruby-identifier">obj</span> <span class="ruby-operator">&lt;=</span> <span class="ruby-identifier">n</span>, <span class="ruby-string">&#39;expected #{this} to be at most &#39;</span> <span class="ruby-operator">+</span> <span class="ruby-identifier">n</span>, <span class="ruby-string">&#39;expected #{this} to be above &#39;</span> <span class="ruby-operator">+</span> <span class="ruby-identifier">n</span>);
903
+ }
904
+ }
905
+
906
+ <span class="ruby-constant">Assertion</span>.<span class="ruby-identifier">addMethod</span>(<span class="ruby-string">&#39;most&#39;</span>, <span class="ruby-identifier">assertMost</span>);
907
+ <span class="ruby-constant">Assertion</span>.<span class="ruby-identifier">addMethod</span>(<span class="ruby-string">&#39;lte&#39;</span>, <span class="ruby-identifier">assertMost</span>);
908
+
909
+ <span class="ruby-node">/**
910
+ ### .within(start, finish)
911
+
912
+ Asserts that the target is within a range.
913
+
914
+ expect(7).to.be.within(5,10);
915
+
916
+ Can also be used in conjunction with `length` to
917
+ assert a length range. The benefit being a
918
+ more informative error message than if the length
919
+ was supplied directly.
920
+
921
+ expect(&#39;foo&#39;).to.have.length.within(2,4);
922
+ expect([ 1, 2, 3 ]).to.have.length.within(2,4);
923
+
924
+ @name within
925
+ @param {Number} start lowerbound inclusive
926
+ @param {Number} finish upperbound inclusive
927
+ @param {String} message _optional_
928
+ @api public
929
+ /</span>
930
+
931
+ <span class="ruby-constant">Assertion</span>.<span class="ruby-identifier">addMethod</span>(<span class="ruby-string">&#39;within&#39;</span>, <span class="ruby-identifier">function</span>(<span class="ruby-identifier">start</span>, <span class="ruby-identifier">finish</span>, <span class="ruby-identifier">msg</span>) {
932
+ <span class="ruby-keyword">if</span> (<span class="ruby-identifier">msg</span>) <span class="ruby-identifier">flag</span>(<span class="ruby-identifier">this</span>, <span class="ruby-string">&#39;message&#39;</span>, <span class="ruby-identifier">msg</span>);
933
+ <span class="ruby-identifier">var</span> <span class="ruby-identifier">obj</span> = <span class="ruby-identifier">flag</span>(<span class="ruby-identifier">this</span>, <span class="ruby-string">&#39;object&#39;</span>),
934
+ <span class="ruby-identifier">range</span> = <span class="ruby-identifier">start</span> <span class="ruby-operator">+</span> <span class="ruby-string">&#39;..&#39;</span> <span class="ruby-operator">+</span> <span class="ruby-identifier">finish</span>;
935
+ <span class="ruby-keyword">if</span> (<span class="ruby-identifier">flag</span>(<span class="ruby-identifier">this</span>, <span class="ruby-string">&#39;doLength&#39;</span>)) {
936
+ <span class="ruby-identifier">new</span> <span class="ruby-constant">Assertion</span>(<span class="ruby-identifier">obj</span>, <span class="ruby-identifier">msg</span>).<span class="ruby-identifier">to</span>.<span class="ruby-identifier">have</span>.<span class="ruby-identifier">property</span>(<span class="ruby-string">&#39;length&#39;</span>);
937
+ <span class="ruby-identifier">var</span> <span class="ruby-identifier">len</span> = <span class="ruby-identifier">obj</span>.<span class="ruby-identifier">length</span>;
938
+ <span class="ruby-identifier">this</span>.<span class="ruby-identifier">assert</span>(
939
+ <span class="ruby-identifier">len</span> <span class="ruby-operator">&gt;=</span> <span class="ruby-identifier">start</span> <span class="ruby-operator">&amp;&amp;</span> <span class="ruby-identifier">len</span> <span class="ruby-operator">&lt;=</span> <span class="ruby-identifier">finish</span>, <span class="ruby-string">&#39;expected #{this} to have a length within &#39;</span> <span class="ruby-operator">+</span> <span class="ruby-identifier">range</span>, <span class="ruby-string">&#39;expected #{this} to not have a length within &#39;</span> <span class="ruby-operator">+</span> <span class="ruby-identifier">range</span>);
940
+ } <span class="ruby-keyword">else</span> {
941
+ <span class="ruby-identifier">this</span>.<span class="ruby-identifier">assert</span>(
942
+ <span class="ruby-identifier">obj</span> <span class="ruby-operator">&gt;=</span> <span class="ruby-identifier">start</span> <span class="ruby-operator">&amp;&amp;</span> <span class="ruby-identifier">obj</span> <span class="ruby-operator">&lt;=</span> <span class="ruby-identifier">finish</span>, <span class="ruby-string">&#39;expected #{this} to be within &#39;</span> <span class="ruby-operator">+</span> <span class="ruby-identifier">range</span>, <span class="ruby-string">&#39;expected #{this} to not be within &#39;</span> <span class="ruby-operator">+</span> <span class="ruby-identifier">range</span>);
943
+ }
944
+ });
945
+
946
+ <span class="ruby-node">/**
947
+ ### .instanceof(constructor)
948
+
949
+ Asserts that the target is an instance of `constructor`.
950
+
951
+ var Tea = function (name) { this.name = name; }
952
+ , Chai = new Tea(&#39;chai&#39;);
953
+
954
+ expect(Chai).to.be.an.instanceof(Tea);
955
+ expect([ 1, 2, 3 ]).to.be.instanceof(Array);
956
+
957
+ @name instanceof
958
+ @param {Constructor} constructor
959
+ @param {String} message _optional_
960
+ @alias instanceOf
961
+ @api public
962
+ /</span>
963
+
964
+ <span class="ruby-identifier">function</span> <span class="ruby-identifier">assertInstanceOf</span>(<span class="ruby-identifier">constructor</span>, <span class="ruby-identifier">msg</span>) {
965
+ <span class="ruby-keyword">if</span> (<span class="ruby-identifier">msg</span>) <span class="ruby-identifier">flag</span>(<span class="ruby-identifier">this</span>, <span class="ruby-string">&#39;message&#39;</span>, <span class="ruby-identifier">msg</span>);
966
+ <span class="ruby-identifier">var</span> <span class="ruby-identifier">name</span> = <span class="ruby-identifier">_</span>.<span class="ruby-identifier">getName</span>(<span class="ruby-identifier">constructor</span>);
967
+ <span class="ruby-identifier">this</span>.<span class="ruby-identifier">assert</span>(
968
+ <span class="ruby-identifier">flag</span>(<span class="ruby-identifier">this</span>, <span class="ruby-string">&#39;object&#39;</span>) <span class="ruby-identifier">instanceof</span> <span class="ruby-identifier">constructor</span>, <span class="ruby-string">&#39;expected #{this} to be an instance of &#39;</span> <span class="ruby-operator">+</span> <span class="ruby-identifier">name</span>, <span class="ruby-string">&#39;expected #{this} to not be an instance of &#39;</span> <span class="ruby-operator">+</span> <span class="ruby-identifier">name</span>);
969
+ };
970
+
971
+ <span class="ruby-constant">Assertion</span>.<span class="ruby-identifier">addMethod</span>(<span class="ruby-string">&#39;instanceof&#39;</span>, <span class="ruby-identifier">assertInstanceOf</span>);
972
+ <span class="ruby-constant">Assertion</span>.<span class="ruby-identifier">addMethod</span>(<span class="ruby-string">&#39;instanceOf&#39;</span>, <span class="ruby-identifier">assertInstanceOf</span>);
973
+
974
+ <span class="ruby-node">/**
975
+ ### .property(name, [value])
976
+
977
+ Asserts that the target has a property `name`, optionally asserting that
978
+ the value of that property is strictly equal to `value`.
979
+ If the `deep` flag is set, you can use dot- and bracket-notation for deep
980
+ references into objects and arrays.
981
+
982
+ /</span><span class="ruby-operator">/</span> <span class="ruby-identifier">simple</span> <span class="ruby-identifier">referencing</span>
983
+ <span class="ruby-identifier">var</span> <span class="ruby-identifier">obj</span> = { <span class="ruby-identifier">foo</span><span class="ruby-operator">:</span> <span class="ruby-string">&#39;bar&#39;</span> };
984
+ <span class="ruby-identifier">expect</span>(<span class="ruby-identifier">obj</span>).<span class="ruby-identifier">to</span>.<span class="ruby-identifier">have</span>.<span class="ruby-identifier">property</span>(<span class="ruby-string">&#39;foo&#39;</span>);
985
+ <span class="ruby-identifier">expect</span>(<span class="ruby-identifier">obj</span>).<span class="ruby-identifier">to</span>.<span class="ruby-identifier">have</span>.<span class="ruby-identifier">property</span>(<span class="ruby-string">&#39;foo&#39;</span>, <span class="ruby-string">&#39;bar&#39;</span>);
986
+
987
+ <span class="ruby-regexp">//</span> <span class="ruby-identifier">deep</span> <span class="ruby-identifier">referencing</span>
988
+ <span class="ruby-identifier">var</span> <span class="ruby-identifier">deepObj</span> = {
989
+ <span class="ruby-identifier">green</span><span class="ruby-operator">:</span> { <span class="ruby-identifier">tea</span><span class="ruby-operator">:</span> <span class="ruby-string">&#39;matcha&#39;</span> }
990
+ , <span class="ruby-identifier">teas</span><span class="ruby-operator">:</span> [ <span class="ruby-string">&#39;chai&#39;</span>, <span class="ruby-string">&#39;matcha&#39;</span>, { <span class="ruby-identifier">tea</span><span class="ruby-operator">:</span> <span class="ruby-string">&#39;konacha&#39;</span> } ]
991
+ };
992
+
993
+ <span class="ruby-identifier">expect</span>(<span class="ruby-identifier">deepObj</span>).<span class="ruby-identifier">to</span>.<span class="ruby-identifier">have</span>.<span class="ruby-identifier">deep</span>.<span class="ruby-identifier">property</span>(<span class="ruby-string">&#39;green.tea&#39;</span>, <span class="ruby-string">&#39;matcha&#39;</span>);
994
+ <span class="ruby-identifier">expect</span>(<span class="ruby-identifier">deepObj</span>).<span class="ruby-identifier">to</span>.<span class="ruby-identifier">have</span>.<span class="ruby-identifier">deep</span>.<span class="ruby-identifier">property</span>(<span class="ruby-string">&#39;teas[1]&#39;</span>, <span class="ruby-string">&#39;matcha&#39;</span>);
995
+ <span class="ruby-identifier">expect</span>(<span class="ruby-identifier">deepObj</span>).<span class="ruby-identifier">to</span>.<span class="ruby-identifier">have</span>.<span class="ruby-identifier">deep</span>.<span class="ruby-identifier">property</span>(<span class="ruby-string">&#39;teas[2].tea&#39;</span>, <span class="ruby-string">&#39;konacha&#39;</span>);
996
+
997
+ <span class="ruby-constant">You</span> <span class="ruby-identifier">can</span> <span class="ruby-identifier">also</span> <span class="ruby-identifier">use</span> <span class="ruby-identifier">an</span> <span class="ruby-identifier">array</span> <span class="ruby-identifier">as</span> <span class="ruby-identifier">the</span> <span class="ruby-identifier">starting</span> <span class="ruby-identifier">point</span> <span class="ruby-identifier">of</span> <span class="ruby-identifier">a</span> <span class="ruby-value">%xdeep.property`</span>
998
+ <span class="ruby-identifier">assertion</span>, <span class="ruby-keyword">or</span> <span class="ruby-identifier">traverse</span> <span class="ruby-identifier">nested</span> <span class="ruby-identifier">arrays</span>.
999
+
1000
+ <span class="ruby-identifier">var</span> <span class="ruby-identifier">arr</span> = [
1001
+ [ <span class="ruby-string">&#39;chai&#39;</span>, <span class="ruby-string">&#39;matcha&#39;</span>, <span class="ruby-string">&#39;konacha&#39;</span> ]
1002
+ , [ { <span class="ruby-identifier">tea</span><span class="ruby-operator">:</span> <span class="ruby-string">&#39;chai&#39;</span> }
1003
+ , { <span class="ruby-identifier">tea</span><span class="ruby-operator">:</span> <span class="ruby-string">&#39;matcha&#39;</span> }
1004
+ , { <span class="ruby-identifier">tea</span><span class="ruby-operator">:</span> <span class="ruby-string">&#39;konacha&#39;</span> } ]
1005
+ ];
1006
+
1007
+ <span class="ruby-identifier">expect</span>(<span class="ruby-identifier">arr</span>).<span class="ruby-identifier">to</span>.<span class="ruby-identifier">have</span>.<span class="ruby-identifier">deep</span>.<span class="ruby-identifier">property</span>(<span class="ruby-string">&#39;[0][1]&#39;</span>, <span class="ruby-string">&#39;matcha&#39;</span>);
1008
+ <span class="ruby-identifier">expect</span>(<span class="ruby-identifier">arr</span>).<span class="ruby-identifier">to</span>.<span class="ruby-identifier">have</span>.<span class="ruby-identifier">deep</span>.<span class="ruby-identifier">property</span>(<span class="ruby-string">&#39;[1][2].tea&#39;</span>, <span class="ruby-string">&#39;konacha&#39;</span>);
1009
+
1010
+ <span class="ruby-constant">Furthermore</span>, <span class="ruby-value">%xproperty`</span> <span class="ruby-identifier">changes</span> <span class="ruby-identifier">the</span> <span class="ruby-identifier">subject</span> <span class="ruby-identifier">of</span> <span class="ruby-identifier">the</span> <span class="ruby-identifier">assertion</span>
1011
+ <span class="ruby-identifier">to</span> <span class="ruby-identifier">be</span> <span class="ruby-identifier">the</span> <span class="ruby-identifier">value</span> <span class="ruby-identifier">of</span> <span class="ruby-identifier">that</span> <span class="ruby-identifier">property</span> <span class="ruby-identifier">from</span> <span class="ruby-identifier">the</span> <span class="ruby-identifier">original</span> <span class="ruby-identifier">object</span>. <span class="ruby-constant">This</span>
1012
+ <span class="ruby-identifier">permits</span> <span class="ruby-keyword">for</span> <span class="ruby-identifier">further</span> <span class="ruby-identifier">chainable</span> <span class="ruby-identifier">assertions</span> <span class="ruby-identifier">on</span> <span class="ruby-identifier">that</span> <span class="ruby-identifier">property</span>.
1013
+
1014
+ <span class="ruby-identifier">expect</span>(<span class="ruby-identifier">obj</span>).<span class="ruby-identifier">to</span>.<span class="ruby-identifier">have</span>.<span class="ruby-identifier">property</span>(<span class="ruby-string">&#39;foo&#39;</span>)
1015
+ .<span class="ruby-identifier">that</span>.<span class="ruby-identifier">is</span>.<span class="ruby-identifier">a</span>(<span class="ruby-string">&#39;string&#39;</span>);
1016
+ <span class="ruby-identifier">expect</span>(<span class="ruby-identifier">deepObj</span>).<span class="ruby-identifier">to</span>.<span class="ruby-identifier">have</span>.<span class="ruby-identifier">property</span>(<span class="ruby-string">&#39;green&#39;</span>)
1017
+ .<span class="ruby-identifier">that</span>.<span class="ruby-identifier">is</span>.<span class="ruby-identifier">an</span>(<span class="ruby-string">&#39;object&#39;</span>)
1018
+ .<span class="ruby-identifier">that</span>.<span class="ruby-identifier">deep</span>.<span class="ruby-identifier">equals</span>({ <span class="ruby-identifier">tea</span><span class="ruby-operator">:</span> <span class="ruby-string">&#39;matcha&#39;</span> });
1019
+ <span class="ruby-identifier">expect</span>(<span class="ruby-identifier">deepObj</span>).<span class="ruby-identifier">to</span>.<span class="ruby-identifier">have</span>.<span class="ruby-identifier">property</span>(<span class="ruby-string">&#39;teas&#39;</span>)
1020
+ .<span class="ruby-identifier">that</span>.<span class="ruby-identifier">is</span>.<span class="ruby-identifier">an</span>(<span class="ruby-string">&#39;array&#39;</span>)
1021
+ .<span class="ruby-identifier">with</span>.<span class="ruby-identifier">deep</span>.<span class="ruby-identifier">property</span>(<span class="ruby-string">&#39;[2]&#39;</span>)
1022
+ .<span class="ruby-identifier">that</span>.<span class="ruby-identifier">deep</span>.<span class="ruby-identifier">equals</span>({ <span class="ruby-identifier">tea</span><span class="ruby-operator">:</span> <span class="ruby-string">&#39;konacha&#39;</span> });
1023
+
1024
+ <span class="ruby-ivar">@name</span> <span class="ruby-identifier">property</span>
1025
+ <span class="ruby-ivar">@alias</span> <span class="ruby-identifier">deep</span>.<span class="ruby-identifier">property</span>
1026
+ <span class="ruby-ivar">@param</span> {<span class="ruby-constant">String</span>} <span class="ruby-identifier">name</span>
1027
+ <span class="ruby-ivar">@param</span> {<span class="ruby-constant">Mixed</span>} <span class="ruby-identifier">value</span> (<span class="ruby-identifier">optional</span>)
1028
+ <span class="ruby-ivar">@param</span> {<span class="ruby-constant">String</span>} <span class="ruby-identifier">message</span> <span class="ruby-identifier">_optional_</span>
1029
+ <span class="ruby-ivar">@returns</span> <span class="ruby-identifier">value</span> <span class="ruby-identifier">of</span> <span class="ruby-identifier">property</span> <span class="ruby-keyword">for</span> <span class="ruby-identifier">chaining</span>
1030
+ <span class="ruby-ivar">@api</span> <span class="ruby-identifier">public</span>
1031
+ <span class="ruby-node">/
1032
+
1033
+ Assertion.addMethod(&#39;property&#39;, function(name, val, msg) {
1034
+ if (msg) flag(this, &#39;message&#39;, msg);
1035
+
1036
+ var descriptor = flag(this, &#39;deep&#39;) ? &#39;deep property &#39; : &#39;property &#39;,
1037
+ negate = flag(this, &#39;negate&#39;),
1038
+ obj = flag(this, &#39;object&#39;),
1039
+ value = flag(this, &#39;deep&#39;) ? _.getPathValue(name, obj) : obj[name];
1040
+
1041
+ if (negate &amp;&amp; undefined !== val) {
1042
+ if (undefined === value) {
1043
+ msg = (msg != null) ? msg + &#39;: &#39; : &#39;&#39;;
1044
+ throw new Error(msg + _.inspect(obj) + &#39; has no &#39; + descriptor + _.inspect(name));
1045
+ }
1046
+ } else {
1047
+ this.assert(
1048
+ undefined !== value, &#39;expected #{this} to have a &#39; + descriptor + _.inspect(name), &#39;expected #{this} to not have &#39; + descriptor + _.inspect(name));
1049
+ }
1050
+
1051
+ if (undefined !== val) {
1052
+ this.assert(
1053
+ val === value, &#39;expected #{this} to have a &#39; + descriptor + _.inspect(name) + &#39; of #{exp}, but got #{act}&#39;, &#39;expected #{this} to not have a &#39; + descriptor + _.inspect(name) + &#39; of #{act}&#39;, val, value);
1054
+ }
1055
+
1056
+ flag(this, &#39;object&#39;, value);
1057
+ });
1058
+
1059
+ /</span><span class="ruby-operator">**</span>
1060
+ <span class="ruby-comment">### .ownProperty(name)</span>
1061
+
1062
+ <span class="ruby-constant">Asserts</span> <span class="ruby-identifier">that</span> <span class="ruby-identifier">the</span> <span class="ruby-identifier">target</span> <span class="ruby-identifier">has</span> <span class="ruby-identifier">an</span> <span class="ruby-identifier">own</span> <span class="ruby-identifier">property</span> <span class="ruby-value">%xname`</span>.
1063
+
1064
+ <span class="ruby-identifier">expect</span>(<span class="ruby-string">&#39;test&#39;</span>).<span class="ruby-identifier">to</span>.<span class="ruby-identifier">have</span>.<span class="ruby-identifier">ownProperty</span>(<span class="ruby-string">&#39;length&#39;</span>);
1065
+
1066
+ <span class="ruby-ivar">@name</span> <span class="ruby-identifier">ownProperty</span>
1067
+ <span class="ruby-ivar">@alias</span> <span class="ruby-identifier">haveOwnProperty</span>
1068
+ <span class="ruby-ivar">@param</span> {<span class="ruby-constant">String</span>} <span class="ruby-identifier">name</span>
1069
+ <span class="ruby-ivar">@param</span> {<span class="ruby-constant">String</span>} <span class="ruby-identifier">message</span> <span class="ruby-identifier">_optional_</span>
1070
+ <span class="ruby-ivar">@api</span> <span class="ruby-identifier">public</span>
1071
+ <span class="ruby-node">/
1072
+
1073
+ function assertOwnProperty(name, msg) {
1074
+ if (msg) flag(this, &#39;message&#39;, msg);
1075
+ var obj = flag(this, &#39;object&#39;);
1076
+ this.assert(
1077
+ obj.hasOwnProperty(name), &#39;expected #{this} to have own property &#39; + _.inspect(name), &#39;expected #{this} to not have own property &#39; + _.inspect(name));
1078
+ }
1079
+
1080
+ Assertion.addMethod(&#39;ownProperty&#39;, assertOwnProperty);
1081
+ Assertion.addMethod(&#39;haveOwnProperty&#39;, assertOwnProperty);
1082
+
1083
+ /</span><span class="ruby-operator">**</span>
1084
+ <span class="ruby-comment">### .length(value)</span>
1085
+
1086
+ <span class="ruby-constant">Asserts</span> <span class="ruby-identifier">that</span> <span class="ruby-identifier">the</span> <span class="ruby-identifier">target</span><span class="ruby-string">&#39;s `length` property has
1087
+ the expected value.
1088
+
1089
+ expect([ 1, 2, 3]).to.have.length(3);
1090
+ expect(&#39;</span><span class="ruby-identifier">foobar</span><span class="ruby-string">&#39;).to.have.length(6);
1091
+
1092
+ Can also be used as a chain precursor to a value
1093
+ comparison for the length property.
1094
+
1095
+ expect(&#39;</span><span class="ruby-identifier">foo</span><span class="ruby-string">&#39;).to.have.length.above(2);
1096
+ expect([ 1, 2, 3 ]).to.have.length.above(2);
1097
+ expect(&#39;</span><span class="ruby-identifier">foo</span><span class="ruby-string">&#39;).to.have.length.below(4);
1098
+ expect([ 1, 2, 3 ]).to.have.length.below(4);
1099
+ expect(&#39;</span><span class="ruby-identifier">foo</span><span class="ruby-string">&#39;).to.have.length.within(2,4);
1100
+ expect([ 1, 2, 3 ]).to.have.length.within(2,4);
1101
+
1102
+ @name length
1103
+ @alias lengthOf
1104
+ @param {Number} length
1105
+ @param {String} message _optional_
1106
+ @api public
1107
+ /
1108
+
1109
+ function assertLengthChain() {
1110
+ flag(this, &#39;</span><span class="ruby-identifier">doLength</span><span class="ruby-string">&#39;, true);
1111
+ }
1112
+
1113
+ function assertLength(n, msg) {
1114
+ if (msg) flag(this, &#39;</span><span class="ruby-identifier">message</span><span class="ruby-string">&#39;, msg);
1115
+ var obj = flag(this, &#39;</span><span class="ruby-identifier">object</span><span class="ruby-string">&#39;);
1116
+ new Assertion(obj, msg).to.have.property(&#39;</span><span class="ruby-identifier">length</span><span class="ruby-string">&#39;);
1117
+ var len = obj.length;
1118
+
1119
+ this.assert(
1120
+ len == n, &#39;</span><span class="ruby-identifier">expected</span> <span class="ruby-comment">#{this} to have a length of #{exp} but got #{act}&#39;, &#39;expected #{this} to not have a length of #{act}&#39;, n, len);</span>
1121
+ }
1122
+
1123
+ <span class="ruby-constant">Assertion</span>.<span class="ruby-identifier">addChainableMethod</span>(<span class="ruby-string">&#39;length&#39;</span>, <span class="ruby-identifier">assertLength</span>, <span class="ruby-identifier">assertLengthChain</span>);
1124
+ <span class="ruby-constant">Assertion</span>.<span class="ruby-identifier">addMethod</span>(<span class="ruby-string">&#39;lengthOf&#39;</span>, <span class="ruby-identifier">assertLength</span>, <span class="ruby-identifier">assertLengthChain</span>);
1125
+
1126
+ <span class="ruby-node">/**
1127
+ ### .match(regexp)
1128
+
1129
+ Asserts that the target matches a regular expression.
1130
+
1131
+ expect(&#39;foobar&#39;).to.match(/</span><span class="ruby-operator">^</span><span class="ruby-identifier">foo</span><span class="ruby-operator">/</span>);
1132
+
1133
+ <span class="ruby-ivar">@name</span> <span class="ruby-identifier">match</span>
1134
+ <span class="ruby-ivar">@param</span> {<span class="ruby-constant">RegExp</span>} <span class="ruby-constant">RegularExpression</span>
1135
+ <span class="ruby-ivar">@param</span> {<span class="ruby-constant">String</span>} <span class="ruby-identifier">message</span> <span class="ruby-identifier">_optional_</span>
1136
+ <span class="ruby-ivar">@api</span> <span class="ruby-identifier">public</span>
1137
+ <span class="ruby-node">/
1138
+
1139
+ Assertion.addMethod(&#39;match&#39;, function(re, msg) {
1140
+ if (msg) flag(this, &#39;message&#39;, msg);
1141
+ var obj = flag(this, &#39;object&#39;);
1142
+ this.assert(
1143
+ re.exec(obj), &#39;expected #{this} to match &#39; + re, &#39;expected #{this} not to match &#39; + re);
1144
+ });
1145
+
1146
+ /</span><span class="ruby-operator">**</span>
1147
+ <span class="ruby-comment">### .string(string)</span>
1148
+
1149
+ <span class="ruby-constant">Asserts</span> <span class="ruby-identifier">that</span> <span class="ruby-identifier">the</span> <span class="ruby-identifier">string</span> <span class="ruby-identifier">target</span> <span class="ruby-identifier">contains</span> <span class="ruby-identifier">another</span> <span class="ruby-identifier">string</span>.
1150
+
1151
+ <span class="ruby-identifier">expect</span>(<span class="ruby-string">&#39;foobar&#39;</span>).<span class="ruby-identifier">to</span>.<span class="ruby-identifier">have</span>.<span class="ruby-identifier">string</span>(<span class="ruby-string">&#39;bar&#39;</span>);
1152
+
1153
+ <span class="ruby-ivar">@name</span> <span class="ruby-identifier">string</span>
1154
+ <span class="ruby-ivar">@param</span> {<span class="ruby-constant">String</span>} <span class="ruby-identifier">string</span>
1155
+ <span class="ruby-ivar">@param</span> {<span class="ruby-constant">String</span>} <span class="ruby-identifier">message</span> <span class="ruby-identifier">_optional_</span>
1156
+ <span class="ruby-ivar">@api</span> <span class="ruby-identifier">public</span>
1157
+ <span class="ruby-node">/
1158
+
1159
+ Assertion.addMethod(&#39;string&#39;, function(str, msg) {
1160
+ if (msg) flag(this, &#39;message&#39;, msg);
1161
+ var obj = flag(this, &#39;object&#39;);
1162
+ new Assertion(obj, msg).is.a(&#39;string&#39;);
1163
+
1164
+ this.assert(~obj.indexOf(str), &#39;expected #{this} to contain &#39; + _.inspect(str), &#39;expected #{this} to not contain &#39; + _.inspect(str));
1165
+ });
1166
+
1167
+ /</span><span class="ruby-operator">**</span>
1168
+ <span class="ruby-comment">### .keys(key1, [key2], [...])</span>
1169
+
1170
+ <span class="ruby-constant">Asserts</span> <span class="ruby-identifier">that</span> <span class="ruby-identifier">the</span> <span class="ruby-identifier">target</span> <span class="ruby-identifier">has</span> <span class="ruby-identifier">exactly</span> <span class="ruby-identifier">the</span> <span class="ruby-identifier">given</span> <span class="ruby-identifier">keys</span>, <span class="ruby-keyword">or</span>
1171
+ <span class="ruby-identifier">asserts</span> <span class="ruby-identifier">the</span> <span class="ruby-identifier">inclusion</span> <span class="ruby-identifier">of</span> <span class="ruby-identifier">some</span> <span class="ruby-identifier">keys</span> <span class="ruby-keyword">when</span> <span class="ruby-identifier">using</span> <span class="ruby-identifier">the</span>
1172
+ <span class="ruby-value">%xinclude`</span> <span class="ruby-keyword">or</span> <span class="ruby-value">%xcontain`</span> <span class="ruby-identifier">modifiers</span>.
1173
+
1174
+ <span class="ruby-identifier">expect</span>({ <span class="ruby-identifier">foo</span><span class="ruby-operator">:</span> <span class="ruby-value">1</span>, <span class="ruby-identifier">bar</span><span class="ruby-operator">:</span> <span class="ruby-value">2</span> }).<span class="ruby-identifier">to</span>.<span class="ruby-identifier">have</span>.<span class="ruby-identifier">keys</span>([<span class="ruby-string">&#39;foo&#39;</span>, <span class="ruby-string">&#39;bar&#39;</span>]);
1175
+ <span class="ruby-identifier">expect</span>({ <span class="ruby-identifier">foo</span><span class="ruby-operator">:</span> <span class="ruby-value">1</span>, <span class="ruby-identifier">bar</span><span class="ruby-operator">:</span> <span class="ruby-value">2</span>, <span class="ruby-identifier">baz</span><span class="ruby-operator">:</span> <span class="ruby-value">3</span> }).<span class="ruby-identifier">to</span>.<span class="ruby-identifier">contain</span>.<span class="ruby-identifier">keys</span>(<span class="ruby-string">&#39;foo&#39;</span>, <span class="ruby-string">&#39;bar&#39;</span>);
1176
+
1177
+ <span class="ruby-ivar">@name</span> <span class="ruby-identifier">keys</span>
1178
+ <span class="ruby-ivar">@alias</span> <span class="ruby-identifier">key</span>
1179
+ <span class="ruby-ivar">@param</span> {<span class="ruby-constant">String</span><span class="ruby-operator">...</span><span class="ruby-operator">|</span><span class="ruby-constant">Array</span>} <span class="ruby-identifier">keys</span>
1180
+ <span class="ruby-ivar">@api</span> <span class="ruby-identifier">public</span>
1181
+ <span class="ruby-regexp">/
1182
+
1183
+ function assertKeys(keys) {
1184
+ var obj = flag(this, &#39;object&#39;),
1185
+ str, ok = true;
1186
+
1187
+ keys = keys instanceof Array ? keys : Array.prototype.slice.call(arguments);
1188
+
1189
+ if (!keys.length) throw new Error(&#39;keys required&#39;);
1190
+
1191
+ var actual = Object.keys(obj),
1192
+ len = keys.length;
1193
+
1194
+ /</span><span class="ruby-operator">/</span> <span class="ruby-constant">Inclusion</span>
1195
+ <span class="ruby-identifier">ok</span> = <span class="ruby-identifier">keys</span>.<span class="ruby-identifier">every</span>(<span class="ruby-identifier">function</span>(<span class="ruby-identifier">key</span>) {
1196
+ <span class="ruby-keyword">return</span> <span class="ruby-operator">~</span><span class="ruby-identifier">actual</span>.<span class="ruby-identifier">indexOf</span>(<span class="ruby-identifier">key</span>);
1197
+ });
1198
+
1199
+ <span class="ruby-regexp">//</span> <span class="ruby-constant">Strict</span>
1200
+ <span class="ruby-keyword">if</span> (<span class="ruby-operator">!</span><span class="ruby-identifier">flag</span>(<span class="ruby-identifier">this</span>, <span class="ruby-string">&#39;negate&#39;</span>) <span class="ruby-operator">&amp;&amp;</span> <span class="ruby-operator">!</span><span class="ruby-identifier">flag</span>(<span class="ruby-identifier">this</span>, <span class="ruby-string">&#39;contains&#39;</span>)) {
1201
+ <span class="ruby-identifier">ok</span> = <span class="ruby-identifier">ok</span> <span class="ruby-operator">&amp;&amp;</span> <span class="ruby-identifier">keys</span>.<span class="ruby-identifier">length</span> <span class="ruby-operator">==</span> <span class="ruby-identifier">actual</span>.<span class="ruby-identifier">length</span>;
1202
+ }
1203
+
1204
+ <span class="ruby-regexp">//</span> <span class="ruby-constant">Key</span> <span class="ruby-identifier">string</span>
1205
+ <span class="ruby-keyword">if</span> (<span class="ruby-identifier">len</span> <span class="ruby-operator">&gt;</span> <span class="ruby-value">1</span>) {
1206
+ <span class="ruby-identifier">keys</span> = <span class="ruby-identifier">keys</span>.<span class="ruby-identifier">map</span>(<span class="ruby-identifier">function</span>(<span class="ruby-identifier">key</span>) {
1207
+ <span class="ruby-keyword">return</span> <span class="ruby-identifier">_</span>.<span class="ruby-identifier">inspect</span>(<span class="ruby-identifier">key</span>);
1208
+ });
1209
+ <span class="ruby-identifier">var</span> <span class="ruby-identifier">last</span> = <span class="ruby-identifier">keys</span>.<span class="ruby-identifier">pop</span>();
1210
+ <span class="ruby-identifier">str</span> = <span class="ruby-identifier">keys</span>.<span class="ruby-identifier">join</span>(<span class="ruby-string">&#39;, &#39;</span>) <span class="ruby-operator">+</span> <span class="ruby-string">&#39;, and &#39;</span> <span class="ruby-operator">+</span> <span class="ruby-identifier">last</span>;
1211
+ } <span class="ruby-keyword">else</span> {
1212
+ <span class="ruby-identifier">str</span> = <span class="ruby-identifier">_</span>.<span class="ruby-identifier">inspect</span>(<span class="ruby-identifier">keys</span>[<span class="ruby-value">0</span>]);
1213
+ }
1214
+
1215
+ <span class="ruby-regexp">//</span> <span class="ruby-constant">Form</span>
1216
+ <span class="ruby-identifier">str</span> = (<span class="ruby-identifier">len</span> <span class="ruby-operator">&gt;</span> <span class="ruby-value">1</span> <span class="ruby-operator">?</span> <span class="ruby-string">&#39;keys &#39;</span> <span class="ruby-operator">:</span> <span class="ruby-string">&#39;key &#39;</span>) <span class="ruby-operator">+</span> <span class="ruby-identifier">str</span>;
1217
+
1218
+ <span class="ruby-regexp">//</span> <span class="ruby-constant">Have</span> <span class="ruby-operator">/</span> <span class="ruby-identifier">include</span>
1219
+ <span class="ruby-identifier">str</span> = (<span class="ruby-identifier">flag</span>(<span class="ruby-identifier">this</span>, <span class="ruby-string">&#39;contains&#39;</span>) <span class="ruby-operator">?</span> <span class="ruby-string">&#39;contain &#39;</span> <span class="ruby-operator">:</span> <span class="ruby-string">&#39;have &#39;</span>) <span class="ruby-operator">+</span> <span class="ruby-identifier">str</span>;
1220
+
1221
+ <span class="ruby-regexp">//</span> <span class="ruby-constant">Assertion</span>
1222
+ <span class="ruby-identifier">this</span>.<span class="ruby-identifier">assert</span>(
1223
+ <span class="ruby-identifier">ok</span>, <span class="ruby-string">&#39;expected #{this} to &#39;</span> <span class="ruby-operator">+</span> <span class="ruby-identifier">str</span>, <span class="ruby-string">&#39;expected #{this} to not &#39;</span> <span class="ruby-operator">+</span> <span class="ruby-identifier">str</span>);
1224
+ }
1225
+
1226
+ <span class="ruby-constant">Assertion</span>.<span class="ruby-identifier">addMethod</span>(<span class="ruby-string">&#39;keys&#39;</span>, <span class="ruby-identifier">assertKeys</span>);
1227
+ <span class="ruby-constant">Assertion</span>.<span class="ruby-identifier">addMethod</span>(<span class="ruby-string">&#39;key&#39;</span>, <span class="ruby-identifier">assertKeys</span>);
1228
+
1229
+ <span class="ruby-node">/**
1230
+ ### .throw(constructor)
1231
+
1232
+ Asserts that the function target will throw a specific error, or specific type of error
1233
+ (as determined using `instanceof`), optionally with a RegExp or string inclusion test
1234
+ for the error&#39;s message.
1235
+
1236
+ var err = new ReferenceError(&#39;This is a bad function.&#39;);
1237
+ var fn = function () { throw err; }
1238
+ expect(fn).to.throw(ReferenceError);
1239
+ expect(fn).to.throw(Error);
1240
+ expect(fn).to.throw(/</span><span class="ruby-identifier">bad</span> <span class="ruby-identifier">function</span><span class="ruby-operator">/</span>);
1241
+ <span class="ruby-identifier">expect</span>(<span class="ruby-identifier">fn</span>).<span class="ruby-identifier">to</span>.<span class="ruby-identifier">not</span>.<span class="ruby-identifier">throw</span>(<span class="ruby-string">&#39;good function&#39;</span>);
1242
+ <span class="ruby-identifier">expect</span>(<span class="ruby-identifier">fn</span>).<span class="ruby-identifier">to</span>.<span class="ruby-identifier">throw</span>(<span class="ruby-constant">ReferenceError</span>, <span class="ruby-regexp">/bad function/</span>);
1243
+ <span class="ruby-identifier">expect</span>(<span class="ruby-identifier">fn</span>).<span class="ruby-identifier">to</span>.<span class="ruby-identifier">throw</span>(<span class="ruby-identifier">err</span>);
1244
+ <span class="ruby-identifier">expect</span>(<span class="ruby-identifier">fn</span>).<span class="ruby-identifier">to</span>.<span class="ruby-identifier">not</span>.<span class="ruby-identifier">throw</span>(<span class="ruby-identifier">new</span> <span class="ruby-constant">RangeError</span>(<span class="ruby-string">&#39;Out of range.&#39;</span>));
1245
+
1246
+ <span class="ruby-constant">Please</span> <span class="ruby-identifier">note</span> <span class="ruby-identifier">that</span> <span class="ruby-keyword">when</span> <span class="ruby-identifier">a</span> <span class="ruby-identifier">throw</span> <span class="ruby-identifier">expectation</span> <span class="ruby-identifier">is</span> <span class="ruby-identifier">negated</span>, <span class="ruby-identifier">it</span> <span class="ruby-identifier">will</span> <span class="ruby-identifier">check</span> <span class="ruby-identifier">each</span>
1247
+ <span class="ruby-identifier">parameter</span> <span class="ruby-identifier">independently</span>, <span class="ruby-identifier">starting</span> <span class="ruby-identifier">with</span> <span class="ruby-identifier">error</span> <span class="ruby-identifier">constructor</span> <span class="ruby-identifier">type</span>. <span class="ruby-constant">The</span> <span class="ruby-identifier">appropriate</span> <span class="ruby-identifier">way</span>
1248
+ <span class="ruby-identifier">to</span> <span class="ruby-identifier">check</span> <span class="ruby-keyword">for</span> <span class="ruby-identifier">the</span> <span class="ruby-identifier">existence</span> <span class="ruby-identifier">of</span> <span class="ruby-identifier">a</span> <span class="ruby-identifier">type</span> <span class="ruby-identifier">of</span> <span class="ruby-identifier">error</span> <span class="ruby-identifier">but</span> <span class="ruby-keyword">for</span> <span class="ruby-identifier">a</span> <span class="ruby-identifier">message</span> <span class="ruby-identifier">that</span> <span class="ruby-identifier">does</span> <span class="ruby-keyword">not</span> <span class="ruby-identifier">match</span>
1249
+ <span class="ruby-identifier">is</span> <span class="ruby-identifier">to</span> <span class="ruby-identifier">use</span> <span class="ruby-value">%xand`</span>.
1250
+
1251
+ <span class="ruby-identifier">expect</span>(<span class="ruby-identifier">fn</span>).<span class="ruby-identifier">to</span>.<span class="ruby-identifier">throw</span>(<span class="ruby-constant">ReferenceError</span>)
1252
+ .<span class="ruby-identifier">and</span>.<span class="ruby-identifier">not</span>.<span class="ruby-identifier">throw</span>(<span class="ruby-regexp">/good function/</span>);
1253
+
1254
+ <span class="ruby-ivar">@name</span> <span class="ruby-identifier">throw</span>
1255
+ <span class="ruby-ivar">@alias</span> <span class="ruby-identifier">throws</span>
1256
+ <span class="ruby-ivar">@alias</span> <span class="ruby-constant">Throw</span>
1257
+ <span class="ruby-ivar">@param</span> {<span class="ruby-constant">ErrorConstructor</span>} <span class="ruby-identifier">constructor</span>
1258
+ <span class="ruby-ivar">@param</span> {<span class="ruby-constant">String</span><span class="ruby-operator">|</span><span class="ruby-constant">RegExp</span>} <span class="ruby-identifier">expected</span> <span class="ruby-identifier">error</span> <span class="ruby-identifier">message</span>
1259
+ <span class="ruby-ivar">@param</span> {<span class="ruby-constant">String</span>} <span class="ruby-identifier">message</span> <span class="ruby-identifier">_optional_</span>
1260
+ <span class="ruby-ivar">@see</span> <span class="ruby-identifier">https</span><span class="ruby-operator">:</span><span class="ruby-regexp">//</span><span class="ruby-identifier">developer</span>.<span class="ruby-identifier">mozilla</span>.<span class="ruby-identifier">org</span><span class="ruby-operator">/</span><span class="ruby-identifier">en</span><span class="ruby-operator">/</span><span class="ruby-constant">JavaScript</span><span class="ruby-operator">/</span><span class="ruby-constant">Reference</span><span class="ruby-operator">/</span><span class="ruby-constant">Global_Objects</span><span class="ruby-operator">/</span><span class="ruby-constant">Error</span><span class="ruby-comment">#Error_types</span>
1261
+ <span class="ruby-ivar">@api</span> <span class="ruby-identifier">public</span>
1262
+ <span class="ruby-regexp">/
1263
+
1264
+ function assertThrows(constructor, errMsg, msg) {
1265
+ if (msg) flag(this, &#39;message&#39;, msg);
1266
+ var obj = flag(this, &#39;object&#39;);
1267
+ new Assertion(obj, msg).is.a(&#39;function&#39;);
1268
+
1269
+ var thrown = false,
1270
+ desiredError = null,
1271
+ name = null,
1272
+ thrownError = null;
1273
+
1274
+ if (arguments.length === 0) {
1275
+ errMsg = null;
1276
+ constructor = null;
1277
+ } else if (constructor &amp;&amp; (constructor instanceof RegExp || &#39;string&#39; === typeof constructor)) {
1278
+ errMsg = constructor;
1279
+ constructor = null;
1280
+ } else if (constructor &amp;&amp; constructor instanceof Error) {
1281
+ desiredError = constructor;
1282
+ constructor = null;
1283
+ errMsg = null;
1284
+ } else if (typeof constructor === &#39;function&#39;) {
1285
+ name = (new constructor()).name;
1286
+ } else {
1287
+ constructor = null;
1288
+ }
1289
+
1290
+ try {
1291
+ obj();
1292
+ } catch (err) {
1293
+ /</span><span class="ruby-operator">/</span> <span class="ruby-identifier">first</span>, <span class="ruby-identifier">check</span> <span class="ruby-identifier">desired</span> <span class="ruby-identifier">error</span>
1294
+ <span class="ruby-keyword">if</span> (<span class="ruby-identifier">desiredError</span>) {
1295
+ <span class="ruby-identifier">this</span>.<span class="ruby-identifier">assert</span>(
1296
+ <span class="ruby-identifier">err</span> <span class="ruby-operator">===</span> <span class="ruby-identifier">desiredError</span>, <span class="ruby-string">&#39;expected #{this} to throw #{exp} but #{act} was thrown&#39;</span>, <span class="ruby-string">&#39;expected #{this} to not throw #{exp}&#39;</span>, <span class="ruby-identifier">desiredError</span>, <span class="ruby-identifier">err</span>);
1297
+
1298
+ <span class="ruby-keyword">return</span> <span class="ruby-identifier">this</span>;
1299
+ }
1300
+ <span class="ruby-regexp">//</span> <span class="ruby-keyword">next</span>, <span class="ruby-identifier">check</span> <span class="ruby-identifier">constructor</span>
1301
+ <span class="ruby-keyword">if</span> (<span class="ruby-identifier">constructor</span>) {
1302
+ <span class="ruby-identifier">this</span>.<span class="ruby-identifier">assert</span>(
1303
+ <span class="ruby-identifier">err</span> <span class="ruby-identifier">instanceof</span> <span class="ruby-identifier">constructor</span>, <span class="ruby-string">&#39;expected #{this} to throw #{exp} but #{act} was thrown&#39;</span>, <span class="ruby-string">&#39;expected #{this} to not throw #{exp} but #{act} was thrown&#39;</span>, <span class="ruby-identifier">name</span>, <span class="ruby-identifier">err</span>);
1304
+
1305
+ <span class="ruby-keyword">if</span> (<span class="ruby-operator">!</span><span class="ruby-identifier">errMsg</span>) <span class="ruby-keyword">return</span> <span class="ruby-identifier">this</span>;
1306
+ }
1307
+ <span class="ruby-regexp">//</span> <span class="ruby-keyword">next</span>, <span class="ruby-identifier">check</span> <span class="ruby-identifier">message</span>
1308
+ <span class="ruby-identifier">var</span> <span class="ruby-identifier">message</span> = <span class="ruby-string">&#39;object&#39;</span> <span class="ruby-operator">===</span> <span class="ruby-identifier">_</span>.<span class="ruby-identifier">type</span>(<span class="ruby-identifier">err</span>) <span class="ruby-operator">&amp;&amp;</span> <span class="ruby-string">&quot;message&quot;</span> <span class="ruby-keyword">in</span> <span class="ruby-identifier">err</span> <span class="ruby-operator">?</span> <span class="ruby-identifier">err</span>.<span class="ruby-identifier">message</span> <span class="ruby-operator">:</span> <span class="ruby-string">&#39;&#39;</span> <span class="ruby-operator">+</span> <span class="ruby-identifier">err</span>;
1309
+
1310
+ <span class="ruby-keyword">if</span> ((<span class="ruby-identifier">message</span> <span class="ruby-operator">!=</span> <span class="ruby-identifier">null</span>) <span class="ruby-operator">&amp;&amp;</span> <span class="ruby-identifier">errMsg</span> <span class="ruby-operator">&amp;&amp;</span> <span class="ruby-identifier">errMsg</span> <span class="ruby-identifier">instanceof</span> <span class="ruby-constant">RegExp</span>) {
1311
+ <span class="ruby-identifier">this</span>.<span class="ruby-identifier">assert</span>(
1312
+ <span class="ruby-identifier">errMsg</span>.<span class="ruby-identifier">exec</span>(<span class="ruby-identifier">message</span>), <span class="ruby-string">&#39;expected #{this} to throw error matching #{exp} but got #{act}&#39;</span>, <span class="ruby-string">&#39;expected #{this} to throw error not matching #{exp}&#39;</span>, <span class="ruby-identifier">errMsg</span>, <span class="ruby-identifier">message</span>);
1313
+
1314
+ <span class="ruby-keyword">return</span> <span class="ruby-identifier">this</span>;
1315
+ } <span class="ruby-keyword">else</span> <span class="ruby-keyword">if</span> ((<span class="ruby-identifier">message</span> <span class="ruby-operator">!=</span> <span class="ruby-identifier">null</span>) <span class="ruby-operator">&amp;&amp;</span> <span class="ruby-identifier">errMsg</span> <span class="ruby-operator">&amp;&amp;</span> <span class="ruby-string">&#39;string&#39;</span> <span class="ruby-operator">===</span> <span class="ruby-identifier">typeof</span> <span class="ruby-identifier">errMsg</span>) {
1316
+ <span class="ruby-identifier">this</span>.<span class="ruby-identifier">assert</span>(<span class="ruby-operator">~</span><span class="ruby-identifier">message</span>.<span class="ruby-identifier">indexOf</span>(<span class="ruby-identifier">errMsg</span>), <span class="ruby-string">&#39;expected #{this} to throw error including #{exp} but got #{act}&#39;</span>, <span class="ruby-string">&#39;expected #{this} to throw error not including #{act}&#39;</span>, <span class="ruby-identifier">errMsg</span>, <span class="ruby-identifier">message</span>);
1317
+
1318
+ <span class="ruby-keyword">return</span> <span class="ruby-identifier">this</span>;
1319
+ } <span class="ruby-keyword">else</span> {
1320
+ <span class="ruby-identifier">thrown</span> = <span class="ruby-keyword">true</span>;
1321
+ <span class="ruby-identifier">thrownError</span> = <span class="ruby-identifier">err</span>;
1322
+ }
1323
+ }
1324
+
1325
+ <span class="ruby-identifier">var</span> <span class="ruby-identifier">actuallyGot</span> = <span class="ruby-string">&#39;&#39;</span>,
1326
+ <span class="ruby-identifier">expectedThrown</span> = <span class="ruby-identifier">name</span> <span class="ruby-operator">!=</span>= <span class="ruby-identifier">null</span> <span class="ruby-operator">?</span> <span class="ruby-identifier">name</span> <span class="ruby-operator">:</span> <span class="ruby-identifier">desiredError</span> <span class="ruby-operator">?</span> <span class="ruby-string">&#39;#{exp}&#39;</span> <span class="ruby-operator">/</span><span class="ruby-node">/_.inspect(desiredError)
1327
+ :
1328
+ &#39;an error&#39;;
1329
+
1330
+ if (thrown) {
1331
+ actuallyGot = &#39; but #{act} was thrown&#39;
1332
+ }
1333
+
1334
+ this.assert(
1335
+ thrown === true, &#39;expected #{this} to throw &#39; + expectedThrown + actuallyGot, &#39;expected #{this} to not throw &#39; + expectedThrown + actuallyGot, desiredError, thrownError);
1336
+ };
1337
+
1338
+ Assertion.addMethod(&#39;throw&#39;, assertThrows);
1339
+ Assertion.addMethod(&#39;throws&#39;, assertThrows);
1340
+ Assertion.addMethod(&#39;Throw&#39;, assertThrows);
1341
+
1342
+ /</span><span class="ruby-operator">**</span>
1343
+ <span class="ruby-comment">### .respondTo(method)</span>
1344
+
1345
+ <span class="ruby-constant">Asserts</span> <span class="ruby-identifier">that</span> <span class="ruby-identifier">the</span> <span class="ruby-identifier">object</span> <span class="ruby-keyword">or</span> <span class="ruby-keyword">class</span> <span class="ruby-identifier">target</span> <span class="ruby-identifier">will</span> <span class="ruby-identifier">respond</span> <span class="ruby-identifier">to</span> <span class="ruby-identifier">a</span> <span class="ruby-identifier">method</span>.
1346
+
1347
+ <span class="ruby-constant">Klass</span>.<span class="ruby-identifier">prototype</span>.<span class="ruby-identifier">bar</span> = <span class="ruby-identifier">function</span>(){};
1348
+ <span class="ruby-identifier">expect</span>(<span class="ruby-constant">Klass</span>).<span class="ruby-identifier">to</span>.<span class="ruby-identifier">respondTo</span>(<span class="ruby-string">&#39;bar&#39;</span>);
1349
+ <span class="ruby-identifier">expect</span>(<span class="ruby-identifier">obj</span>).<span class="ruby-identifier">to</span>.<span class="ruby-identifier">respondTo</span>(<span class="ruby-string">&#39;bar&#39;</span>);
1350
+
1351
+ <span class="ruby-constant">To</span> <span class="ruby-identifier">check</span> <span class="ruby-keyword">if</span> <span class="ruby-identifier">a</span> <span class="ruby-identifier">constructor</span> <span class="ruby-identifier">will</span> <span class="ruby-identifier">respond</span> <span class="ruby-identifier">to</span> <span class="ruby-identifier">a</span> <span class="ruby-identifier">static</span> <span class="ruby-identifier">function</span>,
1352
+ <span class="ruby-identifier">set</span> <span class="ruby-identifier">the</span> <span class="ruby-value">%xitself`</span> <span class="ruby-identifier">flag</span>.
1353
+
1354
+ <span class="ruby-constant">Klass</span>.<span class="ruby-identifier">baz</span> = <span class="ruby-identifier">function</span>(){};
1355
+ <span class="ruby-identifier">expect</span>(<span class="ruby-constant">Klass</span>).<span class="ruby-identifier">itself</span>.<span class="ruby-identifier">to</span>.<span class="ruby-identifier">respondTo</span>(<span class="ruby-string">&#39;baz&#39;</span>);
1356
+
1357
+ <span class="ruby-ivar">@name</span> <span class="ruby-identifier">respondTo</span>
1358
+ <span class="ruby-ivar">@param</span> {<span class="ruby-constant">String</span>} <span class="ruby-identifier">method</span>
1359
+ <span class="ruby-ivar">@param</span> {<span class="ruby-constant">String</span>} <span class="ruby-identifier">message</span> <span class="ruby-identifier">_optional_</span>
1360
+ <span class="ruby-ivar">@api</span> <span class="ruby-identifier">public</span>
1361
+ <span class="ruby-node">/
1362
+
1363
+ Assertion.addMethod(&#39;respondTo&#39;, function(method, msg) {
1364
+ if (msg) flag(this, &#39;message&#39;, msg);
1365
+ var obj = flag(this, &#39;object&#39;),
1366
+ itself = flag(this, &#39;itself&#39;),
1367
+ context = (&#39;function&#39; === _.type(obj) &amp;&amp; !itself) ? obj.prototype[method] : obj[method];
1368
+
1369
+ this.assert(&#39;function&#39; === typeof context, &#39;expected #{this} to respond to &#39; + _.inspect(method), &#39;expected #{this} to not respond to &#39; + _.inspect(method));
1370
+ });
1371
+
1372
+ /</span><span class="ruby-operator">**</span>
1373
+ <span class="ruby-comment">### .itself</span>
1374
+
1375
+ <span class="ruby-constant">Sets</span> <span class="ruby-identifier">the</span> <span class="ruby-value">%xitself`</span> <span class="ruby-identifier">flag</span>, <span class="ruby-identifier">later</span> <span class="ruby-identifier">used</span> <span class="ruby-identifier">by</span> <span class="ruby-identifier">the</span> <span class="ruby-value">%xrespondTo`</span> <span class="ruby-identifier">assertion</span>.
1376
+
1377
+ <span class="ruby-identifier">function</span> <span class="ruby-constant">Foo</span>() {}
1378
+ <span class="ruby-constant">Foo</span>.<span class="ruby-identifier">bar</span> = <span class="ruby-identifier">function</span>() {}
1379
+ <span class="ruby-constant">Foo</span>.<span class="ruby-identifier">prototype</span>.<span class="ruby-identifier">baz</span> = <span class="ruby-identifier">function</span>() {}
1380
+
1381
+ <span class="ruby-identifier">expect</span>(<span class="ruby-constant">Foo</span>).<span class="ruby-identifier">itself</span>.<span class="ruby-identifier">to</span>.<span class="ruby-identifier">respondTo</span>(<span class="ruby-string">&#39;bar&#39;</span>);
1382
+ <span class="ruby-identifier">expect</span>(<span class="ruby-constant">Foo</span>).<span class="ruby-identifier">itself</span>.<span class="ruby-identifier">not</span>.<span class="ruby-identifier">to</span>.<span class="ruby-identifier">respondTo</span>(<span class="ruby-string">&#39;baz&#39;</span>);
1383
+
1384
+ <span class="ruby-ivar">@name</span> <span class="ruby-identifier">itself</span>
1385
+ <span class="ruby-ivar">@api</span> <span class="ruby-identifier">public</span>
1386
+ <span class="ruby-regexp">/
1387
+
1388
+ Assertion.addProperty(&#39;itself&#39;, function() {
1389
+ flag(this, &#39;itself&#39;, true);
1390
+ });
1391
+
1392
+ /</span><span class="ruby-operator">**</span>
1393
+ <span class="ruby-comment">### .satisfy(method)</span>
1394
+
1395
+ <span class="ruby-constant">Asserts</span> <span class="ruby-identifier">that</span> <span class="ruby-identifier">the</span> <span class="ruby-identifier">target</span> <span class="ruby-identifier">passes</span> <span class="ruby-identifier">a</span> <span class="ruby-identifier">given</span> <span class="ruby-identifier">truth</span> <span class="ruby-identifier">test</span>.
1396
+
1397
+ <span class="ruby-identifier">expect</span>(<span class="ruby-value">1</span>).<span class="ruby-identifier">to</span>.<span class="ruby-identifier">satisfy</span>(<span class="ruby-identifier">function</span>(<span class="ruby-identifier">num</span>) { <span class="ruby-keyword">return</span> <span class="ruby-identifier">num</span> <span class="ruby-operator">&gt;</span> <span class="ruby-value">0</span>; });
1398
+
1399
+ <span class="ruby-ivar">@name</span> <span class="ruby-identifier">satisfy</span>
1400
+ <span class="ruby-ivar">@param</span> {<span class="ruby-constant">Function</span>} <span class="ruby-identifier">matcher</span>
1401
+ <span class="ruby-ivar">@param</span> {<span class="ruby-constant">String</span>} <span class="ruby-identifier">message</span> <span class="ruby-identifier">_optional_</span>
1402
+ <span class="ruby-ivar">@api</span> <span class="ruby-identifier">public</span>
1403
+ <span class="ruby-node">/
1404
+
1405
+ Assertion.addMethod(&#39;satisfy&#39;, function(matcher, msg) {
1406
+ if (msg) flag(this, &#39;message&#39;, msg);
1407
+ var obj = flag(this, &#39;object&#39;);
1408
+ this.assert(
1409
+ matcher(obj), &#39;expected #{this} to satisfy &#39; + _.objDisplay(matcher), &#39;expected #{this} to not satisfy&#39; + _.objDisplay(matcher), this.negate ? false : true, matcher(obj));
1410
+ });
1411
+
1412
+ /</span><span class="ruby-operator">**</span>
1413
+ <span class="ruby-comment">### .closeTo(expected, delta)</span>
1414
+
1415
+ <span class="ruby-constant">Asserts</span> <span class="ruby-identifier">that</span> <span class="ruby-identifier">the</span> <span class="ruby-identifier">target</span> <span class="ruby-identifier">is</span> <span class="ruby-identifier">equal</span> <span class="ruby-value">%xexpected`</span>, <span class="ruby-identifier">to</span> <span class="ruby-identifier">within</span> <span class="ruby-identifier">a</span> <span class="ruby-operator">+</span><span class="ruby-regexp">/- `delta` range.
1416
+
1417
+ expect(1.5).to.be.closeTo(1, 0.5);
1418
+
1419
+ @name closeTo
1420
+ @param {Number} expected
1421
+ @param {Number} delta
1422
+ @param {String} message _optional_
1423
+ @api public
1424
+ /</span>
1425
+
1426
+ <span class="ruby-constant">Assertion</span>.<span class="ruby-identifier">addMethod</span>(<span class="ruby-string">&#39;closeTo&#39;</span>, <span class="ruby-identifier">function</span>(<span class="ruby-identifier">expected</span>, <span class="ruby-identifier">delta</span>, <span class="ruby-identifier">msg</span>) {
1427
+ <span class="ruby-keyword">if</span> (<span class="ruby-identifier">msg</span>) <span class="ruby-identifier">flag</span>(<span class="ruby-identifier">this</span>, <span class="ruby-string">&#39;message&#39;</span>, <span class="ruby-identifier">msg</span>);
1428
+ <span class="ruby-identifier">var</span> <span class="ruby-identifier">obj</span> = <span class="ruby-identifier">flag</span>(<span class="ruby-identifier">this</span>, <span class="ruby-string">&#39;object&#39;</span>);
1429
+ <span class="ruby-identifier">this</span>.<span class="ruby-identifier">assert</span>(
1430
+ <span class="ruby-constant">Math</span>.<span class="ruby-identifier">abs</span>(<span class="ruby-identifier">obj</span> <span class="ruby-operator">-</span> <span class="ruby-identifier">expected</span>) <span class="ruby-operator">&lt;=</span> <span class="ruby-identifier">delta</span>, <span class="ruby-string">&#39;expected #{this} to be close to &#39;</span> <span class="ruby-operator">+</span> <span class="ruby-identifier">expected</span> <span class="ruby-operator">+</span> <span class="ruby-string">&#39; +/- &#39;</span> <span class="ruby-operator">+</span> <span class="ruby-identifier">delta</span>, <span class="ruby-string">&#39;expected #{this} not to be close to &#39;</span> <span class="ruby-operator">+</span> <span class="ruby-identifier">expected</span> <span class="ruby-operator">+</span> <span class="ruby-string">&#39; +/- &#39;</span> <span class="ruby-operator">+</span> <span class="ruby-identifier">delta</span>);
1431
+ });
1432
+
1433
+ };
1434
+
1435
+ }); <span class="ruby-regexp">//</span> <span class="ruby-identifier">module</span><span class="ruby-operator">:</span> <span class="ruby-identifier">chai</span><span class="ruby-operator">/</span><span class="ruby-identifier">core</span><span class="ruby-operator">/</span><span class="ruby-identifier">assertions</span>.<span class="ruby-identifier">js</span>
1436
+ <span class="ruby-identifier">require</span>.<span class="ruby-identifier">register</span>(<span class="ruby-string">&quot;chai/error.js&quot;</span>, <span class="ruby-identifier">function</span>(<span class="ruby-keyword">module</span>, <span class="ruby-identifier">exports</span>, <span class="ruby-identifier">require</span>) {
1437
+ <span class="ruby-regexp">/*!
1438
+ chai
1439
+ Copyright(c) 2011-2013 Jake Luer &lt;jake@alogicalparadox.com&gt;
1440
+ MIT Licensed
1441
+ /</span>
1442
+
1443
+ <span class="ruby-regexp">/*!
1444
+ Main export
1445
+ /</span>
1446
+
1447
+ <span class="ruby-keyword">module</span>.<span class="ruby-identifier">exports</span> = <span class="ruby-constant">AssertionError</span>;
1448
+
1449
+ <span class="ruby-node">/**
1450
+ # AssertionError (constructor)
1451
+
1452
+ Create a new assertion error based on the Javascript
1453
+ `Error` prototype.
1454
+
1455
+ **Options**
1456
+ - message
1457
+ - actual
1458
+ - expected
1459
+ - operator
1460
+ - startStackFunction
1461
+
1462
+ @param {Object} options
1463
+ @api public
1464
+ /</span>
1465
+
1466
+ <span class="ruby-identifier">function</span> <span class="ruby-constant">AssertionError</span>(<span class="ruby-identifier">options</span>) {
1467
+ <span class="ruby-identifier">options</span> = <span class="ruby-identifier">options</span> <span class="ruby-operator">||</span> {};
1468
+ <span class="ruby-identifier">this</span>.<span class="ruby-identifier">message</span> = <span class="ruby-identifier">options</span>.<span class="ruby-identifier">message</span>;
1469
+ <span class="ruby-identifier">this</span>.<span class="ruby-identifier">actual</span> = <span class="ruby-identifier">options</span>.<span class="ruby-identifier">actual</span>;
1470
+ <span class="ruby-identifier">this</span>.<span class="ruby-identifier">expected</span> = <span class="ruby-identifier">options</span>.<span class="ruby-identifier">expected</span>;
1471
+ <span class="ruby-identifier">this</span>.<span class="ruby-identifier">operator</span> = <span class="ruby-identifier">options</span>.<span class="ruby-identifier">operator</span>;
1472
+ <span class="ruby-identifier">this</span>.<span class="ruby-identifier">showDiff</span> = <span class="ruby-identifier">options</span>.<span class="ruby-identifier">showDiff</span>;
1473
+
1474
+ <span class="ruby-keyword">if</span> (<span class="ruby-identifier">options</span>.<span class="ruby-identifier">stackStartFunction</span> <span class="ruby-operator">&amp;&amp;</span> <span class="ruby-constant">Error</span>.<span class="ruby-identifier">captureStackTrace</span>) {
1475
+ <span class="ruby-identifier">var</span> <span class="ruby-identifier">stackStartFunction</span> = <span class="ruby-identifier">options</span>.<span class="ruby-identifier">stackStartFunction</span>;
1476
+ <span class="ruby-constant">Error</span>.<span class="ruby-identifier">captureStackTrace</span>(<span class="ruby-identifier">this</span>, <span class="ruby-identifier">stackStartFunction</span>);
1477
+ }
1478
+ }
1479
+
1480
+ <span class="ruby-regexp">/*!
1481
+ Inherit from Error
1482
+ /</span>
1483
+
1484
+ <span class="ruby-constant">AssertionError</span>.<span class="ruby-identifier">prototype</span> = <span class="ruby-constant">Object</span>.<span class="ruby-identifier">create</span>(<span class="ruby-constant">Error</span>.<span class="ruby-identifier">prototype</span>);
1485
+ <span class="ruby-constant">AssertionError</span>.<span class="ruby-identifier">prototype</span>.<span class="ruby-identifier">name</span> = <span class="ruby-string">&#39;AssertionError&#39;</span>;
1486
+ <span class="ruby-constant">AssertionError</span>.<span class="ruby-identifier">prototype</span>.<span class="ruby-identifier">constructor</span> = <span class="ruby-constant">AssertionError</span>;
1487
+
1488
+ <span class="ruby-node">/**
1489
+ # toString()
1490
+
1491
+ Override default to string method
1492
+ /</span>
1493
+
1494
+ <span class="ruby-constant">AssertionError</span>.<span class="ruby-identifier">prototype</span>.<span class="ruby-identifier">toString</span> = <span class="ruby-identifier">function</span>() {
1495
+ <span class="ruby-keyword">return</span> <span class="ruby-identifier">this</span>.<span class="ruby-identifier">message</span>;
1496
+ };
1497
+
1498
+ }); <span class="ruby-regexp">//</span> <span class="ruby-identifier">module</span><span class="ruby-operator">:</span> <span class="ruby-identifier">chai</span><span class="ruby-operator">/</span><span class="ruby-identifier">error</span>.<span class="ruby-identifier">js</span>
1499
+ <span class="ruby-identifier">require</span>.<span class="ruby-identifier">register</span>(<span class="ruby-string">&quot;chai/interface/assert.js&quot;</span>, <span class="ruby-identifier">function</span>(<span class="ruby-keyword">module</span>, <span class="ruby-identifier">exports</span>, <span class="ruby-identifier">require</span>) {
1500
+ <span class="ruby-regexp">/*!
1501
+ chai
1502
+ Copyright(c) 2011-2013 Jake Luer &lt;jake@alogicalparadox.com&gt;
1503
+ MIT Licensed
1504
+ /</span>
1505
+
1506
+ <span class="ruby-keyword">module</span>.<span class="ruby-identifier">exports</span> = <span class="ruby-identifier">function</span>(<span class="ruby-identifier">chai</span>, <span class="ruby-identifier">util</span>) {
1507
+
1508
+ <span class="ruby-regexp">/*!
1509
+ Chai dependencies.
1510
+ /</span>
1511
+
1512
+ <span class="ruby-identifier">var</span> <span class="ruby-constant">Assertion</span> = <span class="ruby-identifier">chai</span>.<span class="ruby-constant">Assertion</span>,
1513
+ <span class="ruby-identifier">flag</span> = <span class="ruby-identifier">util</span>.<span class="ruby-identifier">flag</span>;
1514
+
1515
+ <span class="ruby-regexp">/*!
1516
+ Module export.
1517
+ /</span>
1518
+
1519
+ <span class="ruby-node">/**
1520
+ ### assert(expression, message)
1521
+
1522
+ Write your own test expressions.
1523
+
1524
+ assert(&#39;foo&#39; !== &#39;bar&#39;, &#39;foo is not bar&#39;);
1525
+ assert(Array.isArray([]), &#39;empty arrays are arrays&#39;);
1526
+
1527
+ @param {Mixed} expression to test for truthiness
1528
+ @param {String} message to display on error
1529
+ @name assert
1530
+ @api public
1531
+ /</span>
1532
+
1533
+ <span class="ruby-identifier">var</span> <span class="ruby-identifier">assert</span> = <span class="ruby-identifier">chai</span>.<span class="ruby-identifier">assert</span> = <span class="ruby-identifier">function</span>(<span class="ruby-identifier">express</span>, <span class="ruby-identifier">errmsg</span>) {
1534
+ <span class="ruby-identifier">var</span> <span class="ruby-identifier">test</span> = <span class="ruby-identifier">new</span> <span class="ruby-constant">Assertion</span>(<span class="ruby-identifier">null</span>);
1535
+ <span class="ruby-identifier">test</span>.<span class="ruby-identifier">assert</span>(
1536
+ <span class="ruby-identifier">express</span>, <span class="ruby-identifier">errmsg</span>, <span class="ruby-string">&#39;[ negation message unavailable ]&#39;</span>);
1537
+ };
1538
+
1539
+ <span class="ruby-node">/**
1540
+ ### .fail(actual, expected, [message], [operator])
1541
+
1542
+ Throw a failure. Node.js `assert` module-compatible.
1543
+
1544
+ @name fail
1545
+ @param {Mixed} actual
1546
+ @param {Mixed} expected
1547
+ @param {String} message
1548
+ @param {String} operator
1549
+ @api public
1550
+ /</span>
1551
+
1552
+ <span class="ruby-identifier">assert</span>.<span class="ruby-identifier">fail</span> = <span class="ruby-identifier">function</span>(<span class="ruby-identifier">actual</span>, <span class="ruby-identifier">expected</span>, <span class="ruby-identifier">message</span>, <span class="ruby-identifier">operator</span>) {
1553
+ <span class="ruby-identifier">throw</span> <span class="ruby-identifier">new</span> <span class="ruby-identifier">chai</span>.<span class="ruby-constant">AssertionError</span>({
1554
+ <span class="ruby-identifier">actual</span><span class="ruby-operator">:</span> <span class="ruby-identifier">actual</span>,
1555
+ <span class="ruby-identifier">expected</span><span class="ruby-operator">:</span> <span class="ruby-identifier">expected</span>,
1556
+ <span class="ruby-identifier">message</span><span class="ruby-operator">:</span> <span class="ruby-identifier">message</span>,
1557
+ <span class="ruby-identifier">operator</span><span class="ruby-operator">:</span> <span class="ruby-identifier">operator</span>,
1558
+ <span class="ruby-identifier">stackStartFunction</span><span class="ruby-operator">:</span> <span class="ruby-identifier">assert</span>.<span class="ruby-identifier">fail</span>
1559
+ });
1560
+ };
1561
+
1562
+ <span class="ruby-node">/**
1563
+ ### .ok(object, [message])
1564
+
1565
+ Asserts that `object` is truthy.
1566
+
1567
+ assert.ok(&#39;everything&#39;, &#39;everything is ok&#39;);
1568
+ assert.ok(false, &#39;this will fail&#39;);
1569
+
1570
+ @name ok
1571
+ @param {Mixed} object to test
1572
+ @param {String} message
1573
+ @api public
1574
+ /</span>
1575
+
1576
+ <span class="ruby-identifier">assert</span>.<span class="ruby-identifier">ok</span> = <span class="ruby-identifier">function</span>(<span class="ruby-identifier">val</span>, <span class="ruby-identifier">msg</span>) {
1577
+ <span class="ruby-identifier">new</span> <span class="ruby-constant">Assertion</span>(<span class="ruby-identifier">val</span>, <span class="ruby-identifier">msg</span>).<span class="ruby-identifier">is</span>.<span class="ruby-identifier">ok</span>;
1578
+ };
1579
+
1580
+ <span class="ruby-node">/**
1581
+ ### .equal(actual, expected, [message])
1582
+
1583
+ Asserts non-strict equality (`==`) of `actual` and `expected`.
1584
+
1585
+ assert.equal(3, &#39;3&#39;, &#39;== coerces values to strings&#39;);
1586
+
1587
+ @name equal
1588
+ @param {Mixed} actual
1589
+ @param {Mixed} expected
1590
+ @param {String} message
1591
+ @api public
1592
+ /</span>
1593
+
1594
+ <span class="ruby-identifier">assert</span>.<span class="ruby-identifier">equal</span> = <span class="ruby-identifier">function</span>(<span class="ruby-identifier">act</span>, <span class="ruby-identifier">exp</span>, <span class="ruby-identifier">msg</span>) {
1595
+ <span class="ruby-identifier">var</span> <span class="ruby-identifier">test</span> = <span class="ruby-identifier">new</span> <span class="ruby-constant">Assertion</span>(<span class="ruby-identifier">act</span>, <span class="ruby-identifier">msg</span>);
1596
+
1597
+ <span class="ruby-identifier">test</span>.<span class="ruby-identifier">assert</span>(
1598
+ <span class="ruby-identifier">exp</span> <span class="ruby-operator">==</span> <span class="ruby-identifier">flag</span>(<span class="ruby-identifier">test</span>, <span class="ruby-string">&#39;object&#39;</span>), <span class="ruby-string">&#39;expected #{this} to equal #{exp}&#39;</span>, <span class="ruby-string">&#39;expected #{this} to not equal #{act}&#39;</span>, <span class="ruby-identifier">exp</span>, <span class="ruby-identifier">act</span>);
1599
+ };
1600
+
1601
+ <span class="ruby-node">/**
1602
+ ### .notEqual(actual, expected, [message])
1603
+
1604
+ Asserts non-strict inequality (`!=`) of `actual` and `expected`.
1605
+
1606
+ assert.notEqual(3, 4, &#39;these numbers are not equal&#39;);
1607
+
1608
+ @name notEqual
1609
+ @param {Mixed} actual
1610
+ @param {Mixed} expected
1611
+ @param {String} message
1612
+ @api public
1613
+ /</span>
1614
+
1615
+ <span class="ruby-identifier">assert</span>.<span class="ruby-identifier">notEqual</span> = <span class="ruby-identifier">function</span>(<span class="ruby-identifier">act</span>, <span class="ruby-identifier">exp</span>, <span class="ruby-identifier">msg</span>) {
1616
+ <span class="ruby-identifier">var</span> <span class="ruby-identifier">test</span> = <span class="ruby-identifier">new</span> <span class="ruby-constant">Assertion</span>(<span class="ruby-identifier">act</span>, <span class="ruby-identifier">msg</span>);
1617
+
1618
+ <span class="ruby-identifier">test</span>.<span class="ruby-identifier">assert</span>(
1619
+ <span class="ruby-identifier">exp</span> <span class="ruby-operator">!=</span> <span class="ruby-identifier">flag</span>(<span class="ruby-identifier">test</span>, <span class="ruby-string">&#39;object&#39;</span>), <span class="ruby-string">&#39;expected #{this} to not equal #{exp}&#39;</span>, <span class="ruby-string">&#39;expected #{this} to equal #{act}&#39;</span>, <span class="ruby-identifier">exp</span>, <span class="ruby-identifier">act</span>);
1620
+ };
1621
+
1622
+ <span class="ruby-node">/**
1623
+ ### .strictEqual(actual, expected, [message])
1624
+
1625
+ Asserts strict equality (`===`) of `actual` and `expected`.
1626
+
1627
+ assert.strictEqual(true, true, &#39;these booleans are strictly equal&#39;);
1628
+
1629
+ @name strictEqual
1630
+ @param {Mixed} actual
1631
+ @param {Mixed} expected
1632
+ @param {String} message
1633
+ @api public
1634
+ /</span>
1635
+
1636
+ <span class="ruby-identifier">assert</span>.<span class="ruby-identifier">strictEqual</span> = <span class="ruby-identifier">function</span>(<span class="ruby-identifier">act</span>, <span class="ruby-identifier">exp</span>, <span class="ruby-identifier">msg</span>) {
1637
+ <span class="ruby-identifier">new</span> <span class="ruby-constant">Assertion</span>(<span class="ruby-identifier">act</span>, <span class="ruby-identifier">msg</span>).<span class="ruby-identifier">to</span>.<span class="ruby-identifier">equal</span>(<span class="ruby-identifier">exp</span>);
1638
+ };
1639
+
1640
+ <span class="ruby-node">/**
1641
+ ### .notStrictEqual(actual, expected, [message])
1642
+
1643
+ Asserts strict inequality (`!==`) of `actual` and `expected`.
1644
+
1645
+ assert.notStrictEqual(3, &#39;3&#39;, &#39;no coercion for strict equality&#39;);
1646
+
1647
+ @name notStrictEqual
1648
+ @param {Mixed} actual
1649
+ @param {Mixed} expected
1650
+ @param {String} message
1651
+ @api public
1652
+ /</span>
1653
+
1654
+ <span class="ruby-identifier">assert</span>.<span class="ruby-identifier">notStrictEqual</span> = <span class="ruby-identifier">function</span>(<span class="ruby-identifier">act</span>, <span class="ruby-identifier">exp</span>, <span class="ruby-identifier">msg</span>) {
1655
+ <span class="ruby-identifier">new</span> <span class="ruby-constant">Assertion</span>(<span class="ruby-identifier">act</span>, <span class="ruby-identifier">msg</span>).<span class="ruby-identifier">to</span>.<span class="ruby-identifier">not</span>.<span class="ruby-identifier">equal</span>(<span class="ruby-identifier">exp</span>);
1656
+ };
1657
+
1658
+ <span class="ruby-node">/**
1659
+ ### .deepEqual(actual, expected, [message])
1660
+
1661
+ Asserts that `actual` is deeply equal to `expected`.
1662
+
1663
+ assert.deepEqual({ tea: &#39;green&#39; }, { tea: &#39;green&#39; });
1664
+
1665
+ @name deepEqual
1666
+ @param {Mixed} actual
1667
+ @param {Mixed} expected
1668
+ @param {String} message
1669
+ @api public
1670
+ /</span>
1671
+
1672
+ <span class="ruby-identifier">assert</span>.<span class="ruby-identifier">deepEqual</span> = <span class="ruby-identifier">function</span>(<span class="ruby-identifier">act</span>, <span class="ruby-identifier">exp</span>, <span class="ruby-identifier">msg</span>) {
1673
+ <span class="ruby-identifier">new</span> <span class="ruby-constant">Assertion</span>(<span class="ruby-identifier">act</span>, <span class="ruby-identifier">msg</span>).<span class="ruby-identifier">to</span>.<span class="ruby-identifier">eql</span>(<span class="ruby-identifier">exp</span>);
1674
+ };
1675
+
1676
+ <span class="ruby-node">/**
1677
+ ### .notDeepEqual(actual, expected, [message])
1678
+
1679
+ Assert that `actual` is not deeply equal to `expected`.
1680
+
1681
+ assert.notDeepEqual({ tea: &#39;green&#39; }, { tea: &#39;jasmine&#39; });
1682
+
1683
+ @name notDeepEqual
1684
+ @param {Mixed} actual
1685
+ @param {Mixed} expected
1686
+ @param {String} message
1687
+ @api public
1688
+ /</span>
1689
+
1690
+ <span class="ruby-identifier">assert</span>.<span class="ruby-identifier">notDeepEqual</span> = <span class="ruby-identifier">function</span>(<span class="ruby-identifier">act</span>, <span class="ruby-identifier">exp</span>, <span class="ruby-identifier">msg</span>) {
1691
+ <span class="ruby-identifier">new</span> <span class="ruby-constant">Assertion</span>(<span class="ruby-identifier">act</span>, <span class="ruby-identifier">msg</span>).<span class="ruby-identifier">to</span>.<span class="ruby-identifier">not</span>.<span class="ruby-identifier">eql</span>(<span class="ruby-identifier">exp</span>);
1692
+ };
1693
+
1694
+ <span class="ruby-node">/**
1695
+ ### .isTrue(value, [message])
1696
+
1697
+ Asserts that `value` is true.
1698
+
1699
+ var teaServed = true;
1700
+ assert.isTrue(teaServed, &#39;the tea has been served&#39;);
1701
+
1702
+ @name isTrue
1703
+ @param {Mixed} value
1704
+ @param {String} message
1705
+ @api public
1706
+ /</span>
1707
+
1708
+ <span class="ruby-identifier">assert</span>.<span class="ruby-identifier">isTrue</span> = <span class="ruby-identifier">function</span>(<span class="ruby-identifier">val</span>, <span class="ruby-identifier">msg</span>) {
1709
+ <span class="ruby-identifier">new</span> <span class="ruby-constant">Assertion</span>(<span class="ruby-identifier">val</span>, <span class="ruby-identifier">msg</span>).<span class="ruby-identifier">is</span>[<span class="ruby-string">&#39;true&#39;</span>];
1710
+ };
1711
+
1712
+ <span class="ruby-node">/**
1713
+ ### .isFalse(value, [message])
1714
+
1715
+ Asserts that `value` is false.
1716
+
1717
+ var teaServed = false;
1718
+ assert.isFalse(teaServed, &#39;no tea yet? hmm...&#39;);
1719
+
1720
+ @name isFalse
1721
+ @param {Mixed} value
1722
+ @param {String} message
1723
+ @api public
1724
+ /</span>
1725
+
1726
+ <span class="ruby-identifier">assert</span>.<span class="ruby-identifier">isFalse</span> = <span class="ruby-identifier">function</span>(<span class="ruby-identifier">val</span>, <span class="ruby-identifier">msg</span>) {
1727
+ <span class="ruby-identifier">new</span> <span class="ruby-constant">Assertion</span>(<span class="ruby-identifier">val</span>, <span class="ruby-identifier">msg</span>).<span class="ruby-identifier">is</span>[<span class="ruby-string">&#39;false&#39;</span>];
1728
+ };
1729
+
1730
+ <span class="ruby-node">/**
1731
+ ### .isNull(value, [message])
1732
+
1733
+ Asserts that `value` is null.
1734
+
1735
+ assert.isNull(err, &#39;there was no error&#39;);
1736
+
1737
+ @name isNull
1738
+ @param {Mixed} value
1739
+ @param {String} message
1740
+ @api public
1741
+ /</span>
1742
+
1743
+ <span class="ruby-identifier">assert</span>.<span class="ruby-identifier">isNull</span> = <span class="ruby-identifier">function</span>(<span class="ruby-identifier">val</span>, <span class="ruby-identifier">msg</span>) {
1744
+ <span class="ruby-identifier">new</span> <span class="ruby-constant">Assertion</span>(<span class="ruby-identifier">val</span>, <span class="ruby-identifier">msg</span>).<span class="ruby-identifier">to</span>.<span class="ruby-identifier">equal</span>(<span class="ruby-identifier">null</span>);
1745
+ };
1746
+
1747
+ <span class="ruby-node">/**
1748
+ ### .isNotNull(value, [message])
1749
+
1750
+ Asserts that `value` is not null.
1751
+
1752
+ var tea = &#39;tasty chai&#39;;
1753
+ assert.isNotNull(tea, &#39;great, time for tea!&#39;);
1754
+
1755
+ @name isNotNull
1756
+ @param {Mixed} value
1757
+ @param {String} message
1758
+ @api public
1759
+ /</span>
1760
+
1761
+ <span class="ruby-identifier">assert</span>.<span class="ruby-identifier">isNotNull</span> = <span class="ruby-identifier">function</span>(<span class="ruby-identifier">val</span>, <span class="ruby-identifier">msg</span>) {
1762
+ <span class="ruby-identifier">new</span> <span class="ruby-constant">Assertion</span>(<span class="ruby-identifier">val</span>, <span class="ruby-identifier">msg</span>).<span class="ruby-identifier">to</span>.<span class="ruby-identifier">not</span>.<span class="ruby-identifier">equal</span>(<span class="ruby-identifier">null</span>);
1763
+ };
1764
+
1765
+ <span class="ruby-node">/**
1766
+ ### .isUndefined(value, [message])
1767
+
1768
+ Asserts that `value` is `undefined`.
1769
+
1770
+ var tea;
1771
+ assert.isUndefined(tea, &#39;no tea defined&#39;);
1772
+
1773
+ @name isUndefined
1774
+ @param {Mixed} value
1775
+ @param {String} message
1776
+ @api public
1777
+ /</span>
1778
+
1779
+ <span class="ruby-identifier">assert</span>.<span class="ruby-identifier">isUndefined</span> = <span class="ruby-identifier">function</span>(<span class="ruby-identifier">val</span>, <span class="ruby-identifier">msg</span>) {
1780
+ <span class="ruby-identifier">new</span> <span class="ruby-constant">Assertion</span>(<span class="ruby-identifier">val</span>, <span class="ruby-identifier">msg</span>).<span class="ruby-identifier">to</span>.<span class="ruby-identifier">equal</span>(<span class="ruby-identifier">undefined</span>);
1781
+ };
1782
+
1783
+ <span class="ruby-node">/**
1784
+ ### .isDefined(value, [message])
1785
+
1786
+ Asserts that `value` is not `undefined`.
1787
+
1788
+ var tea = &#39;cup of chai&#39;;
1789
+ assert.isDefined(tea, &#39;tea has been defined&#39;);
1790
+
1791
+ @name isUndefined
1792
+ @param {Mixed} value
1793
+ @param {String} message
1794
+ @api public
1795
+ /</span>
1796
+
1797
+ <span class="ruby-identifier">assert</span>.<span class="ruby-identifier">isDefined</span> = <span class="ruby-identifier">function</span>(<span class="ruby-identifier">val</span>, <span class="ruby-identifier">msg</span>) {
1798
+ <span class="ruby-identifier">new</span> <span class="ruby-constant">Assertion</span>(<span class="ruby-identifier">val</span>, <span class="ruby-identifier">msg</span>).<span class="ruby-identifier">to</span>.<span class="ruby-identifier">not</span>.<span class="ruby-identifier">equal</span>(<span class="ruby-identifier">undefined</span>);
1799
+ };
1800
+
1801
+ <span class="ruby-node">/**
1802
+ ### .isFunction(value, [message])
1803
+
1804
+ Asserts that `value` is a function.
1805
+
1806
+ function serveTea() { return &#39;cup of tea&#39;; };
1807
+ assert.isFunction(serveTea, &#39;great, we can have tea now&#39;);
1808
+
1809
+ @name isFunction
1810
+ @param {Mixed} value
1811
+ @param {String} message
1812
+ @api public
1813
+ /</span>
1814
+
1815
+ <span class="ruby-identifier">assert</span>.<span class="ruby-identifier">isFunction</span> = <span class="ruby-identifier">function</span>(<span class="ruby-identifier">val</span>, <span class="ruby-identifier">msg</span>) {
1816
+ <span class="ruby-identifier">new</span> <span class="ruby-constant">Assertion</span>(<span class="ruby-identifier">val</span>, <span class="ruby-identifier">msg</span>).<span class="ruby-identifier">to</span>.<span class="ruby-identifier">be</span>.<span class="ruby-identifier">a</span>(<span class="ruby-string">&#39;function&#39;</span>);
1817
+ };
1818
+
1819
+ <span class="ruby-node">/**
1820
+ ### .isNotFunction(value, [message])
1821
+
1822
+ Asserts that `value` is _not_ a function.
1823
+
1824
+ var serveTea = [ &#39;heat&#39;, &#39;pour&#39;, &#39;sip&#39; ];
1825
+ assert.isNotFunction(serveTea, &#39;great, we have listed the steps&#39;);
1826
+
1827
+ @name isNotFunction
1828
+ @param {Mixed} value
1829
+ @param {String} message
1830
+ @api public
1831
+ /</span>
1832
+
1833
+ <span class="ruby-identifier">assert</span>.<span class="ruby-identifier">isNotFunction</span> = <span class="ruby-identifier">function</span>(<span class="ruby-identifier">val</span>, <span class="ruby-identifier">msg</span>) {
1834
+ <span class="ruby-identifier">new</span> <span class="ruby-constant">Assertion</span>(<span class="ruby-identifier">val</span>, <span class="ruby-identifier">msg</span>).<span class="ruby-identifier">to</span>.<span class="ruby-identifier">not</span>.<span class="ruby-identifier">be</span>.<span class="ruby-identifier">a</span>(<span class="ruby-string">&#39;function&#39;</span>);
1835
+ };
1836
+
1837
+ <span class="ruby-node">/**
1838
+ ### .isObject(value, [message])
1839
+
1840
+ Asserts that `value` is an object (as revealed by
1841
+ `Object.prototype.toString`).
1842
+
1843
+ var selection = { name: &#39;Chai&#39;, serve: &#39;with spices&#39; };
1844
+ assert.isObject(selection, &#39;tea selection is an object&#39;);
1845
+
1846
+ @name isObject
1847
+ @param {Mixed} value
1848
+ @param {String} message
1849
+ @api public
1850
+ /</span>
1851
+
1852
+ <span class="ruby-identifier">assert</span>.<span class="ruby-identifier">isObject</span> = <span class="ruby-identifier">function</span>(<span class="ruby-identifier">val</span>, <span class="ruby-identifier">msg</span>) {
1853
+ <span class="ruby-identifier">new</span> <span class="ruby-constant">Assertion</span>(<span class="ruby-identifier">val</span>, <span class="ruby-identifier">msg</span>).<span class="ruby-identifier">to</span>.<span class="ruby-identifier">be</span>.<span class="ruby-identifier">a</span>(<span class="ruby-string">&#39;object&#39;</span>);
1854
+ };
1855
+
1856
+ <span class="ruby-node">/**
1857
+ ### .isNotObject(value, [message])
1858
+
1859
+ Asserts that `value` is _not_ an object.
1860
+
1861
+ var selection = &#39;chai&#39;
1862
+ assert.isObject(selection, &#39;tea selection is not an object&#39;);
1863
+ assert.isObject(null, &#39;null is not an object&#39;);
1864
+
1865
+ @name isNotObject
1866
+ @param {Mixed} value
1867
+ @param {String} message
1868
+ @api public
1869
+ /</span>
1870
+
1871
+ <span class="ruby-identifier">assert</span>.<span class="ruby-identifier">isNotObject</span> = <span class="ruby-identifier">function</span>(<span class="ruby-identifier">val</span>, <span class="ruby-identifier">msg</span>) {
1872
+ <span class="ruby-identifier">new</span> <span class="ruby-constant">Assertion</span>(<span class="ruby-identifier">val</span>, <span class="ruby-identifier">msg</span>).<span class="ruby-identifier">to</span>.<span class="ruby-identifier">not</span>.<span class="ruby-identifier">be</span>.<span class="ruby-identifier">a</span>(<span class="ruby-string">&#39;object&#39;</span>);
1873
+ };
1874
+
1875
+ <span class="ruby-node">/**
1876
+ ### .isArray(value, [message])
1877
+
1878
+ Asserts that `value` is an array.
1879
+
1880
+ var menu = [ &#39;green&#39;, &#39;chai&#39;, &#39;oolong&#39; ];
1881
+ assert.isArray(menu, &#39;what kind of tea do we want?&#39;);
1882
+
1883
+ @name isArray
1884
+ @param {Mixed} value
1885
+ @param {String} message
1886
+ @api public
1887
+ /</span>
1888
+
1889
+ <span class="ruby-identifier">assert</span>.<span class="ruby-identifier">isArray</span> = <span class="ruby-identifier">function</span>(<span class="ruby-identifier">val</span>, <span class="ruby-identifier">msg</span>) {
1890
+ <span class="ruby-identifier">new</span> <span class="ruby-constant">Assertion</span>(<span class="ruby-identifier">val</span>, <span class="ruby-identifier">msg</span>).<span class="ruby-identifier">to</span>.<span class="ruby-identifier">be</span>.<span class="ruby-identifier">an</span>(<span class="ruby-string">&#39;array&#39;</span>);
1891
+ };
1892
+
1893
+ <span class="ruby-node">/**
1894
+ ### .isNotArray(value, [message])
1895
+
1896
+ Asserts that `value` is _not_ an array.
1897
+
1898
+ var menu = &#39;green|chai|oolong&#39;;
1899
+ assert.isNotArray(menu, &#39;what kind of tea do we want?&#39;);
1900
+
1901
+ @name isNotArray
1902
+ @param {Mixed} value
1903
+ @param {String} message
1904
+ @api public
1905
+ /</span>
1906
+
1907
+ <span class="ruby-identifier">assert</span>.<span class="ruby-identifier">isNotArray</span> = <span class="ruby-identifier">function</span>(<span class="ruby-identifier">val</span>, <span class="ruby-identifier">msg</span>) {
1908
+ <span class="ruby-identifier">new</span> <span class="ruby-constant">Assertion</span>(<span class="ruby-identifier">val</span>, <span class="ruby-identifier">msg</span>).<span class="ruby-identifier">to</span>.<span class="ruby-identifier">not</span>.<span class="ruby-identifier">be</span>.<span class="ruby-identifier">an</span>(<span class="ruby-string">&#39;array&#39;</span>);
1909
+ };
1910
+
1911
+ <span class="ruby-node">/**
1912
+ ### .isString(value, [message])
1913
+
1914
+ Asserts that `value` is a string.
1915
+
1916
+ var teaOrder = &#39;chai&#39;;
1917
+ assert.isString(teaOrder, &#39;order placed&#39;);
1918
+
1919
+ @name isString
1920
+ @param {Mixed} value
1921
+ @param {String} message
1922
+ @api public
1923
+ /</span>
1924
+
1925
+ <span class="ruby-identifier">assert</span>.<span class="ruby-identifier">isString</span> = <span class="ruby-identifier">function</span>(<span class="ruby-identifier">val</span>, <span class="ruby-identifier">msg</span>) {
1926
+ <span class="ruby-identifier">new</span> <span class="ruby-constant">Assertion</span>(<span class="ruby-identifier">val</span>, <span class="ruby-identifier">msg</span>).<span class="ruby-identifier">to</span>.<span class="ruby-identifier">be</span>.<span class="ruby-identifier">a</span>(<span class="ruby-string">&#39;string&#39;</span>);
1927
+ };
1928
+
1929
+ <span class="ruby-node">/**
1930
+ ### .isNotString(value, [message])
1931
+
1932
+ Asserts that `value` is _not_ a string.
1933
+
1934
+ var teaOrder = 4;
1935
+ assert.isNotString(teaOrder, &#39;order placed&#39;);
1936
+
1937
+ @name isNotString
1938
+ @param {Mixed} value
1939
+ @param {String} message
1940
+ @api public
1941
+ /</span>
1942
+
1943
+ <span class="ruby-identifier">assert</span>.<span class="ruby-identifier">isNotString</span> = <span class="ruby-identifier">function</span>(<span class="ruby-identifier">val</span>, <span class="ruby-identifier">msg</span>) {
1944
+ <span class="ruby-identifier">new</span> <span class="ruby-constant">Assertion</span>(<span class="ruby-identifier">val</span>, <span class="ruby-identifier">msg</span>).<span class="ruby-identifier">to</span>.<span class="ruby-identifier">not</span>.<span class="ruby-identifier">be</span>.<span class="ruby-identifier">a</span>(<span class="ruby-string">&#39;string&#39;</span>);
1945
+ };
1946
+
1947
+ <span class="ruby-node">/**
1948
+ ### .isNumber(value, [message])
1949
+
1950
+ Asserts that `value` is a number.
1951
+
1952
+ var cups = 2;
1953
+ assert.isNumber(cups, &#39;how many cups&#39;);
1954
+
1955
+ @name isNumber
1956
+ @param {Number} value
1957
+ @param {String} message
1958
+ @api public
1959
+ /</span>
1960
+
1961
+ <span class="ruby-identifier">assert</span>.<span class="ruby-identifier">isNumber</span> = <span class="ruby-identifier">function</span>(<span class="ruby-identifier">val</span>, <span class="ruby-identifier">msg</span>) {
1962
+ <span class="ruby-identifier">new</span> <span class="ruby-constant">Assertion</span>(<span class="ruby-identifier">val</span>, <span class="ruby-identifier">msg</span>).<span class="ruby-identifier">to</span>.<span class="ruby-identifier">be</span>.<span class="ruby-identifier">a</span>(<span class="ruby-string">&#39;number&#39;</span>);
1963
+ };
1964
+
1965
+ <span class="ruby-node">/**
1966
+ ### .isNotNumber(value, [message])
1967
+
1968
+ Asserts that `value` is _not_ a number.
1969
+
1970
+ var cups = &#39;2 cups please&#39;;
1971
+ assert.isNotNumber(cups, &#39;how many cups&#39;);
1972
+
1973
+ @name isNotNumber
1974
+ @param {Mixed} value
1975
+ @param {String} message
1976
+ @api public
1977
+ /</span>
1978
+
1979
+ <span class="ruby-identifier">assert</span>.<span class="ruby-identifier">isNotNumber</span> = <span class="ruby-identifier">function</span>(<span class="ruby-identifier">val</span>, <span class="ruby-identifier">msg</span>) {
1980
+ <span class="ruby-identifier">new</span> <span class="ruby-constant">Assertion</span>(<span class="ruby-identifier">val</span>, <span class="ruby-identifier">msg</span>).<span class="ruby-identifier">to</span>.<span class="ruby-identifier">not</span>.<span class="ruby-identifier">be</span>.<span class="ruby-identifier">a</span>(<span class="ruby-string">&#39;number&#39;</span>);
1981
+ };
1982
+
1983
+ <span class="ruby-node">/**
1984
+ ### .isBoolean(value, [message])
1985
+
1986
+ Asserts that `value` is a boolean.
1987
+
1988
+ var teaReady = true
1989
+ , teaServed = false;
1990
+
1991
+ assert.isBoolean(teaReady, &#39;is the tea ready&#39;);
1992
+ assert.isBoolean(teaServed, &#39;has tea been served&#39;);
1993
+
1994
+ @name isBoolean
1995
+ @param {Mixed} value
1996
+ @param {String} message
1997
+ @api public
1998
+ /</span>
1999
+
2000
+ <span class="ruby-identifier">assert</span>.<span class="ruby-identifier">isBoolean</span> = <span class="ruby-identifier">function</span>(<span class="ruby-identifier">val</span>, <span class="ruby-identifier">msg</span>) {
2001
+ <span class="ruby-identifier">new</span> <span class="ruby-constant">Assertion</span>(<span class="ruby-identifier">val</span>, <span class="ruby-identifier">msg</span>).<span class="ruby-identifier">to</span>.<span class="ruby-identifier">be</span>.<span class="ruby-identifier">a</span>(<span class="ruby-string">&#39;boolean&#39;</span>);
2002
+ };
2003
+
2004
+ <span class="ruby-node">/**
2005
+ ### .isNotBoolean(value, [message])
2006
+
2007
+ Asserts that `value` is _not_ a boolean.
2008
+
2009
+ var teaReady = &#39;yep&#39;
2010
+ , teaServed = &#39;nope&#39;;
2011
+
2012
+ assert.isNotBoolean(teaReady, &#39;is the tea ready&#39;);
2013
+ assert.isNotBoolean(teaServed, &#39;has tea been served&#39;);
2014
+
2015
+ @name isNotBoolean
2016
+ @param {Mixed} value
2017
+ @param {String} message
2018
+ @api public
2019
+ /</span>
2020
+
2021
+ <span class="ruby-identifier">assert</span>.<span class="ruby-identifier">isNotBoolean</span> = <span class="ruby-identifier">function</span>(<span class="ruby-identifier">val</span>, <span class="ruby-identifier">msg</span>) {
2022
+ <span class="ruby-identifier">new</span> <span class="ruby-constant">Assertion</span>(<span class="ruby-identifier">val</span>, <span class="ruby-identifier">msg</span>).<span class="ruby-identifier">to</span>.<span class="ruby-identifier">not</span>.<span class="ruby-identifier">be</span>.<span class="ruby-identifier">a</span>(<span class="ruby-string">&#39;boolean&#39;</span>);
2023
+ };
2024
+
2025
+ <span class="ruby-node">/**
2026
+ ### .typeOf(value, name, [message])
2027
+
2028
+ Asserts that `value`&#39;s type is `name`, as determined by
2029
+ `Object.prototype.toString`.
2030
+
2031
+ assert.typeOf({ tea: &#39;chai&#39; }, &#39;object&#39;, &#39;we have an object&#39;);
2032
+ assert.typeOf([&#39;chai&#39;, &#39;jasmine&#39;], &#39;array&#39;, &#39;we have an array&#39;);
2033
+ assert.typeOf(&#39;tea&#39;, &#39;string&#39;, &#39;we have a string&#39;);
2034
+ assert.typeOf(/</span><span class="ruby-identifier">tea</span><span class="ruby-operator">/</span>, <span class="ruby-string">&#39;regexp&#39;</span>, <span class="ruby-string">&#39;we have a regular expression&#39;</span>);
2035
+ <span class="ruby-identifier">assert</span>.<span class="ruby-identifier">typeOf</span>(<span class="ruby-identifier">null</span>, <span class="ruby-string">&#39;null&#39;</span>, <span class="ruby-string">&#39;we have a null&#39;</span>);
2036
+ <span class="ruby-identifier">assert</span>.<span class="ruby-identifier">typeOf</span>(<span class="ruby-identifier">undefined</span>, <span class="ruby-string">&#39;undefined&#39;</span>, <span class="ruby-string">&#39;we have an undefined&#39;</span>);
2037
+
2038
+ <span class="ruby-ivar">@name</span> <span class="ruby-identifier">typeOf</span>
2039
+ <span class="ruby-ivar">@param</span> {<span class="ruby-constant">Mixed</span>} <span class="ruby-identifier">value</span>
2040
+ <span class="ruby-ivar">@param</span> {<span class="ruby-constant">String</span>} <span class="ruby-identifier">name</span>
2041
+ <span class="ruby-ivar">@param</span> {<span class="ruby-constant">String</span>} <span class="ruby-identifier">message</span>
2042
+ <span class="ruby-ivar">@api</span> <span class="ruby-identifier">public</span>
2043
+ <span class="ruby-regexp">/
2044
+
2045
+ assert.typeOf = function(val, type, msg) {
2046
+ new Assertion(val, msg).to.be.a(type);
2047
+ };
2048
+
2049
+ /</span><span class="ruby-operator">**</span>
2050
+ <span class="ruby-comment">### .notTypeOf(value, name, [message])</span>
2051
+
2052
+ <span class="ruby-constant">Asserts</span> <span class="ruby-identifier">that</span> <span class="ruby-value">%xvalue`</span><span class="ruby-string">&#39;s type is _not_ `name`, as determined by
2053
+ `Object.prototype.toString`.
2054
+
2055
+ assert.notTypeOf(&#39;</span><span class="ruby-identifier">tea</span><span class="ruby-string">&#39;, &#39;</span><span class="ruby-identifier">number</span><span class="ruby-string">&#39;, &#39;</span><span class="ruby-identifier">strings</span> <span class="ruby-identifier">are</span> <span class="ruby-keyword">not</span> <span class="ruby-identifier">numbers</span><span class="ruby-string">&#39;);
2056
+
2057
+ @name notTypeOf
2058
+ @param {Mixed} value
2059
+ @param {String} typeof name
2060
+ @param {String} message
2061
+ @api public
2062
+ /
2063
+
2064
+ assert.notTypeOf = function(val, type, msg) {
2065
+ new Assertion(val, msg).to.not.be.a(type);
2066
+ };
2067
+
2068
+ /**
2069
+ ### .instanceOf(object, constructor, [message])
2070
+
2071
+ Asserts that `value` is an instance of `constructor`.
2072
+
2073
+ var Tea = function (name) { this.name = name; }
2074
+ , chai = new Tea(&#39;</span><span class="ruby-identifier">chai</span><span class="ruby-string">&#39;);
2075
+
2076
+ assert.instanceOf(chai, Tea, &#39;</span><span class="ruby-identifier">chai</span> <span class="ruby-identifier">is</span> <span class="ruby-identifier">an</span> <span class="ruby-identifier">instance</span> <span class="ruby-identifier">of</span> <span class="ruby-identifier">tea</span><span class="ruby-string">&#39;);
2077
+
2078
+ @name instanceOf
2079
+ @param {Object} object
2080
+ @param {Constructor} constructor
2081
+ @param {String} message
2082
+ @api public
2083
+ /
2084
+
2085
+ assert.instanceOf = function(val, type, msg) {
2086
+ new Assertion(val, msg).to.be.instanceOf(type);
2087
+ };
2088
+
2089
+ /**
2090
+ ### .notInstanceOf(object, constructor, [message])
2091
+
2092
+ Asserts `value` is not an instance of `constructor`.
2093
+
2094
+ var Tea = function (name) { this.name = name; }
2095
+ , chai = new String(&#39;</span><span class="ruby-identifier">chai</span><span class="ruby-string">&#39;);
2096
+
2097
+ assert.notInstanceOf(chai, Tea, &#39;</span><span class="ruby-identifier">chai</span> <span class="ruby-identifier">is</span> <span class="ruby-keyword">not</span> <span class="ruby-identifier">an</span> <span class="ruby-identifier">instance</span> <span class="ruby-identifier">of</span> <span class="ruby-identifier">tea</span><span class="ruby-string">&#39;);
2098
+
2099
+ @name notInstanceOf
2100
+ @param {Object} object
2101
+ @param {Constructor} constructor
2102
+ @param {String} message
2103
+ @api public
2104
+ /
2105
+
2106
+ assert.notInstanceOf = function(val, type, msg) {
2107
+ new Assertion(val, msg).to.not.be.instanceOf(type);
2108
+ };
2109
+
2110
+ /**
2111
+ ### .include(haystack, needle, [message])
2112
+
2113
+ Asserts that `haystack` includes `needle`. Works
2114
+ for strings and arrays.
2115
+
2116
+ assert.include(&#39;</span><span class="ruby-identifier">foobar</span><span class="ruby-string">&#39;, &#39;</span><span class="ruby-identifier">bar</span><span class="ruby-string">&#39;, &#39;</span><span class="ruby-identifier">foobar</span> <span class="ruby-identifier">contains</span> <span class="ruby-identifier">string</span> <span class="ruby-string">&quot;bar&quot;</span><span class="ruby-string">&#39;);
2117
+ assert.include([ 1, 2, 3 ], 3, &#39;</span><span class="ruby-identifier">array</span> <span class="ruby-identifier">contains</span> <span class="ruby-identifier">value</span><span class="ruby-string">&#39;);
2118
+
2119
+ @name include
2120
+ @param {Array|String} haystack
2121
+ @param {Mixed} needle
2122
+ @param {String} message
2123
+ @api public
2124
+ /
2125
+
2126
+ assert.include = function(exp, inc, msg) {
2127
+ var obj = new Assertion(exp, msg);
2128
+
2129
+ if (Array.isArray(exp)) {
2130
+ obj.to.include(inc);
2131
+ } else if (&#39;</span><span class="ruby-identifier">string</span><span class="ruby-string">&#39; === typeof exp) {
2132
+ obj.to.contain.string(inc);
2133
+ }
2134
+ };
2135
+
2136
+ /**
2137
+ ### .match(value, regexp, [message])
2138
+
2139
+ Asserts that `value` matches the regular expression `regexp`.
2140
+
2141
+ assert.match(&#39;</span><span class="ruby-identifier">foobar</span><span class="ruby-string">&#39;, /^foo/, &#39;</span><span class="ruby-identifier">regexp</span> <span class="ruby-identifier">matches</span><span class="ruby-string">&#39;);
2142
+
2143
+ @name match
2144
+ @param {Mixed} value
2145
+ @param {RegExp} regexp
2146
+ @param {String} message
2147
+ @api public
2148
+ /
2149
+
2150
+ assert.match = function(exp, re, msg) {
2151
+ new Assertion(exp, msg).to.match(re);
2152
+ };
2153
+
2154
+ /**
2155
+ ### .notMatch(value, regexp, [message])
2156
+
2157
+ Asserts that `value` does not match the regular expression `regexp`.
2158
+
2159
+ assert.notMatch(&#39;</span><span class="ruby-identifier">foobar</span><span class="ruby-string">&#39;, /^foo/, &#39;</span><span class="ruby-identifier">regexp</span> <span class="ruby-identifier">does</span> <span class="ruby-keyword">not</span> <span class="ruby-identifier">match</span><span class="ruby-string">&#39;);
2160
+
2161
+ @name notMatch
2162
+ @param {Mixed} value
2163
+ @param {RegExp} regexp
2164
+ @param {String} message
2165
+ @api public
2166
+ /
2167
+
2168
+ assert.notMatch = function(exp, re, msg) {
2169
+ new Assertion(exp, msg).to.not.match(re);
2170
+ };
2171
+
2172
+ /**
2173
+ ### .property(object, property, [message])
2174
+
2175
+ Asserts that `object` has a property named by `property`.
2176
+
2177
+ assert.property({ tea: { green: &#39;</span><span class="ruby-identifier">matcha</span><span class="ruby-string">&#39; }}, &#39;</span><span class="ruby-identifier">tea</span><span class="ruby-string">&#39;);
2178
+
2179
+ @name property
2180
+ @param {Object} object
2181
+ @param {String} property
2182
+ @param {String} message
2183
+ @api public
2184
+ /
2185
+
2186
+ assert.property = function(obj, prop, msg) {
2187
+ new Assertion(obj, msg).to.have.property(prop);
2188
+ };
2189
+
2190
+ /**
2191
+ ### .notProperty(object, property, [message])
2192
+
2193
+ Asserts that `object` does _not_ have a property named by `property`.
2194
+
2195
+ assert.notProperty({ tea: { green: &#39;</span><span class="ruby-identifier">matcha</span><span class="ruby-string">&#39; }}, &#39;</span><span class="ruby-identifier">coffee</span><span class="ruby-string">&#39;);
2196
+
2197
+ @name notProperty
2198
+ @param {Object} object
2199
+ @param {String} property
2200
+ @param {String} message
2201
+ @api public
2202
+ /
2203
+
2204
+ assert.notProperty = function(obj, prop, msg) {
2205
+ new Assertion(obj, msg).to.not.have.property(prop);
2206
+ };
2207
+
2208
+ /**
2209
+ ### .deepProperty(object, property, [message])
2210
+
2211
+ Asserts that `object` has a property named by `property`, which can be a
2212
+ string using dot- and bracket-notation for deep reference.
2213
+
2214
+ assert.deepProperty({ tea: { green: &#39;</span><span class="ruby-identifier">matcha</span><span class="ruby-string">&#39; }}, &#39;</span><span class="ruby-identifier">tea</span>.<span class="ruby-identifier">green</span><span class="ruby-string">&#39;);
2215
+
2216
+ @name deepProperty
2217
+ @param {Object} object
2218
+ @param {String} property
2219
+ @param {String} message
2220
+ @api public
2221
+ /
2222
+
2223
+ assert.deepProperty = function(obj, prop, msg) {
2224
+ new Assertion(obj, msg).to.have.deep.property(prop);
2225
+ };
2226
+
2227
+ /**
2228
+ ### .notDeepProperty(object, property, [message])
2229
+
2230
+ Asserts that `object` does _not_ have a property named by `property`, which
2231
+ can be a string using dot- and bracket-notation for deep reference.
2232
+
2233
+ assert.notDeepProperty({ tea: { green: &#39;</span><span class="ruby-identifier">matcha</span><span class="ruby-string">&#39; }}, &#39;</span><span class="ruby-identifier">tea</span>.<span class="ruby-identifier">oolong</span><span class="ruby-string">&#39;);
2234
+
2235
+ @name notDeepProperty
2236
+ @param {Object} object
2237
+ @param {String} property
2238
+ @param {String} message
2239
+ @api public
2240
+ /
2241
+
2242
+ assert.notDeepProperty = function(obj, prop, msg) {
2243
+ new Assertion(obj, msg).to.not.have.deep.property(prop);
2244
+ };
2245
+
2246
+ /**
2247
+ ### .propertyVal(object, property, value, [message])
2248
+
2249
+ Asserts that `object` has a property named by `property` with value given
2250
+ by `value`.
2251
+
2252
+ assert.propertyVal({ tea: &#39;</span><span class="ruby-identifier">is</span> <span class="ruby-identifier">good</span><span class="ruby-string">&#39; }, &#39;</span><span class="ruby-identifier">tea</span><span class="ruby-string">&#39;, &#39;</span><span class="ruby-identifier">is</span> <span class="ruby-identifier">good</span><span class="ruby-string">&#39;);
2253
+
2254
+ @name propertyVal
2255
+ @param {Object} object
2256
+ @param {String} property
2257
+ @param {Mixed} value
2258
+ @param {String} message
2259
+ @api public
2260
+ /
2261
+
2262
+ assert.propertyVal = function(obj, prop, val, msg) {
2263
+ new Assertion(obj, msg).to.have.property(prop, val);
2264
+ };
2265
+
2266
+ /**
2267
+ ### .propertyNotVal(object, property, value, [message])
2268
+
2269
+ Asserts that `object` has a property named by `property`, but with a value
2270
+ different from that given by `value`.
2271
+
2272
+ assert.propertyNotVal({ tea: &#39;</span><span class="ruby-identifier">is</span> <span class="ruby-identifier">good</span><span class="ruby-string">&#39; }, &#39;</span><span class="ruby-identifier">tea</span><span class="ruby-string">&#39;, &#39;</span><span class="ruby-identifier">is</span> <span class="ruby-identifier">bad</span><span class="ruby-string">&#39;);
2273
+
2274
+ @name propertyNotVal
2275
+ @param {Object} object
2276
+ @param {String} property
2277
+ @param {Mixed} value
2278
+ @param {String} message
2279
+ @api public
2280
+ /
2281
+
2282
+ assert.propertyNotVal = function(obj, prop, val, msg) {
2283
+ new Assertion(obj, msg).to.not.have.property(prop, val);
2284
+ };
2285
+
2286
+ /**
2287
+ ### .deepPropertyVal(object, property, value, [message])
2288
+
2289
+ Asserts that `object` has a property named by `property` with value given
2290
+ by `value`. `property` can use dot- and bracket-notation for deep
2291
+ reference.
2292
+
2293
+ assert.deepPropertyVal({ tea: { green: &#39;</span><span class="ruby-identifier">matcha</span><span class="ruby-string">&#39; }}, &#39;</span><span class="ruby-identifier">tea</span>.<span class="ruby-identifier">green</span><span class="ruby-string">&#39;, &#39;</span><span class="ruby-identifier">matcha</span><span class="ruby-string">&#39;);
2294
+
2295
+ @name deepPropertyVal
2296
+ @param {Object} object
2297
+ @param {String} property
2298
+ @param {Mixed} value
2299
+ @param {String} message
2300
+ @api public
2301
+ /
2302
+
2303
+ assert.deepPropertyVal = function(obj, prop, val, msg) {
2304
+ new Assertion(obj, msg).to.have.deep.property(prop, val);
2305
+ };
2306
+
2307
+ /**
2308
+ ### .deepPropertyNotVal(object, property, value, [message])
2309
+
2310
+ Asserts that `object` has a property named by `property`, but with a value
2311
+ different from that given by `value`. `property` can use dot- and
2312
+ bracket-notation for deep reference.
2313
+
2314
+ assert.deepPropertyNotVal({ tea: { green: &#39;</span><span class="ruby-identifier">matcha</span><span class="ruby-string">&#39; }}, &#39;</span><span class="ruby-identifier">tea</span>.<span class="ruby-identifier">green</span><span class="ruby-string">&#39;, &#39;</span><span class="ruby-identifier">konacha</span><span class="ruby-string">&#39;);
2315
+
2316
+ @name deepPropertyNotVal
2317
+ @param {Object} object
2318
+ @param {String} property
2319
+ @param {Mixed} value
2320
+ @param {String} message
2321
+ @api public
2322
+ /
2323
+
2324
+ assert.deepPropertyNotVal = function(obj, prop, val, msg) {
2325
+ new Assertion(obj, msg).to.not.have.deep.property(prop, val);
2326
+ };
2327
+
2328
+ /**
2329
+ ### .lengthOf(object, length, [message])
2330
+
2331
+ Asserts that `object` has a `length` property with the expected value.
2332
+
2333
+ assert.lengthOf([1,2,3], 3, &#39;</span><span class="ruby-identifier">array</span> <span class="ruby-identifier">has</span> <span class="ruby-identifier">length</span> <span class="ruby-identifier">of</span> <span class="ruby-value">3</span><span class="ruby-string">&#39;);
2334
+ assert.lengthOf(&#39;</span><span class="ruby-identifier">foobar</span><span class="ruby-string">&#39;, 5, &#39;</span><span class="ruby-identifier">string</span> <span class="ruby-identifier">has</span> <span class="ruby-identifier">length</span> <span class="ruby-identifier">of</span> <span class="ruby-value">6</span><span class="ruby-string">&#39;);
2335
+
2336
+ @name lengthOf
2337
+ @param {Mixed} object
2338
+ @param {Number} length
2339
+ @param {String} message
2340
+ @api public
2341
+ /
2342
+
2343
+ assert.lengthOf = function(exp, len, msg) {
2344
+ new Assertion(exp, msg).to.have.length(len);
2345
+ };
2346
+
2347
+ /**
2348
+ ### .throws(function, [constructor/string/regexp], [string/regexp], [message])
2349
+
2350
+ Asserts that `function` will throw an error that is an instance of
2351
+ `constructor`, or alternately that it will throw an error with message
2352
+ matching `regexp`.
2353
+
2354
+ assert.throw(fn, &#39;</span><span class="ruby-identifier">function</span> <span class="ruby-identifier">throws</span> <span class="ruby-identifier">a</span> <span class="ruby-identifier">reference</span> <span class="ruby-identifier">error</span><span class="ruby-string">&#39;);
2355
+ assert.throw(fn, /function throws a reference error/);
2356
+ assert.throw(fn, ReferenceError);
2357
+ assert.throw(fn, ReferenceError, &#39;</span><span class="ruby-identifier">function</span> <span class="ruby-identifier">throws</span> <span class="ruby-identifier">a</span> <span class="ruby-identifier">reference</span> <span class="ruby-identifier">error</span><span class="ruby-string">&#39;);
2358
+ assert.throw(fn, ReferenceError, /function throws a reference error/);
2359
+
2360
+ @name throws
2361
+ @alias throw
2362
+ @alias Throw
2363
+ @param {Function} function
2364
+ @param {ErrorConstructor} constructor
2365
+ @param {RegExp} regexp
2366
+ @param {String} message
2367
+ @see https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Error#Error_types
2368
+ @api public
2369
+ /
2370
+
2371
+ assert.Throw = function(fn, errt, errs, msg) {
2372
+ if (&#39;</span><span class="ruby-identifier">string</span><span class="ruby-string">&#39; === typeof errt || errt instanceof RegExp) {
2373
+ errs = errt;
2374
+ errt = null;
2375
+ }
2376
+
2377
+ new Assertion(fn, msg).to.Throw(errt, errs);
2378
+ };
2379
+
2380
+ /**
2381
+ ### .doesNotThrow(function, [constructor/regexp], [message])
2382
+
2383
+ Asserts that `function` will _not_ throw an error that is an instance of
2384
+ `constructor`, or alternately that it will not throw an error with message
2385
+ matching `regexp`.
2386
+
2387
+ assert.doesNotThrow(fn, Error, &#39;</span><span class="ruby-identifier">function</span> <span class="ruby-identifier">does</span> <span class="ruby-keyword">not</span> <span class="ruby-identifier">throw</span><span class="ruby-string">&#39;);
2388
+
2389
+ @name doesNotThrow
2390
+ @param {Function} function
2391
+ @param {ErrorConstructor} constructor
2392
+ @param {RegExp} regexp
2393
+ @param {String} message
2394
+ @see https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Error#Error_types
2395
+ @api public
2396
+ /
2397
+
2398
+ assert.doesNotThrow = function(fn, type, msg) {
2399
+ if (&#39;</span><span class="ruby-identifier">string</span><span class="ruby-string">&#39; === typeof type) {
2400
+ msg = type;
2401
+ type = null;
2402
+ }
2403
+
2404
+ new Assertion(fn, msg).to.not.Throw(type);
2405
+ };
2406
+
2407
+ /**
2408
+ ### .operator(val1, operator, val2, [message])
2409
+
2410
+ Compares two values using `operator`.
2411
+
2412
+ assert.operator(1, &#39;</span><span class="ruby-operator">&lt;</span><span class="ruby-string">&#39;, 2, &#39;</span><span class="ruby-identifier">everything</span> <span class="ruby-identifier">is</span> <span class="ruby-identifier">ok</span><span class="ruby-string">&#39;);
2413
+ assert.operator(1, &#39;</span><span class="ruby-operator">&gt;</span><span class="ruby-string">&#39;, 2, &#39;</span><span class="ruby-identifier">this</span> <span class="ruby-identifier">will</span> <span class="ruby-identifier">fail</span><span class="ruby-string">&#39;);
2414
+
2415
+ @name operator
2416
+ @param {Mixed} val1
2417
+ @param {String} operator
2418
+ @param {Mixed} val2
2419
+ @param {String} message
2420
+ @api public
2421
+ /
2422
+
2423
+ assert.operator = function(val, operator, val2, msg) {
2424
+ if (!~ [&#39;</span><span class="ruby-operator">==</span><span class="ruby-string">&#39;, &#39;</span><span class="ruby-operator">===</span><span class="ruby-string">&#39;, &#39;</span><span class="ruby-operator">&gt;</span><span class="ruby-string">&#39;, &#39;</span><span class="ruby-operator">&gt;=</span><span class="ruby-string">&#39;, &#39;</span><span class="ruby-operator">&lt;</span><span class="ruby-string">&#39;, &#39;</span><span class="ruby-operator">&lt;=</span><span class="ruby-string">&#39;, &#39;</span><span class="ruby-operator">!=</span><span class="ruby-string">&#39;, &#39;</span><span class="ruby-operator">!=</span>=<span class="ruby-string">&#39;].indexOf(operator)) {
2425
+ throw new Error(&#39;</span><span class="ruby-constant">Invalid</span> <span class="ruby-identifier">operator</span> <span class="ruby-string">&quot;&#39; + operator + &#39;&quot;</span><span class="ruby-string">&#39;);
2426
+ }
2427
+ var test = new Assertion(eval(val + operator + val2), msg);
2428
+ test.assert(
2429
+ true === flag(test, &#39;</span><span class="ruby-identifier">object</span><span class="ruby-string">&#39;), &#39;</span><span class="ruby-identifier">expected</span> <span class="ruby-string">&#39; + util.inspect(val) + &#39;</span> <span class="ruby-identifier">to</span> <span class="ruby-identifier">be</span> <span class="ruby-string">&#39; + operator + &#39;</span> <span class="ruby-string">&#39; + util.inspect(val2), &#39;</span><span class="ruby-identifier">expected</span> <span class="ruby-string">&#39; + util.inspect(val) + &#39;</span> <span class="ruby-identifier">to</span> <span class="ruby-keyword">not</span> <span class="ruby-identifier">be</span> <span class="ruby-string">&#39; + operator + &#39;</span> <span class="ruby-string">&#39; + util.inspect(val2));
2430
+ };
2431
+
2432
+ /**
2433
+ ### .closeTo(actual, expected, delta, [message])
2434
+
2435
+ Asserts that the target is equal `expected`, to within a +/- `delta` range.
2436
+
2437
+ assert.closeTo(1.5, 1, 0.5, &#39;</span><span class="ruby-identifier">numbers</span> <span class="ruby-identifier">are</span> <span class="ruby-identifier">close</span><span class="ruby-string">&#39;);
2438
+
2439
+ @name closeTo
2440
+ @param {Number} actual
2441
+ @param {Number} expected
2442
+ @param {Number} delta
2443
+ @param {String} message
2444
+ @api public
2445
+ /
2446
+
2447
+ assert.closeTo = function(act, exp, delta, msg) {
2448
+ new Assertion(act, msg).to.be.closeTo(exp, delta);
2449
+ };
2450
+
2451
+ /*!
2452
+ Undocumented / untested
2453
+ /
2454
+
2455
+ assert.ifError = function(val, msg) {
2456
+ new Assertion(val, msg).to.not.be.ok;
2457
+ };
2458
+
2459
+ /*!
2460
+ Aliases.
2461
+ /
2462
+
2463
+ (function alias(name, as) {
2464
+ assert[as] = assert[name];
2465
+ return alias;
2466
+ })
2467
+ (&#39;</span><span class="ruby-constant">Throw</span><span class="ruby-string">&#39;, &#39;</span><span class="ruby-identifier">throw</span><span class="ruby-string">&#39;)
2468
+ (&#39;</span><span class="ruby-constant">Throw</span><span class="ruby-string">&#39;, &#39;</span><span class="ruby-identifier">throws</span><span class="ruby-string">&#39;);
2469
+ };
2470
+
2471
+ }); // module: chai/interface/assert.js
2472
+ require.register(&quot;chai/interface/expect.js&quot;, function(module, exports, require) {
2473
+ /*!
2474
+ chai
2475
+ Copyright(c) 2011-2013 Jake Luer &lt;jake@alogicalparadox.com&gt;
2476
+ MIT Licensed
2477
+ /
2478
+
2479
+ module.exports = function(chai, util) {
2480
+ chai.expect = function(val, message) {
2481
+ return new chai.Assertion(val, message);
2482
+ };
2483
+ };
2484
+
2485
+ }); // module: chai/interface/expect.js
2486
+ require.register(&quot;chai/interface/should.js&quot;, function(module, exports, require) {
2487
+ /*!
2488
+ chai
2489
+ Copyright(c) 2011-2013 Jake Luer &lt;jake@alogicalparadox.com&gt;
2490
+ MIT Licensed
2491
+ /
2492
+
2493
+ module.exports = function(chai, util) {
2494
+ var Assertion = chai.Assertion;
2495
+
2496
+ function loadShould() {
2497
+ // modify Object.prototype to have `should`
2498
+ Object.defineProperty(Object.prototype, &#39;</span><span class="ruby-identifier">should</span><span class="ruby-string">&#39;, {
2499
+ set: function(value) {
2500
+ // See https://github.com/chaijs/chai/issues/86: this makes
2501
+ // `whatever.should = someValue` actually set `someValue`, which is
2502
+ // especially useful for `global.should = require(&#39;</span><span class="ruby-identifier">chai</span><span class="ruby-string">&#39;).should()`.
2503
+ //
2504
+ // Note that we have to use [[DefineProperty]] instead of [[Put]]
2505
+ // since otherwise we would trigger this very setter!
2506
+ Object.defineProperty(this, &#39;</span><span class="ruby-identifier">should</span><span class="ruby-string">&#39;, {
2507
+ value: value,
2508
+ enumerable: true,
2509
+ configurable: true,
2510
+ writable: true
2511
+ });
2512
+ },
2513
+ get: function() {
2514
+ if (this instanceof String || this instanceof Number) {
2515
+ return new Assertion(this.constructor(this));
2516
+ } else if (this instanceof Boolean) {
2517
+ return new Assertion(this == true);
2518
+ }
2519
+ return new Assertion(this);
2520
+ },
2521
+ configurable: true
2522
+ });
2523
+
2524
+ var should = {};
2525
+
2526
+ should.equal = function(val1, val2, msg) {
2527
+ new Assertion(val1, msg).to.equal(val2);
2528
+ };
2529
+
2530
+ should.Throw = function(fn, errt, errs, msg) {
2531
+ new Assertion(fn, msg).to.Throw(errt, errs);
2532
+ };
2533
+
2534
+ should.exist = function(val, msg) {
2535
+ new Assertion(val, msg).to.exist;
2536
+ }
2537
+
2538
+ // negation
2539
+ should.not = {}
2540
+
2541
+ should.not.equal = function(val1, val2, msg) {
2542
+ new Assertion(val1, msg).to.not.equal(val2);
2543
+ };
2544
+
2545
+ should.not.Throw = function(fn, errt, errs, msg) {
2546
+ new Assertion(fn, msg).to.not.Throw(errt, errs);
2547
+ };
2548
+
2549
+ should.not.exist = function(val, msg) {
2550
+ new Assertion(val, msg).to.not.exist;
2551
+ }
2552
+
2553
+ should[&#39;</span><span class="ruby-identifier">throw</span><span class="ruby-string">&#39;] = should[&#39;</span><span class="ruby-constant">Throw</span><span class="ruby-string">&#39;];
2554
+ should.not[&#39;</span><span class="ruby-identifier">throw</span><span class="ruby-string">&#39;] = should.not[&#39;</span><span class="ruby-constant">Throw</span><span class="ruby-string">&#39;];
2555
+
2556
+ return should;
2557
+ };
2558
+
2559
+ chai.should = loadShould;
2560
+ chai.Should = loadShould;
2561
+ };
2562
+
2563
+ }); // module: chai/interface/should.js
2564
+ require.register(&quot;chai/utils/addChainableMethod.js&quot;, function(module, exports, require) {
2565
+ /*!
2566
+ Chai - addChainingMethod utility
2567
+ Copyright(c) 2012-2013 Jake Luer &lt;jake@alogicalparadox.com&gt;
2568
+ MIT Licensed
2569
+ /
2570
+
2571
+ /*!
2572
+ Module dependencies
2573
+ /
2574
+
2575
+ var transferFlags = require(&#39;</span>.<span class="ruby-operator">/</span><span class="ruby-identifier">transferFlags</span><span class="ruby-string">&#39;);
2576
+
2577
+ /*!
2578
+ Module variables
2579
+ /
2580
+
2581
+ // Check whether `__proto__` is supported
2582
+ var hasProtoSupport = &#39;</span><span class="ruby-identifier">__proto__</span><span class="ruby-string">&#39; in Object;
2583
+
2584
+ // Without `__proto__` support, this module will need to add properties to a function.
2585
+ // However, some Function.prototype methods cannot be overwritten,
2586
+ // and there seems no easy cross-platform way to detect them (@see chaijs/chai/issues/69).
2587
+ var excludeNames = /^(?:length|name|arguments|caller)$/;
2588
+
2589
+ /**
2590
+ ### addChainableMethod (ctx, name, method, chainingBehavior)
2591
+
2592
+ Adds a method to an object, such that the method can also be chained.
2593
+
2594
+ utils.addChainableMethod(chai.Assertion.prototype, &#39;</span><span class="ruby-identifier">foo</span><span class="ruby-string">&#39;, function (str) {
2595
+ var obj = utils.flag(this, &#39;</span><span class="ruby-identifier">object</span><span class="ruby-string">&#39;);
2596
+ new chai.Assertion(obj).to.be.equal(str);
2597
+ });
2598
+
2599
+ Can also be accessed directly from `chai.Assertion`.
2600
+
2601
+ chai.Assertion.addChainableMethod(&#39;</span><span class="ruby-identifier">foo</span><span class="ruby-string">&#39;, fn, chainingBehavior);
2602
+
2603
+ The result can then be used as both a method assertion, executing both `method` and
2604
+ `chainingBehavior`, or as a language chain, which only executes `chainingBehavior`.
2605
+
2606
+ expect(fooStr).to.be.foo(&#39;</span><span class="ruby-identifier">bar</span><span class="ruby-string">&#39;);
2607
+ expect(fooStr).to.be.foo.equal(&#39;</span><span class="ruby-identifier">foo</span><span class="ruby-string">&#39;);
2608
+
2609
+ @param {Object} ctx object to which the method is added
2610
+ @param {String} name of method to add
2611
+ @param {Function} method function to be used for `name`, when called
2612
+ @param {Function} chainingBehavior function to be called every time the property is accessed
2613
+ @name addChainableMethod
2614
+ @api public
2615
+ /
2616
+
2617
+ module.exports = function(ctx, name, method, chainingBehavior) {
2618
+ if (typeof chainingBehavior !== &#39;</span><span class="ruby-identifier">function</span><span class="ruby-string">&#39;) chainingBehavior = function() {};
2619
+
2620
+ Object.defineProperty(ctx, name, {
2621
+ get: function() {
2622
+ chainingBehavior.call(this);
2623
+
2624
+ var assert = function() {
2625
+ var result = method.apply(this, arguments);
2626
+ return result === undefined ? this : result;
2627
+ };
2628
+
2629
+ // Use `__proto__` if available
2630
+ if (hasProtoSupport) {
2631
+ assert.__proto__ = this;
2632
+ }
2633
+ // Otherwise, redefine all properties (slow!)
2634
+ else {
2635
+ var asserterNames = Object.getOwnPropertyNames(ctx);
2636
+ asserterNames.forEach(function(asserterName) {
2637
+ if (!excludeNames.test(asserterName)) {
2638
+ var pd = Object.getOwnPropertyDescriptor(ctx, asserterName);
2639
+ Object.defineProperty(assert, asserterName, pd);
2640
+ }
2641
+ });
2642
+ }
2643
+
2644
+ transferFlags(this, assert);
2645
+ return assert;
2646
+ },
2647
+ configurable: true
2648
+ });
2649
+ };
2650
+
2651
+ }); // module: chai/utils/addChainableMethod.js
2652
+ require.register(&quot;chai/utils/addMethod.js&quot;, function(module, exports, require) {
2653
+ /*!
2654
+ Chai - addMethod utility
2655
+ Copyright(c) 2012-2013 Jake Luer &lt;jake@alogicalparadox.com&gt;
2656
+ MIT Licensed
2657
+ /
2658
+
2659
+ /**
2660
+ ### .addMethod (ctx, name, method)
2661
+
2662
+ Adds a method to the prototype of an object.
2663
+
2664
+ utils.addMethod(chai.Assertion.prototype, &#39;</span><span class="ruby-identifier">foo</span><span class="ruby-string">&#39;, function (str) {
2665
+ var obj = utils.flag(this, &#39;</span><span class="ruby-identifier">object</span><span class="ruby-string">&#39;);
2666
+ new chai.Assertion(obj).to.be.equal(str);
2667
+ });
2668
+
2669
+ Can also be accessed directly from `chai.Assertion`.
2670
+
2671
+ chai.Assertion.addMethod(&#39;</span><span class="ruby-identifier">foo</span><span class="ruby-string">&#39;, fn);
2672
+
2673
+ Then can be used as any other assertion.
2674
+
2675
+ expect(fooStr).to.be.foo(&#39;</span><span class="ruby-identifier">bar</span><span class="ruby-string">&#39;);
2676
+
2677
+ @param {Object} ctx object to which the method is added
2678
+ @param {String} name of method to add
2679
+ @param {Function} method function to be used for name
2680
+ @name addMethod
2681
+ @api public
2682
+ /
2683
+
2684
+ module.exports = function(ctx, name, method) {
2685
+ ctx[name] = function() {
2686
+ var result = method.apply(this, arguments);
2687
+ return result === undefined ? this : result;
2688
+ };
2689
+ };
2690
+
2691
+ }); // module: chai/utils/addMethod.js
2692
+ require.register(&quot;chai/utils/addProperty.js&quot;, function(module, exports, require) {
2693
+ /*!
2694
+ Chai - addProperty utility
2695
+ Copyright(c) 2012-2013 Jake Luer &lt;jake@alogicalparadox.com&gt;
2696
+ MIT Licensed
2697
+ /
2698
+
2699
+ /**
2700
+ ### addProperty (ctx, name, getter)
2701
+
2702
+ Adds a property to the prototype of an object.
2703
+
2704
+ utils.addProperty(chai.Assertion.prototype, &#39;</span><span class="ruby-identifier">foo</span><span class="ruby-string">&#39;, function () {
2705
+ var obj = utils.flag(this, &#39;</span><span class="ruby-identifier">object</span><span class="ruby-string">&#39;);
2706
+ new chai.Assertion(obj).to.be.instanceof(Foo);
2707
+ });
2708
+
2709
+ Can also be accessed directly from `chai.Assertion`.
2710
+
2711
+ chai.Assertion.addProperty(&#39;</span><span class="ruby-identifier">foo</span><span class="ruby-string">&#39;, fn);
2712
+
2713
+ Then can be used as any other assertion.
2714
+
2715
+ expect(myFoo).to.be.foo;
2716
+
2717
+ @param {Object} ctx object to which the property is added
2718
+ @param {String} name of property to add
2719
+ @param {Function} getter function to be used for name
2720
+ @name addProperty
2721
+ @api public
2722
+ /
2723
+
2724
+ module.exports = function(ctx, name, getter) {
2725
+ Object.defineProperty(ctx, name, {
2726
+ get: function() {
2727
+ var result = getter.call(this);
2728
+ return result === undefined ? this : result;
2729
+ },
2730
+ configurable: true
2731
+ });
2732
+ };
2733
+
2734
+ }); // module: chai/utils/addProperty.js
2735
+ require.register(&quot;chai/utils/eql.js&quot;, function(module, exports, require) {
2736
+ // This is (almost) directly from Node.js assert
2737
+ // https://github.com/joyent/node/blob/f8c335d0caf47f16d31413f89aa28eda3878e3aa/lib/assert.js
2738
+ module.exports = _deepEqual;
2739
+
2740
+ var getEnumerableProperties = require(&#39;</span>.<span class="ruby-operator">/</span><span class="ruby-identifier">getEnumerableProperties</span><span class="ruby-string">&#39;);
2741
+
2742
+ // for the browser
2743
+ var Buffer;
2744
+ try {
2745
+ Buffer = require(&#39;</span><span class="ruby-identifier">buffer</span><span class="ruby-string">&#39;).Buffer;
2746
+ } catch (ex) {
2747
+ Buffer = {
2748
+ isBuffer: function() {
2749
+ return false;
2750
+ }
2751
+ };
2752
+ }
2753
+
2754
+ function _deepEqual(actual, expected, memos) {
2755
+
2756
+ // 7.1. All identical values are equivalent, as determined by ===.
2757
+ if (actual === expected) {
2758
+ return true;
2759
+
2760
+ } else if (Buffer.isBuffer(actual) &amp;&amp; Buffer.isBuffer(expected)) {
2761
+ if (actual.length != expected.length) return false;
2762
+
2763
+ for (var i = 0; i &lt; actual.length; i++) {
2764
+ if (actual[i] !== expected[i]) return false;
2765
+ }
2766
+
2767
+ return true;
2768
+
2769
+ // 7.2. If the expected value is a Date object, the actual value is
2770
+ // equivalent if it is also a Date object that refers to the same time.
2771
+ } else if (actual instanceof Date &amp;&amp; expected instanceof Date) {
2772
+ return actual.getTime() === expected.getTime();
2773
+
2774
+ // 7.3. Other pairs that do not both pass typeof value == &#39;</span><span class="ruby-identifier">object</span><span class="ruby-string">&#39;,
2775
+ // equivalence is determined by ==.
2776
+ } else if (typeof actual != &#39;</span><span class="ruby-identifier">object</span><span class="ruby-string">&#39; &amp;&amp; typeof expected != &#39;</span><span class="ruby-identifier">object</span><span class="ruby-string">&#39;) {
2777
+ return actual === expected;
2778
+
2779
+ // 7.4. For all other Object pairs, including Array objects, equivalence is
2780
+ // determined by having the same number of owned properties (as verified
2781
+ // with Object.prototype.hasOwnProperty.call), the same set of keys
2782
+ // (although not necessarily the same order), equivalent values for every
2783
+ // corresponding key, and an identical &#39;</span><span class="ruby-identifier">prototype</span><span class="ruby-string">&#39; property. Note: this
2784
+ // accounts for both named and indexed properties on Arrays.
2785
+ } else {
2786
+ return objEquiv(actual, expected, memos);
2787
+ }
2788
+ }
2789
+
2790
+ function isUndefinedOrNull(value) {
2791
+ return value === null || value === undefined;
2792
+ }
2793
+
2794
+ function isArguments(object) {
2795
+ return Object.prototype.toString.call(object) == &#39;</span>[<span class="ruby-identifier">object</span> <span class="ruby-constant">Arguments</span>]<span class="ruby-string">&#39;;
2796
+ }
2797
+
2798
+ function objEquiv(a, b, memos) {
2799
+ if (isUndefinedOrNull(a) || isUndefinedOrNull(b)) return false;
2800
+
2801
+ // an identical &#39;</span><span class="ruby-identifier">prototype</span><span class="ruby-string">&#39; property.
2802
+ if (a.prototype !== b.prototype) return false;
2803
+
2804
+ // check if we have already compared a and b
2805
+ var i;
2806
+ if (memos) {
2807
+ for (i = 0; i &lt; memos.length; i++) {
2808
+ if ((memos[i][0] === a &amp;&amp; memos[i][1] === b) || (memos[i][0] === b &amp;&amp; memos[i][1] === a)) return true;
2809
+ }
2810
+ } else {
2811
+ memos = [];
2812
+ }
2813
+
2814
+ //~~~I&#39;</span><span class="ruby-identifier">ve</span> <span class="ruby-identifier">managed</span> <span class="ruby-identifier">to</span> <span class="ruby-keyword">break</span> <span class="ruby-constant">Object</span>.<span class="ruby-identifier">keys</span> <span class="ruby-identifier">through</span> <span class="ruby-identifier">screwy</span> <span class="ruby-identifier">arguments</span> <span class="ruby-identifier">passing</span>.
2815
+ <span class="ruby-operator">/</span><span class="ruby-regexp">/ Converting to array solves the problem.
2816
+ if (isArguments(a)) {
2817
+ if (!isArguments(b)) {
2818
+ return false;
2819
+ }
2820
+ a = pSlice.call(a);
2821
+ b = pSlice.call(b);
2822
+ return _deepEqual(a, b, memos);
2823
+ }
2824
+ try {
2825
+ var ka = getEnumerableProperties(a),
2826
+ kb = getEnumerableProperties(b),
2827
+ key;
2828
+ } catch (e) { /</span><span class="ruby-operator">/</span><span class="ruby-identifier">happens</span> <span class="ruby-keyword">when</span> <span class="ruby-identifier">one</span> <span class="ruby-identifier">is</span> <span class="ruby-identifier">a</span> <span class="ruby-identifier">string</span> <span class="ruby-identifier">literal</span> <span class="ruby-keyword">and</span> <span class="ruby-identifier">the</span> <span class="ruby-identifier">other</span> <span class="ruby-identifier">isn</span><span class="ruby-string">&#39;t
2829
+ return false;
2830
+ }
2831
+
2832
+ // having the same number of owned properties (keys incorporates
2833
+ // hasOwnProperty)
2834
+ if (ka.length != kb.length) return false;
2835
+
2836
+ //the same set of keys (although not necessarily the same order),
2837
+ ka.sort();
2838
+ kb.sort();
2839
+ //~~~cheap key test
2840
+ for (i = ka.length - 1; i &gt;= 0; i--) {
2841
+ if (ka[i] != kb[i]) return false;
2842
+ }
2843
+
2844
+ // remember objects we have compared to guard against circular references
2845
+ memos.push([a, b]);
2846
+
2847
+ //equivalent values for every corresponding key, and
2848
+ //~~~possibly expensive deep test
2849
+ for (i = ka.length - 1; i &gt;= 0; i--) {
2850
+ key = ka[i];
2851
+ if (!_deepEqual(a[key], b[key], memos)) return false;
2852
+ }
2853
+
2854
+ return true;
2855
+ }
2856
+
2857
+ }); // module: chai/utils/eql.js
2858
+ require.register(&quot;chai/utils/flag.js&quot;, function(module, exports, require) {
2859
+ /*!
2860
+ Chai - flag utility
2861
+ Copyright(c) 2012-2013 Jake Luer &lt;jake@alogicalparadox.com&gt;
2862
+ MIT Licensed
2863
+ /
2864
+
2865
+ /**
2866
+ ### flag(object ,key, [value])
2867
+
2868
+ Get or set a flag value on an object. If a
2869
+ value is provided it will be set, else it will
2870
+ return the currently set value or `undefined` if
2871
+ the value is not set.
2872
+
2873
+ utils.flag(this, &#39;</span><span class="ruby-identifier">foo</span><span class="ruby-string">&#39;, &#39;</span><span class="ruby-identifier">bar</span><span class="ruby-string">&#39;); // setter
2874
+ utils.flag(this, &#39;</span><span class="ruby-identifier">foo</span><span class="ruby-string">&#39;); // getter, returns `bar`
2875
+
2876
+ @param {Object} object (constructed Assertion
2877
+ @param {String} key
2878
+ @param {Mixed} value (optional)
2879
+ @name flag
2880
+ @api private
2881
+ /
2882
+
2883
+ module.exports = function(obj, key, value) {
2884
+ var flags = obj.__flags || (obj.__flags = Object.create(null));
2885
+ if (arguments.length === 3) {
2886
+ flags[key] = value;
2887
+ } else {
2888
+ return flags[key];
2889
+ }
2890
+ };
2891
+
2892
+ }); // module: chai/utils/flag.js
2893
+ require.register(&quot;chai/utils/getActual.js&quot;, function(module, exports, require) {
2894
+ /*!
2895
+ Chai - getActual utility
2896
+ Copyright(c) 2012-2013 Jake Luer &lt;jake@alogicalparadox.com&gt;
2897
+ MIT Licensed
2898
+ /
2899
+
2900
+ /**
2901
+ # getActual(object, [actual])
2902
+
2903
+ Returns the `actual` value for an Assertion
2904
+
2905
+ @param {Object} object (constructed Assertion)
2906
+ @param {Arguments} chai.Assertion.prototype.assert arguments
2907
+ /
2908
+
2909
+ module.exports = function(obj, args) {
2910
+ var actual = args[4];
2911
+ return &#39;</span><span class="ruby-identifier">undefined</span><span class="ruby-string">&#39; !== typeof actual ? actual : obj._obj;
2912
+ };
2913
+
2914
+ }); // module: chai/utils/getActual.js
2915
+ require.register(&quot;chai/utils/getEnumerableProperties.js&quot;, function(module, exports, require) {
2916
+ /*!
2917
+ Chai - getEnumerableProperties utility
2918
+ Copyright(c) 2012-2013 Jake Luer &lt;jake@alogicalparadox.com&gt;
2919
+ MIT Licensed
2920
+ /
2921
+
2922
+ /**
2923
+ ### .getEnumerableProperties(object)
2924
+
2925
+ This allows the retrieval of enumerable property names of an object,
2926
+ inherited or not.
2927
+
2928
+ @param {Object} object
2929
+ @returns {Array}
2930
+ @name getEnumerableProperties
2931
+ @api public
2932
+ /
2933
+
2934
+ module.exports = function getEnumerableProperties(object) {
2935
+ var result = [];
2936
+ for (var name in object) {
2937
+ result.push(name);
2938
+ }
2939
+ return result;
2940
+ };
2941
+
2942
+ }); // module: chai/utils/getEnumerableProperties.js
2943
+ require.register(&quot;chai/utils/getMessage.js&quot;, function(module, exports, require) {
2944
+ /*!
2945
+ Chai - message composition utility
2946
+ Copyright(c) 2012-2013 Jake Luer &lt;jake@alogicalparadox.com&gt;
2947
+ MIT Licensed
2948
+ /
2949
+
2950
+ /*!
2951
+ Module dependancies
2952
+ /
2953
+
2954
+ var flag = require(&#39;</span>.<span class="ruby-operator">/</span><span class="ruby-identifier">flag</span><span class="ruby-string">&#39;),
2955
+ getActual = require(&#39;</span>.<span class="ruby-operator">/</span><span class="ruby-identifier">getActual</span><span class="ruby-string">&#39;),
2956
+ inspect = require(&#39;</span>.<span class="ruby-operator">/</span><span class="ruby-identifier">inspect</span><span class="ruby-string">&#39;),
2957
+ objDisplay = require(&#39;</span>.<span class="ruby-operator">/</span><span class="ruby-identifier">objDisplay</span><span class="ruby-string">&#39;);
2958
+
2959
+ /**
2960
+ ### .getMessage(object, message, negateMessage)
2961
+
2962
+ Construct the error message based on flags
2963
+ and template tags. Template tags will return
2964
+ a stringified inspection of the object referenced.
2965
+
2966
+ Messsage template tags:
2967
+ - `#{this}` current asserted object
2968
+ - `#{act}` actual value
2969
+ - `#{exp}` expected value
2970
+
2971
+ @param {Object} object (constructed Assertion)
2972
+ @param {Arguments} chai.Assertion.prototype.assert arguments
2973
+ @name getMessage
2974
+ @api public
2975
+ /
2976
+
2977
+ module.exports = function(obj, args) {
2978
+ var negate = flag(obj, &#39;</span><span class="ruby-identifier">negate</span><span class="ruby-string">&#39;),
2979
+ val = flag(obj, &#39;</span><span class="ruby-identifier">object</span><span class="ruby-string">&#39;),
2980
+ expected = args[3],
2981
+ actual = getActual(obj, args),
2982
+ msg = negate ? args[2] : args[1],
2983
+ flagMsg = flag(obj, &#39;</span><span class="ruby-identifier">message</span><span class="ruby-string">&#39;);
2984
+
2985
+ msg = msg || &#39;</span><span class="ruby-string">&#39;;
2986
+ msg = msg.replace(/#{this}/g, objDisplay(val)).replace(/#{act}/g, objDisplay(actual)).replace(/#{exp}/g, objDisplay(expected));
2987
+
2988
+ return flagMsg ? flagMsg + &#39;</span><span class="ruby-operator">:</span> <span class="ruby-string">&#39; + msg : msg;
2989
+ };
2990
+
2991
+ }); // module: chai/utils/getMessage.js
2992
+ require.register(&quot;chai/utils/getName.js&quot;, function(module, exports, require) {
2993
+ /*!
2994
+ Chai - getName utility
2995
+ Copyright(c) 2012-2013 Jake Luer &lt;jake@alogicalparadox.com&gt;
2996
+ MIT Licensed
2997
+ /
2998
+
2999
+ /**
3000
+ # getName(func)
3001
+
3002
+ Gets the name of a function, in a cross-browser way.
3003
+
3004
+ @param {Function} a function (usually a constructor)
3005
+ /
3006
+
3007
+ module.exports = function(func) {
3008
+ if (func.name) return func.name;
3009
+
3010
+ var match = /^\s?function ([^(]*)\(/.exec(func);
3011
+ return match &amp;&amp; match[1] ? match[1] : &quot;&quot;;
3012
+ };
3013
+
3014
+ }); // module: chai/utils/getName.js
3015
+ require.register(&quot;chai/utils/getPathValue.js&quot;, function(module, exports, require) {
3016
+ /*!
3017
+ Chai - getPathValue utility
3018
+ Copyright(c) 2012-2013 Jake Luer &lt;jake@alogicalparadox.com&gt;
3019
+ @see https://github.com/logicalparadox/filtr
3020
+ MIT Licensed
3021
+ /
3022
+
3023
+ /**
3024
+ ### .getPathValue(path, object)
3025
+
3026
+ This allows the retrieval of values in an
3027
+ object given a string path.
3028
+
3029
+ var obj = {
3030
+ prop1: {
3031
+ arr: [&#39;</span><span class="ruby-identifier">a</span><span class="ruby-string">&#39;, &#39;</span><span class="ruby-identifier">b</span><span class="ruby-string">&#39;, &#39;</span><span class="ruby-identifier">c</span><span class="ruby-string">&#39;]
3032
+ , str: &#39;</span><span class="ruby-constant">Hello</span><span class="ruby-string">&#39;
3033
+ }
3034
+ , prop2: {
3035
+ arr: [ { nested: &#39;</span><span class="ruby-constant">Universe</span><span class="ruby-string">&#39; } ]
3036
+ , str: &#39;</span><span class="ruby-constant">Hello</span> <span class="ruby-identifier">again!</span><span class="ruby-string">&#39;
3037
+ }
3038
+ }
3039
+
3040
+ The following would be the results.
3041
+
3042
+ getPathValue(&#39;</span><span class="ruby-identifier">prop1</span>.<span class="ruby-identifier">str</span><span class="ruby-string">&#39;, obj); // Hello
3043
+ getPathValue(&#39;</span><span class="ruby-identifier">prop1</span>.<span class="ruby-identifier">att</span>[<span class="ruby-value">2</span>]<span class="ruby-string">&#39;, obj); // b
3044
+ getPathValue(&#39;</span><span class="ruby-identifier">prop2</span>.<span class="ruby-identifier">arr</span>[<span class="ruby-value">0</span>].<span class="ruby-identifier">nested</span><span class="ruby-string">&#39;, obj); // Universe
3045
+
3046
+ @param {String} path
3047
+ @param {Object} object
3048
+ @returns {Object} value or `undefined`
3049
+ @name getPathValue
3050
+ @api public
3051
+ /
3052
+
3053
+ var getPathValue = module.exports = function(path, obj) {
3054
+ var parsed = parsePath(path);
3055
+ return _getPathValue(parsed, obj);
3056
+ };
3057
+
3058
+ /*!
3059
+ ## parsePath(path)
3060
+
3061
+ Helper function used to parse string object
3062
+ paths. Use in conjunction with `_getPathValue`.
3063
+
3064
+ var parsed = parsePath(&#39;</span><span class="ruby-identifier">myobject</span>.<span class="ruby-identifier">property</span>.<span class="ruby-identifier">subprop</span><span class="ruby-string">&#39;);
3065
+
3066
+ ### Paths:
3067
+
3068
+ * Can be as near infinitely deep and nested
3069
+ * Arrays are also valid using the formal `myobject.document[3].property`.
3070
+
3071
+ @param {String} path
3072
+ @returns {Object} parsed
3073
+ @api private
3074
+ /
3075
+
3076
+ function parsePath(path) {
3077
+ var str = path.replace(/\[/g, &#39;</span>.[<span class="ruby-string">&#39;),
3078
+ parts = str.match(/(\\.|[^.]+?)+/g);
3079
+ return parts.map(function(value) {
3080
+ var re = /\[(\d+)\]$/,
3081
+ mArr = re.exec(value)
3082
+ if (mArr) return {
3083
+ i: parseFloat(mArr[1])
3084
+ };
3085
+ else return {
3086
+ p: value
3087
+ };
3088
+ });
3089
+ };
3090
+
3091
+ /*!
3092
+ ## _getPathValue(parsed, obj)
3093
+
3094
+ Helper companion function for `.parsePath` that returns
3095
+ the value located at the parsed address.
3096
+
3097
+ var value = getPathValue(parsed, obj);
3098
+
3099
+ @param {Object} parsed definition from `parsePath`.
3100
+ @param {Object} object to search against
3101
+ @returns {Object|Undefined} value
3102
+ @api private
3103
+ /
3104
+
3105
+ function _getPathValue(parsed, obj) {
3106
+ var tmp = obj,
3107
+ res;
3108
+ for (var i = 0, l = parsed.length; i &lt; l; i++) {
3109
+ var part = parsed[i];
3110
+ if (tmp) {
3111
+ if (&#39;</span><span class="ruby-identifier">undefined</span><span class="ruby-string">&#39; !== typeof part.p) tmp = tmp[part.p];
3112
+ else if (&#39;</span><span class="ruby-identifier">undefined</span><span class="ruby-string">&#39; !== typeof part.i) tmp = tmp[part.i];
3113
+ if (i == (l - 1)) res = tmp;
3114
+ } else {
3115
+ res = undefined;
3116
+ }
3117
+ }
3118
+ return res;
3119
+ };
3120
+
3121
+ }); // module: chai/utils/getPathValue.js
3122
+ require.register(&quot;chai/utils/getProperties.js&quot;, function(module, exports, require) {
3123
+ /*!
3124
+ Chai - getProperties utility
3125
+ Copyright(c) 2012-2013 Jake Luer &lt;jake@alogicalparadox.com&gt;
3126
+ MIT Licensed
3127
+ /
3128
+
3129
+ /**
3130
+ ### .getProperties(object)
3131
+
3132
+ This allows the retrieval of property names of an object, enumerable or not,
3133
+ inherited or not.
3134
+
3135
+ @param {Object} object
3136
+ @returns {Array}
3137
+ @name getProperties
3138
+ @api public
3139
+ /
3140
+
3141
+ module.exports = function getProperties(object) {
3142
+ var result = Object.getOwnPropertyNames(subject);
3143
+
3144
+ function addProperty(property) {
3145
+ if (result.indexOf(property) === -1) {
3146
+ result.push(property);
3147
+ }
3148
+ }
3149
+
3150
+ var proto = Object.getPrototypeOf(subject);
3151
+ while (proto !== null) {
3152
+ Object.getOwnPropertyNames(proto).forEach(addProperty);
3153
+ proto = Object.getPrototypeOf(proto);
3154
+ }
3155
+
3156
+ return result;
3157
+ };
3158
+
3159
+ }); // module: chai/utils/getProperties.js
3160
+ require.register(&quot;chai/utils/index.js&quot;, function(module, exports, require) {
3161
+ /*!
3162
+ chai
3163
+ Copyright(c) 2011 Jake Luer &lt;jake@alogicalparadox.com&gt;
3164
+ MIT Licensed
3165
+ /
3166
+
3167
+ /*!
3168
+ Main exports
3169
+ /
3170
+
3171
+ var exports = module.exports = {};
3172
+
3173
+ /*!
3174
+ test utility
3175
+ /
3176
+
3177
+ exports.test = require(&#39;</span>.<span class="ruby-operator">/</span><span class="ruby-identifier">test</span><span class="ruby-string">&#39;);
3178
+
3179
+ /*!
3180
+ type utility
3181
+ /
3182
+
3183
+ exports.type = require(&#39;</span>.<span class="ruby-operator">/</span><span class="ruby-identifier">type</span><span class="ruby-string">&#39;);
3184
+
3185
+ /*!
3186
+ message utility
3187
+ /
3188
+
3189
+ exports.getMessage = require(&#39;</span>.<span class="ruby-operator">/</span><span class="ruby-identifier">getMessage</span><span class="ruby-string">&#39;);
3190
+
3191
+ /*!
3192
+ actual utility
3193
+ /
3194
+
3195
+ exports.getActual = require(&#39;</span>.<span class="ruby-operator">/</span><span class="ruby-identifier">getActual</span><span class="ruby-string">&#39;);
3196
+
3197
+ /*!
3198
+ Inspect util
3199
+ /
3200
+
3201
+ exports.inspect = require(&#39;</span>.<span class="ruby-operator">/</span><span class="ruby-identifier">inspect</span><span class="ruby-string">&#39;);
3202
+
3203
+ /*!
3204
+ Object Display util
3205
+ /
3206
+
3207
+ exports.objDisplay = require(&#39;</span>.<span class="ruby-operator">/</span><span class="ruby-identifier">objDisplay</span><span class="ruby-string">&#39;);
3208
+
3209
+ /*!
3210
+ Flag utility
3211
+ /
3212
+
3213
+ exports.flag = require(&#39;</span>.<span class="ruby-operator">/</span><span class="ruby-identifier">flag</span><span class="ruby-string">&#39;);
3214
+
3215
+ /*!
3216
+ Flag transferring utility
3217
+ /
3218
+
3219
+ exports.transferFlags = require(&#39;</span>.<span class="ruby-operator">/</span><span class="ruby-identifier">transferFlags</span><span class="ruby-string">&#39;);
3220
+
3221
+ /*!
3222
+ Deep equal utility
3223
+ /
3224
+
3225
+ exports.eql = require(&#39;</span>.<span class="ruby-operator">/</span><span class="ruby-identifier">eql</span><span class="ruby-string">&#39;);
3226
+
3227
+ /*!
3228
+ Deep path value
3229
+ /
3230
+
3231
+ exports.getPathValue = require(&#39;</span>.<span class="ruby-operator">/</span><span class="ruby-identifier">getPathValue</span><span class="ruby-string">&#39;);
3232
+
3233
+ /*!
3234
+ Function name
3235
+ /
3236
+
3237
+ exports.getName = require(&#39;</span>.<span class="ruby-operator">/</span><span class="ruby-identifier">getName</span><span class="ruby-string">&#39;);
3238
+
3239
+ /*!
3240
+ add Property
3241
+ /
3242
+
3243
+ exports.addProperty = require(&#39;</span>.<span class="ruby-operator">/</span><span class="ruby-identifier">addProperty</span><span class="ruby-string">&#39;);
3244
+
3245
+ /*!
3246
+ add Method
3247
+ /
3248
+
3249
+ exports.addMethod = require(&#39;</span>.<span class="ruby-operator">/</span><span class="ruby-identifier">addMethod</span><span class="ruby-string">&#39;);
3250
+
3251
+ /*!
3252
+ overwrite Property
3253
+ /
3254
+
3255
+ exports.overwriteProperty = require(&#39;</span>.<span class="ruby-operator">/</span><span class="ruby-identifier">overwriteProperty</span><span class="ruby-string">&#39;);
3256
+
3257
+ /*!
3258
+ overwrite Method
3259
+ /
3260
+
3261
+ exports.overwriteMethod = require(&#39;</span>.<span class="ruby-operator">/</span><span class="ruby-identifier">overwriteMethod</span><span class="ruby-string">&#39;);
3262
+
3263
+ /*!
3264
+ Add a chainable method
3265
+ /
3266
+
3267
+ exports.addChainableMethod = require(&#39;</span>.<span class="ruby-operator">/</span><span class="ruby-identifier">addChainableMethod</span><span class="ruby-string">&#39;);
3268
+
3269
+ }); // module: chai/utils/index.js
3270
+ require.register(&quot;chai/utils/inspect.js&quot;, function(module, exports, require) {
3271
+ // This is (almost) directly from Node.js utils
3272
+ // https://github.com/joyent/node/blob/f8c335d0caf47f16d31413f89aa28eda3878e3aa/lib/util.js
3273
+ var getName = require(&#39;</span>.<span class="ruby-operator">/</span><span class="ruby-identifier">getName</span><span class="ruby-string">&#39;);
3274
+ var getProperties = require(&#39;</span>.<span class="ruby-operator">/</span><span class="ruby-identifier">getProperties</span><span class="ruby-string">&#39;);
3275
+ var getEnumerableProperties = require(&#39;</span>.<span class="ruby-operator">/</span><span class="ruby-identifier">getEnumerableProperties</span><span class="ruby-string">&#39;);
3276
+
3277
+ module.exports = inspect;
3278
+
3279
+ /**
3280
+ Echos the value of a value. Trys to print the value out
3281
+ in the best way possible given the different types.
3282
+
3283
+ @param {Object} obj The object to print out.
3284
+ @param {Boolean} showHidden Flag that shows hidden (not enumerable)
3285
+ properties of objects.
3286
+ @param {Number} depth Depth in which to descend in object. Default is 2.
3287
+ @param {Boolean} colors Flag to turn on ANSI escape codes to color the
3288
+ output. Default is false (no coloring).
3289
+ /
3290
+ function inspect(obj, showHidden, depth, colors) {
3291
+ var ctx = {
3292
+ showHidden: showHidden,
3293
+ seen: [],
3294
+ stylize: function(str) {
3295
+ return str;
3296
+ }
3297
+ };
3298
+ return formatValue(ctx, obj, (typeof depth === &#39;</span><span class="ruby-identifier">undefined</span><span class="ruby-string">&#39; ? 2 : depth));
3299
+ }
3300
+
3301
+ // https://gist.github.com/1044128/
3302
+ var getOuterHTML = function(element) {
3303
+ if (&#39;</span><span class="ruby-identifier">outerHTML</span><span class="ruby-string">&#39; in element) return element.outerHTML;
3304
+ var ns = &quot;http://www.w3.org/1999/xhtml&quot;;
3305
+ var container = document.createElementNS(ns, &#39;</span><span class="ruby-identifier">_</span><span class="ruby-string">&#39;);
3306
+ var elemProto = (window.HTMLElement || window.Element).prototype;
3307
+ var xmlSerializer = new XMLSerializer();
3308
+ var html;
3309
+ if (document.xmlVersion) {
3310
+ return xmlSerializer.serializeToString(element);
3311
+ } else {
3312
+ container.appendChild(element.cloneNode(false));
3313
+ html = container.innerHTML.replace(&#39;</span><span class="ruby-operator">&gt;</span><span class="ruby-operator">&lt;</span><span class="ruby-string">&#39;, &#39;</span><span class="ruby-operator">&gt;</span><span class="ruby-string">&#39; + element.innerHTML + &#39;</span><span class="ruby-operator">&lt;</span><span class="ruby-string">&#39;);
3314
+ container.innerHTML = &#39;</span><span class="ruby-string">&#39;;
3315
+ return html;
3316
+ }
3317
+ };
3318
+
3319
+ // Returns true if object is a DOM element.
3320
+ var isDOMElement = function(object) {
3321
+ if (typeof HTMLElement === &#39;</span><span class="ruby-identifier">object</span><span class="ruby-string">&#39;) {
3322
+ return object instanceof HTMLElement;
3323
+ } else {
3324
+ return object &amp;&amp; typeof object === &#39;</span><span class="ruby-identifier">object</span><span class="ruby-string">&#39; &amp;&amp; object.nodeType === 1 &amp;&amp; typeof object.nodeName === &#39;</span><span class="ruby-identifier">string</span><span class="ruby-string">&#39;;
3325
+ }
3326
+ };
3327
+
3328
+ function formatValue(ctx, value, recurseTimes) {
3329
+ // Provide a hook for user-specified inspect functions.
3330
+ // Check that value is an object with an inspect function on it
3331
+ if (value &amp;&amp; typeof value.inspect === &#39;</span><span class="ruby-identifier">function</span><span class="ruby-string">&#39; &amp;&amp;
3332
+ // Filter out the util module, it&#39;</span><span class="ruby-identifier">s</span> <span class="ruby-identifier">inspect</span> <span class="ruby-identifier">function</span> <span class="ruby-identifier">is</span> <span class="ruby-identifier">special</span>
3333
+ <span class="ruby-identifier">value</span>.<span class="ruby-identifier">inspect</span> <span class="ruby-operator">!=</span>= <span class="ruby-identifier">exports</span>.<span class="ruby-identifier">inspect</span> <span class="ruby-operator">&amp;&amp;</span>
3334
+ <span class="ruby-regexp">//</span> <span class="ruby-constant">Also</span> <span class="ruby-identifier">filter</span> <span class="ruby-identifier">out</span> <span class="ruby-identifier">any</span> <span class="ruby-identifier">prototype</span> <span class="ruby-identifier">objects</span> <span class="ruby-identifier">using</span> <span class="ruby-identifier">the</span> <span class="ruby-identifier">circular</span> <span class="ruby-identifier">check</span>.
3335
+ <span class="ruby-operator">!</span>(<span class="ruby-identifier">value</span>.<span class="ruby-identifier">constructor</span> <span class="ruby-operator">&amp;&amp;</span> <span class="ruby-identifier">value</span>.<span class="ruby-identifier">constructor</span>.<span class="ruby-identifier">prototype</span> <span class="ruby-operator">===</span> <span class="ruby-identifier">value</span>)) {
3336
+ <span class="ruby-keyword">return</span> <span class="ruby-identifier">value</span>.<span class="ruby-identifier">inspect</span>(<span class="ruby-identifier">recurseTimes</span>);
3337
+ }
3338
+
3339
+ <span class="ruby-regexp">//</span> <span class="ruby-constant">Primitive</span> <span class="ruby-identifier">types</span> <span class="ruby-identifier">cannot</span> <span class="ruby-identifier">have</span> <span class="ruby-identifier">properties</span>
3340
+ <span class="ruby-identifier">var</span> <span class="ruby-identifier">primitive</span> = <span class="ruby-identifier">formatPrimitive</span>(<span class="ruby-identifier">ctx</span>, <span class="ruby-identifier">value</span>);
3341
+ <span class="ruby-keyword">if</span> (<span class="ruby-identifier">primitive</span>) {
3342
+ <span class="ruby-keyword">return</span> <span class="ruby-identifier">primitive</span>;
3343
+ }
3344
+
3345
+ <span class="ruby-regexp">//</span> <span class="ruby-constant">If</span> <span class="ruby-identifier">it</span><span class="ruby-string">&#39;s DOM elem, get outer HTML.
3346
+ if (isDOMElement(value)) {
3347
+ return getOuterHTML(value);
3348
+ }
3349
+
3350
+ // Look up the keys of the object.
3351
+ var visibleKeys = getEnumerableProperties(value);
3352
+ var keys = ctx.showHidden ? getProperties(value) : visibleKeys;
3353
+
3354
+ // Some type of object without properties can be shortcutted.
3355
+ // In IE, errors have a single `stack` property, or if they are vanilla `Error`,
3356
+ // a `stack` plus `description` property; ignore those for consistency.
3357
+ if (keys.length === 0 || (isError(value) &amp;&amp; (
3358
+ (keys.length === 1 &amp;&amp; keys[0] === &#39;</span><span class="ruby-identifier">stack</span><span class="ruby-string">&#39;) || (keys.length === 2 &amp;&amp; keys[0] === &#39;</span><span class="ruby-identifier">description</span><span class="ruby-string">&#39; &amp;&amp; keys[1] === &#39;</span><span class="ruby-identifier">stack</span><span class="ruby-string">&#39;)))) {
3359
+ if (typeof value === &#39;</span><span class="ruby-identifier">function</span><span class="ruby-string">&#39;) {
3360
+ var name = getName(value);
3361
+ var nameSuffix = name ? &#39;</span><span class="ruby-operator">:</span> <span class="ruby-string">&#39; + name : &#39;</span><span class="ruby-string">&#39;;
3362
+ return ctx.stylize(&#39;</span>[<span class="ruby-constant">Function</span><span class="ruby-string">&#39; + nameSuffix + &#39;</span>]<span class="ruby-string">&#39;, &#39;</span><span class="ruby-identifier">special</span><span class="ruby-string">&#39;);
3363
+ }
3364
+ if (isRegExp(value)) {
3365
+ return ctx.stylize(RegExp.prototype.toString.call(value), &#39;</span><span class="ruby-identifier">regexp</span><span class="ruby-string">&#39;);
3366
+ }
3367
+ if (isDate(value)) {
3368
+ return ctx.stylize(Date.prototype.toUTCString.call(value), &#39;</span><span class="ruby-identifier">date</span><span class="ruby-string">&#39;);
3369
+ }
3370
+ if (isError(value)) {
3371
+ return formatError(value);
3372
+ }
3373
+ }
3374
+
3375
+ var base = &#39;</span><span class="ruby-string">&#39;,
3376
+ array = false,
3377
+ braces = [&#39;</span>{<span class="ruby-string">&#39;, &#39;</span>}<span class="ruby-string">&#39;];
3378
+
3379
+ // Make Array say that they are Array
3380
+ if (isArray(value)) {
3381
+ array = true;
3382
+ braces = [&#39;</span>[<span class="ruby-string">&#39;, &#39;</span>]<span class="ruby-string">&#39;];
3383
+ }
3384
+
3385
+ // Make functions say that they are functions
3386
+ if (typeof value === &#39;</span><span class="ruby-identifier">function</span><span class="ruby-string">&#39;) {
3387
+ var name = getName(value);
3388
+ var nameSuffix = name ? &#39;</span><span class="ruby-operator">:</span> <span class="ruby-string">&#39; + name : &#39;</span><span class="ruby-string">&#39;;
3389
+ base = &#39;</span> [<span class="ruby-constant">Function</span><span class="ruby-string">&#39; + nameSuffix + &#39;</span>]<span class="ruby-string">&#39;;
3390
+ }
3391
+
3392
+ // Make RegExps say that they are RegExps
3393
+ if (isRegExp(value)) {
3394
+ base = &#39;</span> <span class="ruby-string">&#39; + RegExp.prototype.toString.call(value);
3395
+ }
3396
+
3397
+ // Make dates with properties first say the date
3398
+ if (isDate(value)) {
3399
+ base = &#39;</span> <span class="ruby-string">&#39; + Date.prototype.toUTCString.call(value);
3400
+ }
3401
+
3402
+ // Make error with message first say the error
3403
+ if (isError(value)) {
3404
+ return formatError(value);
3405
+ }
3406
+
3407
+ if (keys.length === 0 &amp;&amp; (!array || value.length == 0)) {
3408
+ return braces[0] + base + braces[1];
3409
+ }
3410
+
3411
+ if (recurseTimes &lt; 0) {
3412
+ if (isRegExp(value)) {
3413
+ return ctx.stylize(RegExp.prototype.toString.call(value), &#39;</span><span class="ruby-identifier">regexp</span><span class="ruby-string">&#39;);
3414
+ } else {
3415
+ return ctx.stylize(&#39;</span>[<span class="ruby-constant">Object</span>]<span class="ruby-string">&#39;, &#39;</span><span class="ruby-identifier">special</span><span class="ruby-string">&#39;);
3416
+ }
3417
+ }
3418
+
3419
+ ctx.seen.push(value);
3420
+
3421
+ var output;
3422
+ if (array) {
3423
+ output = formatArray(ctx, value, recurseTimes, visibleKeys, keys);
3424
+ } else {
3425
+ output = keys.map(function(key) {
3426
+ return formatProperty(ctx, value, recurseTimes, visibleKeys, key, array);
3427
+ });
3428
+ }
3429
+
3430
+ ctx.seen.pop();
3431
+
3432
+ return reduceToSingleString(output, base, braces);
3433
+ }
3434
+
3435
+ function formatPrimitive(ctx, value) {
3436
+ switch (typeof value) {
3437
+ case &#39;</span><span class="ruby-identifier">undefined</span><span class="ruby-string">&#39;:
3438
+ return ctx.stylize(&#39;</span><span class="ruby-identifier">undefined</span><span class="ruby-string">&#39;, &#39;</span><span class="ruby-identifier">undefined</span><span class="ruby-string">&#39;);
3439
+
3440
+ case &#39;</span><span class="ruby-identifier">string</span><span class="ruby-string">&#39;:
3441
+ var simple = &#39;</span>\<span class="ruby-string">&#39;&#39;</span> <span class="ruby-operator">+</span> <span class="ruby-constant">JSON</span>.<span class="ruby-identifier">stringify</span>(<span class="ruby-identifier">value</span>).<span class="ruby-identifier">replace</span>(<span class="ruby-regexp">/^&quot;|&quot;$/</span><span class="ruby-identifier">g</span>, <span class="ruby-string">&#39;&#39;</span>).<span class="ruby-identifier">replace</span>(<span class="ruby-regexp">/&#39;/</span><span class="ruby-identifier">g</span>, <span class="ruby-string">&quot;\\&#39;&quot;</span>).<span class="ruby-identifier">replace</span>(<span class="ruby-regexp">/\&quot;/</span><span class="ruby-identifier">g</span>, <span class="ruby-string">&#39;&quot;&#39;</span>) <span class="ruby-operator">+</span> <span class="ruby-string">&#39;\&#39;</span>;
3442
+ <span class="ruby-keyword">return</span> <span class="ruby-identifier">ctx</span>.<span class="ruby-identifier">stylize</span>(<span class="ruby-identifier">simple</span>, <span class="ruby-string">&#39;string&#39;</span>);
3443
+
3444
+ <span class="ruby-keyword">case</span> <span class="ruby-string">&#39;number&#39;</span><span class="ruby-operator">:</span>
3445
+ <span class="ruby-keyword">return</span> <span class="ruby-identifier">ctx</span>.<span class="ruby-identifier">stylize</span>(<span class="ruby-string">&#39;&#39;</span> <span class="ruby-operator">+</span> <span class="ruby-identifier">value</span>, <span class="ruby-string">&#39;number&#39;</span>);
3446
+
3447
+ <span class="ruby-keyword">case</span> <span class="ruby-string">&#39;boolean&#39;</span><span class="ruby-operator">:</span>
3448
+ <span class="ruby-keyword">return</span> <span class="ruby-identifier">ctx</span>.<span class="ruby-identifier">stylize</span>(<span class="ruby-string">&#39;&#39;</span> <span class="ruby-operator">+</span> <span class="ruby-identifier">value</span>, <span class="ruby-string">&#39;boolean&#39;</span>);
3449
+ }
3450
+ <span class="ruby-regexp">//</span> <span class="ruby-constant">For</span> <span class="ruby-identifier">some</span> <span class="ruby-identifier">reason</span> <span class="ruby-identifier">typeof</span> <span class="ruby-identifier">null</span> <span class="ruby-identifier">is</span> <span class="ruby-string">&quot;object&quot;</span>, <span class="ruby-identifier">so</span> <span class="ruby-identifier">special</span> <span class="ruby-keyword">case</span> <span class="ruby-identifier">here</span>.
3451
+ <span class="ruby-identifier">if</span> (<span class="ruby-identifier">value</span> <span class="ruby-operator">===</span> <span class="ruby-identifier">null</span>) {
3452
+ <span class="ruby-keyword">return</span> <span class="ruby-identifier">ctx</span>.<span class="ruby-identifier">stylize</span>(<span class="ruby-string">&#39;null&#39;</span>, <span class="ruby-string">&#39;null&#39;</span>);
3453
+ }
3454
+ }
3455
+
3456
+ <span class="ruby-identifier">function</span> <span class="ruby-identifier">formatError</span>(<span class="ruby-identifier">value</span>) {
3457
+ <span class="ruby-keyword">return</span> <span class="ruby-string">&#39;[&#39;</span> <span class="ruby-operator">+</span> <span class="ruby-constant">Error</span>.<span class="ruby-identifier">prototype</span>.<span class="ruby-identifier">toString</span>.<span class="ruby-identifier">call</span>(<span class="ruby-identifier">value</span>) <span class="ruby-operator">+</span> <span class="ruby-string">&#39;]&#39;</span>;
3458
+ }
3459
+
3460
+ <span class="ruby-identifier">function</span> <span class="ruby-identifier">formatArray</span>(<span class="ruby-identifier">ctx</span>, <span class="ruby-identifier">value</span>, <span class="ruby-identifier">recurseTimes</span>, <span class="ruby-identifier">visibleKeys</span>, <span class="ruby-identifier">keys</span>) {
3461
+ <span class="ruby-identifier">var</span> <span class="ruby-identifier">output</span> = [];
3462
+ <span class="ruby-keyword">for</span> (<span class="ruby-identifier">var</span> <span class="ruby-identifier">i</span> = <span class="ruby-value">0</span>, <span class="ruby-identifier">l</span> = <span class="ruby-identifier">value</span>.<span class="ruby-identifier">length</span>; <span class="ruby-identifier">i</span> <span class="ruby-operator">&lt;</span> <span class="ruby-identifier">l</span>; <span class="ruby-operator">+</span><span class="ruby-operator">+</span><span class="ruby-identifier">i</span>) {
3463
+ <span class="ruby-keyword">if</span> (<span class="ruby-constant">Object</span>.<span class="ruby-identifier">prototype</span>.<span class="ruby-identifier">hasOwnProperty</span>.<span class="ruby-identifier">call</span>(<span class="ruby-identifier">value</span>, <span class="ruby-constant">String</span>(<span class="ruby-identifier">i</span>))) {
3464
+ <span class="ruby-identifier">output</span>.<span class="ruby-identifier">push</span>(<span class="ruby-identifier">formatProperty</span>(<span class="ruby-identifier">ctx</span>, <span class="ruby-identifier">value</span>, <span class="ruby-identifier">recurseTimes</span>, <span class="ruby-identifier">visibleKeys</span>, <span class="ruby-constant">String</span>(<span class="ruby-identifier">i</span>), <span class="ruby-keyword">true</span>));
3465
+ } <span class="ruby-keyword">else</span> {
3466
+ <span class="ruby-identifier">output</span>.<span class="ruby-identifier">push</span>(<span class="ruby-string">&#39;&#39;</span>);
3467
+ }
3468
+ }
3469
+ <span class="ruby-identifier">keys</span>.<span class="ruby-identifier">forEach</span>(<span class="ruby-identifier">function</span>(<span class="ruby-identifier">key</span>) {
3470
+ <span class="ruby-keyword">if</span> (<span class="ruby-operator">!</span><span class="ruby-identifier">key</span>.<span class="ruby-identifier">match</span>(<span class="ruby-regexp">/^\d+$/</span>)) {
3471
+ <span class="ruby-identifier">output</span>.<span class="ruby-identifier">push</span>(<span class="ruby-identifier">formatProperty</span>(<span class="ruby-identifier">ctx</span>, <span class="ruby-identifier">value</span>, <span class="ruby-identifier">recurseTimes</span>, <span class="ruby-identifier">visibleKeys</span>, <span class="ruby-identifier">key</span>, <span class="ruby-keyword">true</span>));
3472
+ }
3473
+ });
3474
+ <span class="ruby-keyword">return</span> <span class="ruby-identifier">output</span>;
3475
+ }
3476
+
3477
+ <span class="ruby-identifier">function</span> <span class="ruby-identifier">formatProperty</span>(<span class="ruby-identifier">ctx</span>, <span class="ruby-identifier">value</span>, <span class="ruby-identifier">recurseTimes</span>, <span class="ruby-identifier">visibleKeys</span>, <span class="ruby-identifier">key</span>, <span class="ruby-identifier">array</span>) {
3478
+ <span class="ruby-identifier">var</span> <span class="ruby-identifier">name</span>, <span class="ruby-identifier">str</span>;
3479
+ <span class="ruby-keyword">if</span> (<span class="ruby-identifier">value</span>.<span class="ruby-identifier">__lookupGetter__</span>) {
3480
+ <span class="ruby-keyword">if</span> (<span class="ruby-identifier">value</span>.<span class="ruby-identifier">__lookupGetter__</span>(<span class="ruby-identifier">key</span>)) {
3481
+ <span class="ruby-keyword">if</span> (<span class="ruby-identifier">value</span>.<span class="ruby-identifier">__lookupSetter__</span>(<span class="ruby-identifier">key</span>)) {
3482
+ <span class="ruby-identifier">str</span> = <span class="ruby-identifier">ctx</span>.<span class="ruby-identifier">stylize</span>(<span class="ruby-string">&#39;[Getter/Setter]&#39;</span>, <span class="ruby-string">&#39;special&#39;</span>);
3483
+ } <span class="ruby-keyword">else</span> {
3484
+ <span class="ruby-identifier">str</span> = <span class="ruby-identifier">ctx</span>.<span class="ruby-identifier">stylize</span>(<span class="ruby-string">&#39;[Getter]&#39;</span>, <span class="ruby-string">&#39;special&#39;</span>);
3485
+ }
3486
+ } <span class="ruby-keyword">else</span> {
3487
+ <span class="ruby-keyword">if</span> (<span class="ruby-identifier">value</span>.<span class="ruby-identifier">__lookupSetter__</span>(<span class="ruby-identifier">key</span>)) {
3488
+ <span class="ruby-identifier">str</span> = <span class="ruby-identifier">ctx</span>.<span class="ruby-identifier">stylize</span>(<span class="ruby-string">&#39;[Setter]&#39;</span>, <span class="ruby-string">&#39;special&#39;</span>);
3489
+ }
3490
+ }
3491
+ }
3492
+ <span class="ruby-keyword">if</span> (<span class="ruby-identifier">visibleKeys</span>.<span class="ruby-identifier">indexOf</span>(<span class="ruby-identifier">key</span>) <span class="ruby-operator">&lt;</span> <span class="ruby-value">0</span>) {
3493
+ <span class="ruby-identifier">name</span> = <span class="ruby-string">&#39;[&#39;</span> <span class="ruby-operator">+</span> <span class="ruby-identifier">key</span> <span class="ruby-operator">+</span> <span class="ruby-string">&#39;]&#39;</span>;
3494
+ }
3495
+ <span class="ruby-keyword">if</span> (<span class="ruby-operator">!</span><span class="ruby-identifier">str</span>) {
3496
+ <span class="ruby-keyword">if</span> (<span class="ruby-identifier">ctx</span>.<span class="ruby-identifier">seen</span>.<span class="ruby-identifier">indexOf</span>(<span class="ruby-identifier">value</span>[<span class="ruby-identifier">key</span>]) <span class="ruby-operator">&lt;</span> <span class="ruby-value">0</span>) {
3497
+ <span class="ruby-keyword">if</span> (<span class="ruby-identifier">recurseTimes</span> <span class="ruby-operator">===</span> <span class="ruby-identifier">null</span>) {
3498
+ <span class="ruby-identifier">str</span> = <span class="ruby-identifier">formatValue</span>(<span class="ruby-identifier">ctx</span>, <span class="ruby-identifier">value</span>[<span class="ruby-identifier">key</span>], <span class="ruby-identifier">null</span>);
3499
+ } <span class="ruby-keyword">else</span> {
3500
+ <span class="ruby-identifier">str</span> = <span class="ruby-identifier">formatValue</span>(<span class="ruby-identifier">ctx</span>, <span class="ruby-identifier">value</span>[<span class="ruby-identifier">key</span>], <span class="ruby-identifier">recurseTimes</span> <span class="ruby-operator">-</span> <span class="ruby-value">1</span>);
3501
+ }
3502
+ <span class="ruby-keyword">if</span> (<span class="ruby-identifier">str</span>.<span class="ruby-identifier">indexOf</span>(<span class="ruby-string">&#39;\n&#39;</span>) <span class="ruby-operator">&gt;</span> <span class="ruby-value">-1</span>) {
3503
+ <span class="ruby-keyword">if</span> (<span class="ruby-identifier">array</span>) {
3504
+ <span class="ruby-identifier">str</span> = <span class="ruby-identifier">str</span>.<span class="ruby-identifier">split</span>(<span class="ruby-string">&#39;\n&#39;</span>).<span class="ruby-identifier">map</span>(<span class="ruby-identifier">function</span>(<span class="ruby-identifier">line</span>) {
3505
+ <span class="ruby-keyword">return</span> <span class="ruby-string">&#39; &#39;</span> <span class="ruby-operator">+</span> <span class="ruby-identifier">line</span>;
3506
+ }).<span class="ruby-identifier">join</span>(<span class="ruby-string">&#39;\n&#39;</span>).<span class="ruby-identifier">substr</span>(<span class="ruby-value">2</span>);
3507
+ } <span class="ruby-keyword">else</span> {
3508
+ <span class="ruby-identifier">str</span> = <span class="ruby-string">&#39;\n&#39;</span> <span class="ruby-operator">+</span> <span class="ruby-identifier">str</span>.<span class="ruby-identifier">split</span>(<span class="ruby-string">&#39;\n&#39;</span>).<span class="ruby-identifier">map</span>(<span class="ruby-identifier">function</span>(<span class="ruby-identifier">line</span>) {
3509
+ <span class="ruby-keyword">return</span> <span class="ruby-string">&#39; &#39;</span> <span class="ruby-operator">+</span> <span class="ruby-identifier">line</span>;
3510
+ }).<span class="ruby-identifier">join</span>(<span class="ruby-string">&#39;\n&#39;</span>);
3511
+ }
3512
+ }
3513
+ } <span class="ruby-keyword">else</span> {
3514
+ <span class="ruby-identifier">str</span> = <span class="ruby-identifier">ctx</span>.<span class="ruby-identifier">stylize</span>(<span class="ruby-string">&#39;[Circular]&#39;</span>, <span class="ruby-string">&#39;special&#39;</span>);
3515
+ }
3516
+ }
3517
+ <span class="ruby-keyword">if</span> (<span class="ruby-identifier">typeof</span> <span class="ruby-identifier">name</span> <span class="ruby-operator">===</span> <span class="ruby-string">&#39;undefined&#39;</span>) {
3518
+ <span class="ruby-keyword">if</span> (<span class="ruby-identifier">array</span> <span class="ruby-operator">&amp;&amp;</span> <span class="ruby-identifier">key</span>.<span class="ruby-identifier">match</span>(<span class="ruby-regexp">/^\d+$/</span>)) {
3519
+ <span class="ruby-keyword">return</span> <span class="ruby-identifier">str</span>;
3520
+ }
3521
+ <span class="ruby-identifier">name</span> = <span class="ruby-constant">JSON</span>.<span class="ruby-identifier">stringify</span>(<span class="ruby-string">&#39;&#39;</span> <span class="ruby-operator">+</span> <span class="ruby-identifier">key</span>);
3522
+ <span class="ruby-keyword">if</span> (<span class="ruby-identifier">name</span>.<span class="ruby-identifier">match</span>(<span class="ruby-regexp">/^&quot;([a-zA-Z_][a-zA-Z_0-9]*)&quot;$/</span>)) {
3523
+ <span class="ruby-identifier">name</span> = <span class="ruby-identifier">name</span>.<span class="ruby-identifier">substr</span>(<span class="ruby-value">1</span>, <span class="ruby-identifier">name</span>.<span class="ruby-identifier">length</span> <span class="ruby-operator">-</span> <span class="ruby-value">2</span>);
3524
+ <span class="ruby-identifier">name</span> = <span class="ruby-identifier">ctx</span>.<span class="ruby-identifier">stylize</span>(<span class="ruby-identifier">name</span>, <span class="ruby-string">&#39;name&#39;</span>);
3525
+ } <span class="ruby-keyword">else</span> {
3526
+ <span class="ruby-identifier">name</span> = <span class="ruby-identifier">name</span>.<span class="ruby-identifier">replace</span>(<span class="ruby-regexp">/&#39;/</span><span class="ruby-identifier">g</span>, <span class="ruby-string">&quot;\\&#39;&quot;</span>).<span class="ruby-identifier">replace</span>(<span class="ruby-regexp">/\&quot;/</span><span class="ruby-identifier">g</span>, <span class="ruby-string">&#39;&quot;&#39;</span>).<span class="ruby-identifier">replace</span>(<span class="ruby-regexp">/(^&quot;|&quot;$)/</span><span class="ruby-identifier">g</span>, <span class="ruby-string">&quot;&#39;&quot;</span>);
3527
+ <span class="ruby-identifier">name</span> = <span class="ruby-identifier">ctx</span>.<span class="ruby-identifier">stylize</span>(<span class="ruby-identifier">name</span>, <span class="ruby-string">&#39;string&#39;</span>);
3528
+ }
3529
+ }
3530
+
3531
+ <span class="ruby-keyword">return</span> <span class="ruby-identifier">name</span> <span class="ruby-operator">+</span> <span class="ruby-string">&#39;: &#39;</span> <span class="ruby-operator">+</span> <span class="ruby-identifier">str</span>;
3532
+ }
3533
+
3534
+ <span class="ruby-identifier">function</span> <span class="ruby-identifier">reduceToSingleString</span>(<span class="ruby-identifier">output</span>, <span class="ruby-identifier">base</span>, <span class="ruby-identifier">braces</span>) {
3535
+ <span class="ruby-identifier">var</span> <span class="ruby-identifier">numLinesEst</span> = <span class="ruby-value">0</span>;
3536
+ <span class="ruby-identifier">var</span> <span class="ruby-identifier">length</span> = <span class="ruby-identifier">output</span>.<span class="ruby-identifier">reduce</span>(<span class="ruby-identifier">function</span>(<span class="ruby-identifier">prev</span>, <span class="ruby-identifier">cur</span>) {
3537
+ <span class="ruby-identifier">numLinesEst</span><span class="ruby-operator">+</span><span class="ruby-operator">+</span>;
3538
+ <span class="ruby-keyword">if</span> (<span class="ruby-identifier">cur</span>.<span class="ruby-identifier">indexOf</span>(<span class="ruby-string">&#39;\n&#39;</span>) <span class="ruby-operator">&gt;=</span> <span class="ruby-value">0</span>) <span class="ruby-identifier">numLinesEst</span><span class="ruby-operator">+</span><span class="ruby-operator">+</span>;
3539
+ <span class="ruby-keyword">return</span> <span class="ruby-identifier">prev</span> <span class="ruby-operator">+</span> <span class="ruby-identifier">cur</span>.<span class="ruby-identifier">length</span> <span class="ruby-operator">+</span> <span class="ruby-value">1</span>;
3540
+ }, <span class="ruby-value">0</span>);
3541
+
3542
+ <span class="ruby-keyword">if</span> (<span class="ruby-identifier">length</span> <span class="ruby-operator">&gt;</span> <span class="ruby-value">60</span>) {
3543
+ <span class="ruby-keyword">return</span> <span class="ruby-identifier">braces</span>[<span class="ruby-value">0</span>] <span class="ruby-operator">+</span> (<span class="ruby-identifier">base</span> <span class="ruby-operator">===</span> <span class="ruby-string">&#39;&#39;</span> <span class="ruby-operator">?</span> <span class="ruby-string">&#39;&#39;</span> <span class="ruby-operator">:</span> <span class="ruby-identifier">base</span> <span class="ruby-operator">+</span> <span class="ruby-string">&#39;\n &#39;</span>) <span class="ruby-operator">+</span> <span class="ruby-string">&#39; &#39;</span> <span class="ruby-operator">+</span> <span class="ruby-identifier">output</span>.<span class="ruby-identifier">join</span>(<span class="ruby-string">&#39;,\n &#39;</span>) <span class="ruby-operator">+</span> <span class="ruby-string">&#39; &#39;</span> <span class="ruby-operator">+</span> <span class="ruby-identifier">braces</span>[<span class="ruby-value">1</span>];
3544
+ }
3545
+
3546
+ <span class="ruby-keyword">return</span> <span class="ruby-identifier">braces</span>[<span class="ruby-value">0</span>] <span class="ruby-operator">+</span> <span class="ruby-identifier">base</span> <span class="ruby-operator">+</span> <span class="ruby-string">&#39; &#39;</span> <span class="ruby-operator">+</span> <span class="ruby-identifier">output</span>.<span class="ruby-identifier">join</span>(<span class="ruby-string">&#39;, &#39;</span>) <span class="ruby-operator">+</span> <span class="ruby-string">&#39; &#39;</span> <span class="ruby-operator">+</span> <span class="ruby-identifier">braces</span>[<span class="ruby-value">1</span>];
3547
+ }
3548
+
3549
+ <span class="ruby-identifier">function</span> <span class="ruby-identifier">isArray</span>(<span class="ruby-identifier">ar</span>) {
3550
+ <span class="ruby-keyword">return</span> <span class="ruby-constant">Array</span>.<span class="ruby-identifier">isArray</span>(<span class="ruby-identifier">ar</span>) <span class="ruby-operator">||</span> (<span class="ruby-identifier">typeof</span> <span class="ruby-identifier">ar</span> <span class="ruby-operator">===</span> <span class="ruby-string">&#39;object&#39;</span> <span class="ruby-operator">&amp;&amp;</span> <span class="ruby-identifier">objectToString</span>(<span class="ruby-identifier">ar</span>) <span class="ruby-operator">===</span> <span class="ruby-string">&#39;[object Array]&#39;</span>);
3551
+ }
3552
+
3553
+ <span class="ruby-identifier">function</span> <span class="ruby-identifier">isRegExp</span>(<span class="ruby-identifier">re</span>) {
3554
+ <span class="ruby-keyword">return</span> <span class="ruby-identifier">typeof</span> <span class="ruby-identifier">re</span> <span class="ruby-operator">===</span> <span class="ruby-string">&#39;object&#39;</span> <span class="ruby-operator">&amp;&amp;</span> <span class="ruby-identifier">objectToString</span>(<span class="ruby-identifier">re</span>) <span class="ruby-operator">===</span> <span class="ruby-string">&#39;[object RegExp]&#39;</span>;
3555
+ }
3556
+
3557
+ <span class="ruby-identifier">function</span> <span class="ruby-identifier">isDate</span>(<span class="ruby-identifier">d</span>) {
3558
+ <span class="ruby-keyword">return</span> <span class="ruby-identifier">typeof</span> <span class="ruby-identifier">d</span> <span class="ruby-operator">===</span> <span class="ruby-string">&#39;object&#39;</span> <span class="ruby-operator">&amp;&amp;</span> <span class="ruby-identifier">objectToString</span>(<span class="ruby-identifier">d</span>) <span class="ruby-operator">===</span> <span class="ruby-string">&#39;[object Date]&#39;</span>;
3559
+ }
3560
+
3561
+ <span class="ruby-identifier">function</span> <span class="ruby-identifier">isError</span>(<span class="ruby-identifier">e</span>) {
3562
+ <span class="ruby-keyword">return</span> <span class="ruby-identifier">typeof</span> <span class="ruby-identifier">e</span> <span class="ruby-operator">===</span> <span class="ruby-string">&#39;object&#39;</span> <span class="ruby-operator">&amp;&amp;</span> <span class="ruby-identifier">objectToString</span>(<span class="ruby-identifier">e</span>) <span class="ruby-operator">===</span> <span class="ruby-string">&#39;[object Error]&#39;</span>;
3563
+ }
3564
+
3565
+ <span class="ruby-identifier">function</span> <span class="ruby-identifier">objectToString</span>(<span class="ruby-identifier">o</span>) {
3566
+ <span class="ruby-keyword">return</span> <span class="ruby-constant">Object</span>.<span class="ruby-identifier">prototype</span>.<span class="ruby-identifier">toString</span>.<span class="ruby-identifier">call</span>(<span class="ruby-identifier">o</span>);
3567
+ }
3568
+
3569
+ }); <span class="ruby-regexp">//</span> <span class="ruby-identifier">module</span><span class="ruby-operator">:</span> <span class="ruby-identifier">chai</span><span class="ruby-operator">/</span><span class="ruby-identifier">utils</span><span class="ruby-operator">/</span><span class="ruby-identifier">inspect</span>.<span class="ruby-identifier">js</span>
3570
+ <span class="ruby-identifier">require</span>.<span class="ruby-identifier">register</span>(<span class="ruby-string">&quot;chai/utils/objDisplay.js&quot;</span>, <span class="ruby-identifier">function</span>(<span class="ruby-keyword">module</span>, <span class="ruby-identifier">exports</span>, <span class="ruby-identifier">require</span>) {
3571
+ <span class="ruby-regexp">/*!
3572
+ Chai - flag utility
3573
+ Copyright(c) 2012-2013 Jake Luer &lt;jake@alogicalparadox.com&gt;
3574
+ MIT Licensed
3575
+ /</span>
3576
+
3577
+ <span class="ruby-regexp">/*!
3578
+ Module dependancies
3579
+ /</span>
3580
+
3581
+ <span class="ruby-identifier">var</span> <span class="ruby-identifier">inspect</span> = <span class="ruby-identifier">require</span>(<span class="ruby-string">&#39;./inspect&#39;</span>);
3582
+
3583
+ <span class="ruby-node">/**
3584
+ ### .objDisplay (object)
3585
+
3586
+ Determines if an object or an array matches
3587
+ criteria to be inspected in-line for error
3588
+ messages or should be truncated.
3589
+
3590
+ @param {Mixed} javascript object to inspect
3591
+ @name objDisplay
3592
+ @api public
3593
+ /</span>
3594
+
3595
+ <span class="ruby-keyword">module</span>.<span class="ruby-identifier">exports</span> = <span class="ruby-identifier">function</span>(<span class="ruby-identifier">obj</span>) {
3596
+ <span class="ruby-identifier">var</span> <span class="ruby-identifier">str</span> = <span class="ruby-identifier">inspect</span>(<span class="ruby-identifier">obj</span>),
3597
+ <span class="ruby-identifier">type</span> = <span class="ruby-constant">Object</span>.<span class="ruby-identifier">prototype</span>.<span class="ruby-identifier">toString</span>.<span class="ruby-identifier">call</span>(<span class="ruby-identifier">obj</span>);
3598
+
3599
+ <span class="ruby-keyword">if</span> (<span class="ruby-identifier">str</span>.<span class="ruby-identifier">length</span> <span class="ruby-operator">&gt;=</span> <span class="ruby-value">40</span>) {
3600
+ <span class="ruby-keyword">if</span> (<span class="ruby-identifier">type</span> <span class="ruby-operator">===</span> <span class="ruby-string">&#39;[object Function]&#39;</span>) {
3601
+ <span class="ruby-keyword">return</span> <span class="ruby-operator">!</span><span class="ruby-identifier">obj</span>.<span class="ruby-identifier">name</span> <span class="ruby-operator">||</span> <span class="ruby-identifier">obj</span>.<span class="ruby-identifier">name</span> <span class="ruby-operator">===</span> <span class="ruby-string">&#39;&#39;</span> <span class="ruby-operator">?</span> <span class="ruby-string">&#39;[Function]&#39;</span> <span class="ruby-operator">:</span> <span class="ruby-string">&#39;[Function: &#39;</span> <span class="ruby-operator">+</span> <span class="ruby-identifier">obj</span>.<span class="ruby-identifier">name</span> <span class="ruby-operator">+</span> <span class="ruby-string">&#39;]&#39;</span>;
3602
+ } <span class="ruby-keyword">else</span> <span class="ruby-keyword">if</span> (<span class="ruby-identifier">type</span> <span class="ruby-operator">===</span> <span class="ruby-string">&#39;[object Array]&#39;</span>) {
3603
+ <span class="ruby-keyword">return</span> <span class="ruby-string">&#39;[ Array(&#39;</span> <span class="ruby-operator">+</span> <span class="ruby-identifier">obj</span>.<span class="ruby-identifier">length</span> <span class="ruby-operator">+</span> <span class="ruby-string">&#39;) ]&#39;</span>;
3604
+ } <span class="ruby-keyword">else</span> <span class="ruby-keyword">if</span> (<span class="ruby-identifier">type</span> <span class="ruby-operator">===</span> <span class="ruby-string">&#39;[object Object]&#39;</span>) {
3605
+ <span class="ruby-identifier">var</span> <span class="ruby-identifier">keys</span> = <span class="ruby-constant">Object</span>.<span class="ruby-identifier">keys</span>(<span class="ruby-identifier">obj</span>),
3606
+ <span class="ruby-identifier">kstr</span> = <span class="ruby-identifier">keys</span>.<span class="ruby-identifier">length</span> <span class="ruby-operator">&gt;</span> <span class="ruby-value">2</span> <span class="ruby-operator">?</span> <span class="ruby-identifier">keys</span>.<span class="ruby-identifier">splice</span>(<span class="ruby-value">0</span>, <span class="ruby-value">2</span>).<span class="ruby-identifier">join</span>(<span class="ruby-string">&#39;, &#39;</span>) <span class="ruby-operator">+</span> <span class="ruby-string">&#39;, ...&#39;</span> <span class="ruby-operator">:</span> <span class="ruby-identifier">keys</span>.<span class="ruby-identifier">join</span>(<span class="ruby-string">&#39;, &#39;</span>);
3607
+ <span class="ruby-keyword">return</span> <span class="ruby-string">&#39;{ Object (&#39;</span> <span class="ruby-operator">+</span> <span class="ruby-identifier">kstr</span> <span class="ruby-operator">+</span> <span class="ruby-string">&#39;) }&#39;</span>;
3608
+ } <span class="ruby-keyword">else</span> {
3609
+ <span class="ruby-keyword">return</span> <span class="ruby-identifier">str</span>;
3610
+ }
3611
+ } <span class="ruby-keyword">else</span> {
3612
+ <span class="ruby-keyword">return</span> <span class="ruby-identifier">str</span>;
3613
+ }
3614
+ };
3615
+
3616
+ }); <span class="ruby-regexp">//</span> <span class="ruby-identifier">module</span><span class="ruby-operator">:</span> <span class="ruby-identifier">chai</span><span class="ruby-operator">/</span><span class="ruby-identifier">utils</span><span class="ruby-operator">/</span><span class="ruby-identifier">objDisplay</span>.<span class="ruby-identifier">js</span>
3617
+ <span class="ruby-identifier">require</span>.<span class="ruby-identifier">register</span>(<span class="ruby-string">&quot;chai/utils/overwriteMethod.js&quot;</span>, <span class="ruby-identifier">function</span>(<span class="ruby-keyword">module</span>, <span class="ruby-identifier">exports</span>, <span class="ruby-identifier">require</span>) {
3618
+ <span class="ruby-regexp">/*!
3619
+ Chai - overwriteMethod utility
3620
+ Copyright(c) 2012-2013 Jake Luer &lt;jake@alogicalparadox.com&gt;
3621
+ MIT Licensed
3622
+ /</span>
3623
+
3624
+ <span class="ruby-node">/**
3625
+ ### overwriteMethod (ctx, name, fn)
3626
+
3627
+ Overwites an already existing method and provides
3628
+ access to previous function. Must return function
3629
+ to be used for name.
3630
+
3631
+ utils.overwriteMethod(chai.Assertion.prototype, &#39;equal&#39;, function (_super) {
3632
+ return function (str) {
3633
+ var obj = utils.flag(this, &#39;object&#39;);
3634
+ if (obj instanceof Foo) {
3635
+ new chai.Assertion(obj.value).to.equal(str);
3636
+ } else {
3637
+ _super.apply(this, arguments);
3638
+ }
3639
+ }
3640
+ });
3641
+
3642
+ Can also be accessed directly from `chai.Assertion`.
3643
+
3644
+ chai.Assertion.overwriteMethod(&#39;foo&#39;, fn);
3645
+
3646
+ Then can be used as any other assertion.
3647
+
3648
+ expect(myFoo).to.equal(&#39;bar&#39;);
3649
+
3650
+ @param {Object} ctx object whose method is to be overwritten
3651
+ @param {String} name of method to overwrite
3652
+ @param {Function} method function that returns a function to be used for name
3653
+ @name overwriteMethod
3654
+ @api public
3655
+ /</span>
3656
+
3657
+ <span class="ruby-keyword">module</span>.<span class="ruby-identifier">exports</span> = <span class="ruby-identifier">function</span>(<span class="ruby-identifier">ctx</span>, <span class="ruby-identifier">name</span>, <span class="ruby-identifier">method</span>) {
3658
+ <span class="ruby-identifier">var</span> <span class="ruby-identifier">_method</span> = <span class="ruby-identifier">ctx</span>[<span class="ruby-identifier">name</span>],
3659
+ <span class="ruby-identifier">_super</span> = <span class="ruby-identifier">function</span>() {
3660
+ <span class="ruby-keyword">return</span> <span class="ruby-identifier">this</span>;
3661
+ };
3662
+
3663
+ <span class="ruby-keyword">if</span> (<span class="ruby-identifier">_method</span> <span class="ruby-operator">&amp;&amp;</span> <span class="ruby-string">&#39;function&#39;</span> <span class="ruby-operator">===</span> <span class="ruby-identifier">typeof</span> <span class="ruby-identifier">_method</span>) <span class="ruby-identifier">_super</span> = <span class="ruby-identifier">_method</span>;
3664
+
3665
+ <span class="ruby-identifier">ctx</span>[<span class="ruby-identifier">name</span>] = <span class="ruby-identifier">function</span>() {
3666
+ <span class="ruby-identifier">var</span> <span class="ruby-identifier">result</span> = <span class="ruby-identifier">method</span>(<span class="ruby-identifier">_super</span>).<span class="ruby-identifier">apply</span>(<span class="ruby-identifier">this</span>, <span class="ruby-identifier">arguments</span>);
3667
+ <span class="ruby-keyword">return</span> <span class="ruby-identifier">result</span> <span class="ruby-operator">===</span> <span class="ruby-identifier">undefined</span> <span class="ruby-operator">?</span> <span class="ruby-identifier">this</span> <span class="ruby-operator">:</span> <span class="ruby-identifier">result</span>;
3668
+ }
3669
+ };
3670
+
3671
+ }); <span class="ruby-regexp">//</span> <span class="ruby-identifier">module</span><span class="ruby-operator">:</span> <span class="ruby-identifier">chai</span><span class="ruby-operator">/</span><span class="ruby-identifier">utils</span><span class="ruby-operator">/</span><span class="ruby-identifier">overwriteMethod</span>.<span class="ruby-identifier">js</span>
3672
+ <span class="ruby-identifier">require</span>.<span class="ruby-identifier">register</span>(<span class="ruby-string">&quot;chai/utils/overwriteProperty.js&quot;</span>, <span class="ruby-identifier">function</span>(<span class="ruby-keyword">module</span>, <span class="ruby-identifier">exports</span>, <span class="ruby-identifier">require</span>) {
3673
+ <span class="ruby-regexp">/*!
3674
+ Chai - overwriteProperty utility
3675
+ Copyright(c) 2012-2013 Jake Luer &lt;jake@alogicalparadox.com&gt;
3676
+ MIT Licensed
3677
+ /</span>
3678
+
3679
+ <span class="ruby-node">/**
3680
+ ### overwriteProperty (ctx, name, fn)
3681
+
3682
+ Overwites an already existing property getter and provides
3683
+ access to previous value. Must return function to use as getter.
3684
+
3685
+ utils.overwriteProperty(chai.Assertion.prototype, &#39;ok&#39;, function (_super) {
3686
+ return function () {
3687
+ var obj = utils.flag(this, &#39;object&#39;);
3688
+ if (obj instanceof Foo) {
3689
+ new chai.Assertion(obj.name).to.equal(&#39;bar&#39;);
3690
+ } else {
3691
+ _super.call(this);
3692
+ }
3693
+ }
3694
+ });
3695
+
3696
+ Can also be accessed directly from `chai.Assertion`.
3697
+
3698
+ chai.Assertion.overwriteProperty(&#39;foo&#39;, fn);
3699
+
3700
+ Then can be used as any other assertion.
3701
+
3702
+ expect(myFoo).to.be.ok;
3703
+
3704
+ @param {Object} ctx object whose property is to be overwritten
3705
+ @param {String} name of property to overwrite
3706
+ @param {Function} getter function that returns a getter function to be used for name
3707
+ @name overwriteProperty
3708
+ @api public
3709
+ /</span>
3710
+
3711
+ <span class="ruby-keyword">module</span>.<span class="ruby-identifier">exports</span> = <span class="ruby-identifier">function</span>(<span class="ruby-identifier">ctx</span>, <span class="ruby-identifier">name</span>, <span class="ruby-identifier">getter</span>) {
3712
+ <span class="ruby-identifier">var</span> <span class="ruby-identifier">_get</span> = <span class="ruby-constant">Object</span>.<span class="ruby-identifier">getOwnPropertyDescriptor</span>(<span class="ruby-identifier">ctx</span>, <span class="ruby-identifier">name</span>),
3713
+ <span class="ruby-identifier">_super</span> = <span class="ruby-identifier">function</span>() {};
3714
+
3715
+ <span class="ruby-keyword">if</span> (<span class="ruby-identifier">_get</span> <span class="ruby-operator">&amp;&amp;</span> <span class="ruby-string">&#39;function&#39;</span> <span class="ruby-operator">===</span> <span class="ruby-identifier">typeof</span> <span class="ruby-identifier">_get</span>.<span class="ruby-identifier">get</span>) <span class="ruby-identifier">_super</span> = <span class="ruby-identifier">_get</span>.<span class="ruby-identifier">get</span>
3716
+
3717
+ <span class="ruby-constant">Object</span>.<span class="ruby-identifier">defineProperty</span>(<span class="ruby-identifier">ctx</span>, <span class="ruby-identifier">name</span>, {
3718
+ <span class="ruby-identifier">get</span><span class="ruby-operator">:</span> <span class="ruby-identifier">function</span>() {
3719
+ <span class="ruby-identifier">var</span> <span class="ruby-identifier">result</span> = <span class="ruby-identifier">getter</span>(<span class="ruby-identifier">_super</span>).<span class="ruby-identifier">call</span>(<span class="ruby-identifier">this</span>);
3720
+ <span class="ruby-keyword">return</span> <span class="ruby-identifier">result</span> <span class="ruby-operator">===</span> <span class="ruby-identifier">undefined</span> <span class="ruby-operator">?</span> <span class="ruby-identifier">this</span> <span class="ruby-operator">:</span> <span class="ruby-identifier">result</span>;
3721
+ },
3722
+ <span class="ruby-identifier">configurable</span><span class="ruby-operator">:</span> <span class="ruby-keyword">true</span>
3723
+ });
3724
+ };
3725
+
3726
+ }); <span class="ruby-regexp">//</span> <span class="ruby-identifier">module</span><span class="ruby-operator">:</span> <span class="ruby-identifier">chai</span><span class="ruby-operator">/</span><span class="ruby-identifier">utils</span><span class="ruby-operator">/</span><span class="ruby-identifier">overwriteProperty</span>.<span class="ruby-identifier">js</span>
3727
+ <span class="ruby-identifier">require</span>.<span class="ruby-identifier">register</span>(<span class="ruby-string">&quot;chai/utils/test.js&quot;</span>, <span class="ruby-identifier">function</span>(<span class="ruby-keyword">module</span>, <span class="ruby-identifier">exports</span>, <span class="ruby-identifier">require</span>) {
3728
+ <span class="ruby-regexp">/*!
3729
+ Chai - test utility
3730
+ Copyright(c) 2012-2013 Jake Luer &lt;jake@alogicalparadox.com&gt;
3731
+ MIT Licensed
3732
+ /</span>
3733
+
3734
+ <span class="ruby-regexp">/*!
3735
+ Module dependancies
3736
+ /</span>
3737
+
3738
+ <span class="ruby-identifier">var</span> <span class="ruby-identifier">flag</span> = <span class="ruby-identifier">require</span>(<span class="ruby-string">&#39;./flag&#39;</span>);
3739
+
3740
+ <span class="ruby-node">/**
3741
+ # test(object, expression)
3742
+
3743
+ Test and object for expression.
3744
+
3745
+ @param {Object} object (constructed Assertion)
3746
+ @param {Arguments} chai.Assertion.prototype.assert arguments
3747
+ /</span>
3748
+
3749
+ <span class="ruby-keyword">module</span>.<span class="ruby-identifier">exports</span> = <span class="ruby-identifier">function</span>(<span class="ruby-identifier">obj</span>, <span class="ruby-identifier">args</span>) {
3750
+ <span class="ruby-identifier">var</span> <span class="ruby-identifier">negate</span> = <span class="ruby-identifier">flag</span>(<span class="ruby-identifier">obj</span>, <span class="ruby-string">&#39;negate&#39;</span>),
3751
+ <span class="ruby-identifier">expr</span> = <span class="ruby-identifier">args</span>[<span class="ruby-value">0</span>];
3752
+ <span class="ruby-keyword">return</span> <span class="ruby-identifier">negate</span> <span class="ruby-operator">?</span> <span class="ruby-operator">!</span><span class="ruby-identifier">expr</span> <span class="ruby-operator">:</span> <span class="ruby-identifier">expr</span>;
3753
+ };
3754
+
3755
+ }); <span class="ruby-regexp">//</span> <span class="ruby-identifier">module</span><span class="ruby-operator">:</span> <span class="ruby-identifier">chai</span><span class="ruby-operator">/</span><span class="ruby-identifier">utils</span><span class="ruby-operator">/</span><span class="ruby-identifier">test</span>.<span class="ruby-identifier">js</span>
3756
+ <span class="ruby-identifier">require</span>.<span class="ruby-identifier">register</span>(<span class="ruby-string">&quot;chai/utils/transferFlags.js&quot;</span>, <span class="ruby-identifier">function</span>(<span class="ruby-keyword">module</span>, <span class="ruby-identifier">exports</span>, <span class="ruby-identifier">require</span>) {
3757
+ <span class="ruby-regexp">/*!
3758
+ Chai - transferFlags utility
3759
+ Copyright(c) 2012-2013 Jake Luer &lt;jake@alogicalparadox.com&gt;
3760
+ MIT Licensed
3761
+ /</span>
3762
+
3763
+ <span class="ruby-node">/**
3764
+ ### transferFlags(assertion, object, includeAll = true)
3765
+
3766
+ Transfer all the flags for `assertion` to `object`. If
3767
+ `includeAll` is set to `false`, then the base Chai
3768
+ assertion flags (namely `object`, `ssfi`, and `message`)
3769
+ will not be transferred.
3770
+
3771
+ var newAssertion = new Assertion();
3772
+ utils.transferFlags(assertion, newAssertion);
3773
+
3774
+ var anotherAsseriton = new Assertion(myObj);
3775
+ utils.transferFlags(assertion, anotherAssertion, false);
3776
+
3777
+ @param {Assertion} assertion the assertion to transfer the flags from
3778
+ @param {Object} object the object to transfer the flags too; usually a new assertion
3779
+ @param {Boolean} includeAll
3780
+ @name getAllFlags
3781
+ @api private
3782
+ /</span>
3783
+
3784
+ <span class="ruby-keyword">module</span>.<span class="ruby-identifier">exports</span> = <span class="ruby-identifier">function</span>(<span class="ruby-identifier">assertion</span>, <span class="ruby-identifier">object</span>, <span class="ruby-identifier">includeAll</span>) {
3785
+ <span class="ruby-identifier">var</span> <span class="ruby-identifier">flags</span> = <span class="ruby-identifier">assertion</span>.<span class="ruby-identifier">__flags</span> <span class="ruby-operator">||</span> (<span class="ruby-identifier">assertion</span>.<span class="ruby-identifier">__flags</span> = <span class="ruby-constant">Object</span>.<span class="ruby-identifier">create</span>(<span class="ruby-identifier">null</span>));
3786
+
3787
+ <span class="ruby-keyword">if</span> (<span class="ruby-operator">!</span><span class="ruby-identifier">object</span>.<span class="ruby-identifier">__flags</span>) {
3788
+ <span class="ruby-identifier">object</span>.<span class="ruby-identifier">__flags</span> = <span class="ruby-constant">Object</span>.<span class="ruby-identifier">create</span>(<span class="ruby-identifier">null</span>);
3789
+ }
3790
+
3791
+ <span class="ruby-identifier">includeAll</span> = <span class="ruby-identifier">arguments</span>.<span class="ruby-identifier">length</span> <span class="ruby-operator">===</span> <span class="ruby-value">3</span> <span class="ruby-operator">?</span> <span class="ruby-identifier">includeAll</span> <span class="ruby-operator">:</span> <span class="ruby-keyword">true</span>;
3792
+
3793
+ <span class="ruby-keyword">for</span> (<span class="ruby-identifier">var</span> <span class="ruby-identifier">flag</span> <span class="ruby-keyword">in</span> <span class="ruby-identifier">flags</span>) {
3794
+ <span class="ruby-keyword">if</span> (<span class="ruby-identifier">includeAll</span> <span class="ruby-operator">||</span> (<span class="ruby-identifier">flag</span> <span class="ruby-operator">!=</span>= <span class="ruby-string">&#39;object&#39;</span> <span class="ruby-operator">&amp;&amp;</span> <span class="ruby-identifier">flag</span> <span class="ruby-operator">!=</span>= <span class="ruby-string">&#39;ssfi&#39;</span> <span class="ruby-operator">&amp;&amp;</span> <span class="ruby-identifier">flag</span> <span class="ruby-operator">!=</span> <span class="ruby-string">&#39;message&#39;</span>)) {
3795
+ <span class="ruby-identifier">object</span>.<span class="ruby-identifier">__flags</span>[<span class="ruby-identifier">flag</span>] = <span class="ruby-identifier">flags</span>[<span class="ruby-identifier">flag</span>];
3796
+ }
3797
+ }
3798
+ };
3799
+
3800
+ }); <span class="ruby-regexp">//</span> <span class="ruby-identifier">module</span><span class="ruby-operator">:</span> <span class="ruby-identifier">chai</span><span class="ruby-operator">/</span><span class="ruby-identifier">utils</span><span class="ruby-operator">/</span><span class="ruby-identifier">transferFlags</span>.<span class="ruby-identifier">js</span>
3801
+ <span class="ruby-identifier">require</span>.<span class="ruby-identifier">register</span>(<span class="ruby-string">&quot;chai/utils/type.js&quot;</span>, <span class="ruby-identifier">function</span>(<span class="ruby-keyword">module</span>, <span class="ruby-identifier">exports</span>, <span class="ruby-identifier">require</span>) {
3802
+ <span class="ruby-regexp">/*!
3803
+ Chai - type utility
3804
+ Copyright(c) 2012-2013 Jake Luer &lt;jake@alogicalparadox.com&gt;
3805
+ MIT Licensed
3806
+ /</span>
3807
+
3808
+ <span class="ruby-regexp">/*!
3809
+ Detectable javascript natives
3810
+ /</span>
3811
+
3812
+ <span class="ruby-identifier">var</span> <span class="ruby-identifier">natives</span> = {
3813
+ <span class="ruby-string">&#39;[object Arguments]&#39;</span><span class="ruby-operator">:</span> <span class="ruby-string">&#39;arguments&#39;</span>,
3814
+ <span class="ruby-string">&#39;[object Array]&#39;</span><span class="ruby-operator">:</span> <span class="ruby-string">&#39;array&#39;</span>,
3815
+ <span class="ruby-string">&#39;[object Date]&#39;</span><span class="ruby-operator">:</span> <span class="ruby-string">&#39;date&#39;</span>,
3816
+ <span class="ruby-string">&#39;[object Function]&#39;</span><span class="ruby-operator">:</span> <span class="ruby-string">&#39;function&#39;</span>,
3817
+ <span class="ruby-string">&#39;[object Number]&#39;</span><span class="ruby-operator">:</span> <span class="ruby-string">&#39;number&#39;</span>,
3818
+ <span class="ruby-string">&#39;[object RegExp]&#39;</span><span class="ruby-operator">:</span> <span class="ruby-string">&#39;regexp&#39;</span>,
3819
+ <span class="ruby-string">&#39;[object String]&#39;</span><span class="ruby-operator">:</span> <span class="ruby-string">&#39;string&#39;</span>
3820
+ };
3821
+
3822
+ <span class="ruby-node">/**
3823
+ ### type(object)
3824
+
3825
+ Better implementation of `typeof` detection that can
3826
+ be used cross-browser. Handles the inconsistencies of
3827
+ Array, `null`, and `undefined` detection.
3828
+
3829
+ utils.type({}) /</span><span class="ruby-operator">/</span> <span class="ruby-string">&#39;object&#39;</span>
3830
+ <span class="ruby-identifier">utils</span>.<span class="ruby-identifier">type</span>(<span class="ruby-identifier">null</span>) <span class="ruby-operator">/</span><span class="ruby-regexp">/ `null&#39;
3831
+ utils.type(undefined) /</span><span class="ruby-operator">/</span> <span class="ruby-value">%xundefined`</span>
3832
+ <span class="ruby-identifier">utils</span>.<span class="ruby-identifier">type</span>([]) <span class="ruby-operator">/</span><span class="ruby-regexp">/ `array`
3833
+
3834
+ @param {Mixed} object to detect type of
3835
+ @name type
3836
+ @api private
3837
+ /</span>
3838
+
3839
+ <span class="ruby-keyword">module</span>.<span class="ruby-identifier">exports</span> = <span class="ruby-identifier">function</span>(<span class="ruby-identifier">obj</span>) {
3840
+ <span class="ruby-identifier">var</span> <span class="ruby-identifier">str</span> = <span class="ruby-constant">Object</span>.<span class="ruby-identifier">prototype</span>.<span class="ruby-identifier">toString</span>.<span class="ruby-identifier">call</span>(<span class="ruby-identifier">obj</span>);
3841
+ <span class="ruby-keyword">if</span> (<span class="ruby-identifier">natives</span>[<span class="ruby-identifier">str</span>]) <span class="ruby-keyword">return</span> <span class="ruby-identifier">natives</span>[<span class="ruby-identifier">str</span>];
3842
+ <span class="ruby-keyword">if</span> (<span class="ruby-identifier">obj</span> <span class="ruby-operator">===</span> <span class="ruby-identifier">null</span>) <span class="ruby-keyword">return</span> <span class="ruby-string">&#39;null&#39;</span>;
3843
+ <span class="ruby-keyword">if</span> (<span class="ruby-identifier">obj</span> <span class="ruby-operator">===</span> <span class="ruby-identifier">undefined</span>) <span class="ruby-keyword">return</span> <span class="ruby-string">&#39;undefined&#39;</span>;
3844
+ <span class="ruby-keyword">if</span> (<span class="ruby-identifier">obj</span> <span class="ruby-operator">===</span> <span class="ruby-constant">Object</span>(<span class="ruby-identifier">obj</span>)) <span class="ruby-keyword">return</span> <span class="ruby-string">&#39;object&#39;</span>;
3845
+ <span class="ruby-keyword">return</span> <span class="ruby-identifier">typeof</span> <span class="ruby-identifier">obj</span>;
3846
+ };
3847
+
3848
+ }); <span class="ruby-regexp">//</span> <span class="ruby-identifier">module</span><span class="ruby-operator">:</span> <span class="ruby-identifier">chai</span><span class="ruby-operator">/</span><span class="ruby-identifier">utils</span><span class="ruby-operator">/</span><span class="ruby-identifier">type</span>.<span class="ruby-identifier">js</span>
3849
+ <span class="ruby-identifier">require</span>.<span class="ruby-identifier">alias</span>(<span class="ruby-string">&quot;./chai.js&quot;</span>, <span class="ruby-string">&quot;chai&quot;</span>);
3850
+
3851
+ <span class="ruby-keyword">return</span> <span class="ruby-identifier">require</span>(<span class="ruby-string">&#39;chai&#39;</span>);
3852
+ </pre>
3853
+
3854
+ <p>});</p>
3855
+ </main>
3856
+
3857
+
3858
+
3859
+ <footer id="validator-badges" role="contentinfo">
3860
+ <p><a href="http://validator.w3.org/check/referer">Validate</a>
3861
+ <p>Generated by <a href="http://rdoc.rubyforge.org">RDoc</a> 4.1.0.
3862
+ <p>Based on <a href="http://deveiate.org/projects/Darkfish-Rdoc/">Darkfish</a> by <a href="http://deveiate.org">Michael Granger</a>.
3863
+ </footer>
3864
+