1 |
|
2 | 'use strict';
|
3 |
|
4 | var assert = require('chai').assert,
|
5 | UTIL = require('util'),
|
6 | BEM = require('..'),
|
7 | PATH = BEM.require('./path'),
|
8 | createLevel = BEM.createLevel;
|
9 |
|
10 |
|
11 |
|
12 |
|
13 |
|
14 |
|
15 |
|
16 |
|
17 |
|
18 |
|
19 |
|
20 |
|
21 | describe('level', function() {
|
22 |
|
23 | describe("Level('data/level-nested') /* nested level */", function() {
|
24 |
|
25 | var level = createLevel(absolute('data/level-nested'));
|
26 |
|
27 | describe(".getByObj()", function() {
|
28 |
|
29 | it("block, elem, mod, val", function() {
|
30 | var item = {
|
31 | block: 'block',
|
32 | elem: 'elem',
|
33 | mod: 'mod',
|
34 | val: 'val'
|
35 | };
|
36 | assert.equal(level.getByObj(item), PATH.resolve(level.dir, 'block/__elem/_mod/block__elem_mod_val'));
|
37 | });
|
38 |
|
39 | it("path/to/block, elem, mod, val", function() {
|
40 | var item = {
|
41 | block: 'path/to/block',
|
42 | elem: 'elem',
|
43 | mod: 'mod',
|
44 | val: 'val'
|
45 | };
|
46 | assert.equal(level.getByObj(item), PATH.resolve(level.dir, 'path/to/block/__elem/_mod/block__elem_mod_val'));
|
47 | });
|
48 |
|
49 | });
|
50 |
|
51 | describe(".getRelByObj()", function() {
|
52 |
|
53 | it("block, elem, mod, val", function() {
|
54 | var item = {
|
55 | block: 'block',
|
56 | elem: 'elem',
|
57 | mod: 'mod',
|
58 | val: 'val'
|
59 | };
|
60 | assert.equal(level.getRelByObj(item), 'block/__elem/_mod/block__elem_mod_val');
|
61 | });
|
62 |
|
63 | it("path/to/block, elem, mod, val", function() {
|
64 | var item = {
|
65 | block: 'path/to/block',
|
66 | elem: 'elem',
|
67 | mod: 'mod',
|
68 | val: 'val'
|
69 | };
|
70 | assert.equal(level.getRelByObj(item), 'path/to/block/__elem/_mod/block__elem_mod_val');
|
71 | });
|
72 |
|
73 | });
|
74 |
|
75 | describe(".matchAny()", function() {
|
76 |
|
77 | var abs1 = PATH.resolve(level.dir, 'block/block.css');
|
78 | it(abs1, function() {
|
79 | assert.deepEqual(level.matchAny(abs1), {
|
80 | block: 'block',
|
81 | suffix: '.css',
|
82 | tech: 'css'
|
83 | });
|
84 | });
|
85 |
|
86 | var abs2 = PATH.resolve(level.dir, 'path/to/block/block.css');
|
87 | it(abs2, function() {
|
88 | assert.deepEqual(level.matchAny(abs2), {
|
89 | block: 'path/to/block',
|
90 | suffix: '.css',
|
91 | tech: 'css'
|
92 | });
|
93 | });
|
94 |
|
95 | it('block/block.css', function() {
|
96 | assert.deepEqual(level.matchAny('block/block.css'), {
|
97 | block: 'block',
|
98 | suffix: '.css',
|
99 | tech: 'css'
|
100 | });
|
101 | });
|
102 |
|
103 | it('path/to/block/block.css', function() {
|
104 | assert.deepEqual(level.matchAny('path/to/block/block.css'), {
|
105 | block: 'path/to/block',
|
106 | suffix: '.css',
|
107 | tech: 'css'
|
108 | });
|
109 | });
|
110 |
|
111 | it('block/_mod/block_mod.css', function() {
|
112 | assert.deepEqual(level.matchAny('block/_mod/block_mod.css'), {
|
113 | block: 'block',
|
114 | mod: 'mod',
|
115 | suffix: '.css',
|
116 | tech: 'css'
|
117 | });
|
118 | });
|
119 |
|
120 | it('path/to/block/_mod/block_mod.css', function() {
|
121 | assert.deepEqual(level.matchAny('path/to/block/_mod/block_mod.css'), {
|
122 | block: 'path/to/block',
|
123 | mod: 'mod',
|
124 | suffix: '.css',
|
125 | tech: 'css'
|
126 | });
|
127 | });
|
128 |
|
129 | it('block/_mod/block_mod_val.css', function() {
|
130 | assert.deepEqual(level.matchAny('block/_mod/block_mod_val.css'), {
|
131 | block: 'block',
|
132 | mod: 'mod',
|
133 | val: 'val',
|
134 | suffix: '.css',
|
135 | tech: 'css'
|
136 | });
|
137 | });
|
138 |
|
139 | it('path/to/block/_mod/block_mod_val.css', function() {
|
140 | assert.deepEqual(level.matchAny('path/to/block/_mod/block_mod_val.css'), {
|
141 | block: 'path/to/block',
|
142 | mod: 'mod',
|
143 | val: 'val',
|
144 | suffix: '.css',
|
145 | tech: 'css'
|
146 | });
|
147 | });
|
148 |
|
149 | it('block/__elem/block__elem.css', function() {
|
150 | assert.deepEqual(level.matchAny('block/__elem/block__elem.css'), {
|
151 | block: 'block',
|
152 | elem: 'elem',
|
153 | suffix: '.css',
|
154 | tech: 'css'
|
155 | });
|
156 | });
|
157 |
|
158 | it('path/to/block/__elem/block__elem.css', function() {
|
159 | assert.deepEqual(level.matchAny('path/to/block/__elem/block__elem.css'), {
|
160 | block: 'path/to/block',
|
161 | elem: 'elem',
|
162 | suffix: '.css',
|
163 | tech: 'css'
|
164 | });
|
165 | });
|
166 |
|
167 | it('block/__elem/_mod/block__elem_mod.css', function() {
|
168 | assert.deepEqual(level.matchAny('block/__elem/_mod/block__elem_mod.css'), {
|
169 | block: 'block',
|
170 | elem: 'elem',
|
171 | mod: 'mod',
|
172 | suffix: '.css',
|
173 | tech: 'css'
|
174 | });
|
175 | });
|
176 |
|
177 | it('path/to/block/__elem/_mod/block__elem_mod.css', function() {
|
178 | assert.deepEqual(level.matchAny('path/to/block/__elem/_mod/block__elem_mod.css'), {
|
179 | block: 'path/to/block',
|
180 | elem: 'elem',
|
181 | mod: 'mod',
|
182 | suffix: '.css',
|
183 | tech: 'css'
|
184 | });
|
185 | });
|
186 |
|
187 | it('block/__elem/_mod/block__elem_mod_val.css', function() {
|
188 | assert.deepEqual(level.matchAny('block/__elem/_mod/block__elem_mod_val.css'), {
|
189 | block: 'block',
|
190 | elem: 'elem',
|
191 | mod: 'mod',
|
192 | val: 'val',
|
193 | suffix: '.css',
|
194 | tech: 'css'
|
195 | });
|
196 | });
|
197 |
|
198 | it('path/to/block/__elem/_mod/block__elem_mod_val.css', function() {
|
199 | assert.deepEqual(level.matchAny('path/to/block/__elem/_mod/block__elem_mod_val.css'), {
|
200 | block: 'path/to/block',
|
201 | elem: 'elem',
|
202 | mod: 'mod',
|
203 | val: 'val',
|
204 | suffix: '.css',
|
205 | tech: 'css'
|
206 | });
|
207 | });
|
208 |
|
209 | it('block/__elem/_mod/block__elem_mod_val.custom', function() {
|
210 | assert.deepEqual(level.matchAny('block/__elem/_mod/block__elem_mod_val.custom'), {
|
211 | block: 'block',
|
212 | elem: 'elem',
|
213 | mod: 'mod',
|
214 | val: 'val',
|
215 | suffix: '.custom',
|
216 | tech: undefined
|
217 | });
|
218 | });
|
219 |
|
220 | it('path/to/block/__elem/_mod/block__elem_mod_val.custom', function() {
|
221 | assert.deepEqual(level.matchAny('path/to/block/__elem/_mod/block__elem_mod_val.custom'), {
|
222 | block: 'path/to/block',
|
223 | elem: 'elem',
|
224 | mod: 'mod',
|
225 | val: 'val',
|
226 | suffix: '.custom',
|
227 | tech: undefined
|
228 | });
|
229 | });
|
230 |
|
231 | });
|
232 |
|
233 | describe(".getDeclByIntrospection()", function() {
|
234 | it("returns correct introspection", function() {
|
235 | assert.deepEqual(level.getDeclByIntrospection(), [
|
236 |
|
237 | {
|
238 | name: 'first-block',
|
239 | elems: [ {
|
240 | name: 'elem1',
|
241 | mods: [ {
|
242 | name: 'mod2',
|
243 | techs: [ { name: 'css' } ],
|
244 | vals: [ {
|
245 | name: '3',
|
246 | techs: [ { name: 'js' } ]
|
247 | } ]
|
248 | } ]
|
249 | } ]
|
250 | },
|
251 |
|
252 | {
|
253 | name: 'path/to/first-block',
|
254 | elems: [ {
|
255 | name: 'elem1',
|
256 | mods: [ {
|
257 | name: 'mod2',
|
258 | techs: [ { name: 'css' } ],
|
259 | vals: [ {
|
260 | name: '3',
|
261 | techs: [ { name: 'js' } ]
|
262 | } ]
|
263 | } ]
|
264 | } ]
|
265 | }
|
266 |
|
267 | ]);
|
268 | });
|
269 | });
|
270 |
|
271 | describe(".match-*()", function() {
|
272 |
|
273 | level.matchOrder().forEach(function(matcher) {
|
274 |
|
275 | var args = matcher.split('-'),
|
276 | match, nestedMatch, block;
|
277 |
|
278 | if (matcher === 'elem-all' || matcher === 'block-all') return;
|
279 |
|
280 |
|
281 | if(args[0] !== 'block') args.unshift('block');
|
282 | match = level.match(matcher, level.getRel(matcher, args));
|
283 |
|
284 | it(UTIL.format("matcher '%s' complies to getter", matcher), testMatch(match));
|
285 |
|
286 |
|
287 | block = PATH.join.apply(null, ['path', 'to', 'block']);
|
288 | args[0] = block;
|
289 | nestedMatch = level.match(matcher, level.getRel(matcher, args));
|
290 |
|
291 | it(UTIL.format("matcher '%s' complies to getter (nested)", matcher), testMatch(nestedMatch, { block: block }));
|
292 |
|
293 |
|
294 | function testMatch(match, vars) {
|
295 |
|
296 | vars = vars || {};
|
297 |
|
298 | return function() {
|
299 | Object.keys(match).forEach(function(key) {
|
300 | assert.isString(match[key]);
|
301 | if(key === 'suffix') {
|
302 | assert.equal(match[key], '');
|
303 | return;
|
304 | }
|
305 | assert.equal(match[key], vars[key] || key);
|
306 | });
|
307 | };
|
308 |
|
309 | }
|
310 |
|
311 | });
|
312 |
|
313 | });
|
314 |
|
315 | });
|
316 |
|
317 | });
|
318 |
|
319 | function absolute(path) {
|
320 | return PATH.resolve(__dirname, path);
|
321 | }
|