less 2.1.1 → 2.3.1

package/test/less-bom/mixins-guards-default-func.less

@@ -0,0 +1,195 @@
+
+// basics:
+
+guard-default-basic-1 {
+    .m(1)                   {case:     1}
+    .m(@x) when (default()) {default: @x}
+
+    &-1 {.m(1)}
+    &-2 {.m(2)}
+}
+
+guard-default-basic-2 {
+    .m(1)                   {case:     1}
+    .m(2)                   {case:     2}
+    .m(3)                   {case:     3}
+    .m(@x) when (default()) {default: @x}
+
+    &-0 {.m(0)}
+    &-2 {.m(2)}
+}
+
+guard-default-basic-3 {
+    .m(@x) when (@x = 1)    {case:     1}
+    .m(2)                   {case:     2}
+    .m(@x) when (@x = 3)    {case:     3}
+    .m(@x) when (default()) {default: @x}
+
+    &-0 {.m(0)}
+    &-2 {.m(2)}
+    &-3 {.m(3)}
+}
+
+guard-default-definition-order {
+    .m(@x) when (default()) {default: @x}
+    .m(@x) when (@x = 1)    {case:     1}
+    .m(2)                   {case:     2}
+    .m(@x) when (@x = 3)    {case:     3}
+
+    &-0 {.m(0)}
+    &-2 {.m(2)}
+    &-2 {.m(3)}
+}
+
+// out of guard:
+
+guard-default-out-of-guard {
+    .m(1)                              {case-1:   1}
+    .m(@x: default()) when (default()) {default: @x}
+
+    &-0 {
+        case-0: default();
+        .m(1);
+        .m(2);
+        case-2: default();
+    }
+    &-1 {.m(default())}
+    &-2 {.m()}
+}
+
+// expressions:
+
+guard-default-expr-not {
+    .m(1)                      {case:     1}
+    .m(@x) when not(default()) {default: @x}
+
+    &-1 {.m(1)}
+    &-2 {.m(2)}
+}
+
+guard-default-expr-eq {
+    .m(@x) when (@x = true)      {case:    @x}
+    .m(@x) when (@x = false)     {case:    @x}
+    .m(@x) when (@x = default()) {default: @x}
+
+    &-true  {.m(true)}
+    &-false {.m(false)}
+}
+
+guard-default-expr-or {
+    .m(1)                             {case:     1}
+    .m(2)                             {case:     2}
+    .m(@x) when (default()), (@x = 2) {default: @x}
+
+    &-1 {.m(1)}
+    &-2 {.m(2)}
+    &-3 {.m(3)}
+}
+
+guard-default-expr-and {
+    .m(1)                                {case:     1}
+    .m(2)                                {case:     2}
+    .m(@x) when (default()) and (@x = 3) {default: @x}
+
+    &-1 {.m(1)}
+    &-2 {.m(2)}
+    &-3 {.m(3)}
+    &-4 {.m(4)}
+}
+
+guard-default-expr-always {
+    .m(1)                                   {case:     1}
+    .m(@x) when (default()), not(default()) {default: @x} // always match
+
+    &-1 {.m(1)}
+    &-2 {.m(2)}
+}
+
+guard-default-expr-never {
+    .m(1)                                      {case:     1}
+    .m(@x) when (default()) and not(default()) {default: @x} // never match
+
+    &-1 {.m(1)}
+    &-2 {.m(2)}
+}
+
+
+// not conflicting multiple default() uses:
+
+guard-default-multi-1 {
+    .m(0)                   {case:       0}
+    .m(@x) when (default()) {default-1: @x}
+    .m(2)  when (default()) {default-2: @x}
+
+    &-0 {.m(0)}
+    &-1 {.m(1)}
+}
+
+guard-default-multi-2 {
+    .m(1, @x)   when (default()) {default-1: @x}
+    .m(2, @x)   when (default()) {default-2: @x}
+    .m(@x, yes) when (default()) {default-3: @x}
+
+    &-1 {.m(1, no)}
+    &-2 {.m(2, no)}
+    &-3 {.m(3, yes)}
+}
+
+guard-default-multi-3 {
+    .m(red)                                    {case-1: darkred}
+    .m(blue)                                   {case-2: darkblue}
+    .m(@x) when (iscolor(@x)) and (default())  {default-color: @x}
+    .m('foo')                                  {case-1: I am 'foo'}
+    .m('bar')                                  {case-2: I am 'bar'}
+    .m(@x) when (isstring(@x)) and (default()) {default-string: I am @x}
+
+    &-blue  {.m(blue)}
+    &-green {.m(green)}
+    &-foo   {.m('foo')}
+    &-baz   {.m('baz')}
+}
+
+guard-default-multi-4 {
+    .m(@x) when (default()), not(default())    {always: @x}
+    .m(@x) when (default()) and not(default()) {never:  @x}
+    .m(2)                                      {case:    2}
+
+    .m(1);
+    .m(2);
+}
+
+guard-default-not-ambiguos-2 {
+    .m(@x)                     {case:         1}
+    .m(@x) when (default())    {default:     @x}
+    .m(@x) when not(default()) {not-default: @x}
+
+    .m(2);
+}
+
+guard-default-not-ambiguos-3 {
+    .m(@x)                     {case:           1}
+    .m(@x) when not(default()) {not-default-1: @x}
+    .m(@x) when not(default()) {not-default-2: @x}
+
+    .m(2);
+}
+
+// default & scope
+
+guard-default-scopes {
+    .s1() {.m(@v)                  {1: no condition}}
+    .s2() {.m(@v) when (@v)        {2: when true}}
+    .s3() {.m(@v) when (default()) {3: when default}}
+
+    &-3 {
+        .s2();
+        .s3();
+        .m(false);
+    }
+
+    &-1 {
+        .s1();
+        .s3();
+        .m(false);
+    }
+}

package/test/less-bom/mixins-guards.less

@@ -0,0 +1,271 @@
+
+// Stacking, functions..
+
+.light (@a) when (lightness(@a) > 50%) {
+  color: white;
+}
+.light (@a) when (lightness(@a) < 50%) {
+  color: black;
+}
+.light (@a) {
+  margin: 1px;
+}
+
+.light1 { .light(#ddd) }
+.light2 { .light(#444) }
+
+// Arguments against each other
+
+.max (@a, @b) when (@a > @b) {
+  width: @a;
+}
+.max (@a, @b) when (@a < @b) {
+  width: @b;
+}
+
+.max1 { .max(3, 6) }
+.max2 { .max(8, 1) }
+
+// Globals inside guards
+
+@g: auto;
+
+.glob (@a) when (@a = @g) {
+  margin: @a @g;
+}
+.glob1 { .glob(auto) }
+
+// Other operators
+
+.ops (@a) when (@a >= 0) {
+  height: gt-or-eq;
+}
+.ops (@a) when (@a =< 0) {
+  height: lt-or-eq;
+}
+.ops (@a) when (@a <= 0) {
+  height: lt-or-eq-alias;
+}
+.ops (@a) when not(@a = 0) {
+  height: not-eq;
+}
+.ops1 { .ops(0) }
+.ops2 { .ops(1) }
+.ops3 { .ops(-1) }
+
+// Scope and default values
+
+@a: auto;
+
+.default (@a: inherit) when (@a = inherit) {
+  content: default;
+}
+.default1 { .default }
+
+// true & false keywords
+.test (@a) when (@a) {
+    content: "true.";
+}
+.test (@a) when not (@a) {
+    content: "false.";
+}
+
+.test1 { .test(true) }
+.test2 { .test(false) }
+.test3 { .test(1) }
+.test4 { .test(boo) }
+.test5 { .test("true") }
+
+// Boolean expressions
+
+.bool () when (true) and (false)                             { content: true and false } // FALSE
+.bool () when (true) and (true)                              { content: true and true } // TRUE
+.bool () when (true)                                         { content: true } // TRUE
+.bool () when (false) and (false)                            { content: true } // FALSE
+.bool () when (false), (true)                                { content: false, true } // TRUE
+.bool () when (false) and (true) and (true),  (true)         { content: false and true and true, true } // TRUE
+.bool () when (true)  and (true) and (false), (false)        { content: true and true and false, false } // FALSE
+.bool () when (false), (true) and (true)                     { content: false, true and true } // TRUE
+.bool () when (false), (false), (true)                       { content: false, false, true } // TRUE
+.bool () when (false), (false) and (true), (false)           { content: false, false and true, false } // FALSE
+.bool () when (false), (true) and (true) and (true), (false) { content: false, true and true and true, false } // TRUE
+.bool () when not (false)                                    { content: not false }
+.bool () when not (true) and not (false)                     { content: not true and not false }
+.bool () when not (true) and not (true)                      { content: not true and not true }
+.bool () when not (false) and (false), not (false)           { content: not false and false, not false }
+
+.bool1 { .bool }
+
+.equality-unit-test(@num) when (@num = 1%) {
+  test: fail;
+}
+.equality-unit-test(@num) when (@num = 2) {
+  test: pass;
+}
+.equality-units {
+  .equality-unit-test(1px);
+  .equality-unit-test(2px);
+}
+
+.colorguard(@col) when (@col = red)                         { content: is @col; }
+.colorguard(@col) when not (blue = @col)                    { content: is not blue its @col; }
+.colorguard(@col)                                           {}
+.colorguardtest {
+    .colorguard(red);
+    .colorguard(blue);
+    .colorguard(purple);
+}
+
+.stringguard(@str) when (@str = "theme1")					{ content: @str is "theme1"; }
+.stringguard(@str) when not ("theme2" = @str)				{ content: @str is not "theme2"; }
+.stringguard(@str) when (@str = 'theme1')					{ content: @str is 'theme1'; }
+.stringguard(@str) when not ('theme2' = @str)				{ content: @str is not 'theme2'; }
+.stringguard(@str) when (~"theme1" = @str)					{ content: @str is theme1; }
+.stringguard(@str)                                          {}
+.stringguardtest {
+    .stringguard("theme1");
+    .stringguard("theme2");
+    .stringguard('theme1');
+    .stringguard('theme2');
+    .stringguard(theme1);
+}
+
+.generic(@a, @b) {/**/}
+.generic(@a, @b) when (@a = @b) {content: @a is equal to @b}
+.generic(@a, @b) when (@b = @a) {content: @b is equal to @a too}
+.generic(@a, @b) when (@a < @b) {content: @a is less than @b}
+.generic(@a, @b) when (@b < @a) {content: @b is less than @a too}
+.generic(@a, @b) when (@a > @b) {content: @a is greater than @b}
+.generic(@a, @b) when (@b > @a) {content: @b is greater than @a too}
+.generic(@a, @b) when not(@a = @b) {content: @a is not equal to @b}
+.generic(@a, @b) when not(@b = @a) {content: @b is not equal to @a too}
+
+.variouse-types-comparison {
+    .generic(true, false);
+    .generic(1, true);
+    .generic(2, 2px);
+    .generic(3, ~"3");
+    .generic(5, ~"4");
+    .generic(abc, ~"abc");
+    .generic(abc, "abc");
+    .generic('abc', "abd");
+    .generic(6, e("6"));
+    .generic(`9`, 8);
+    .generic(a, b);
+    .generic(1 2, 3);
+}
+
+.list-comparison {
+    .generic(a b c, a b c);
+    .generic(a b c, a b d);
+    .generic(a, b, c; a, b, c);
+    .generic(a, b, c; a, b, d);
+    .generic(1 2px 300ms, 1em 2 .3s);
+    
+    @space-list: 1 2 3;
+    @comma-list: 1, 2, 3;
+    @compound: @space-list @comma-list;
+    
+    .generic(@space-list, @comma-list);
+    .generic(@comma-list, ~"1, 2, 3");
+    .generic(@compound, @space-list @comma-list);
+    .generic(@compound, @comma-list @space-list);
+    .generic(@compound 4, ~"1 2 3 1, 2, 3 4");
+}
+
+.mixin(...) {
+  catch:all;
+}
+.mixin(@var) when (@var=4) {
+  declare: 4;
+}
+.mixin(@var) when (@var=4px) {
+  declare: 4px;
+}
+#tryNumberPx {
+  .mixin(4px);
+}
+
+.lock-mixin(@a) {
+ .inner-locked-mixin(@x: @a) when (@a = 1) {
+    a: @a;
+    x: @x;
+  }
+}
+.call-lock-mixin {
+  .lock-mixin(1);
+  .call-inner-lock-mixin {
+    .inner-locked-mixin();
+  }
+}
+.bug-100cm-1m(@a) when (@a = 1) {
+  .failed {
+    one-hundred: not-equal-to-1;
+  }
+}
+.bug-100cm-1m(100cm);
+
+#ns {
+    .mixin-for-root-usage(@a) when (@a > 0) {
+        .mixin-generated-class {
+            a: @a;
+        }
+    }
+}
+
+#ns > .mixin-for-root-usage(1);
+
+@namespaceGuard: 1;
+#guarded when (@namespaceGuard>0) {
+  #deeper {
+    .mixin() {
+      guarded: namespace;
+    }
+  }
+}
+#guarded() when (@namespaceGuard>0) {
+  #deeper {
+    .mixin() {
+      silent: namespace;
+    }
+  }
+}
+#guarded(@variable) when (@namespaceGuard>0) {
+  #deeper {
+    .mixin() {
+      should: not match because namespace argument;
+    }
+  }
+}
+#guarded(@variable: default) when (@namespaceGuard>0) {
+  #deeper {
+    .mixin() {
+      guarded: with default;
+    }
+  }
+}
+#guarded when (@namespaceGuard<0) {
+  #deeper {
+    .mixin() {
+      should: not match because namespace guard;
+    }
+  }
+}
+#guarded-caller {
+  #guarded > #deeper > .mixin();
+}
+#top {
+  #deeper when (@namespaceGuard<0) {
+    .mixin(@a) {
+      should: not match because namespace guard;
+    }
+  }
+  #deeper() when (@namespaceGuard>0) {
+    .mixin(@a) {
+      should: match @a;
+    }
+  }
+}
+#guarded-deeper {
+  #top > #deeper > .mixin(1);
+}

package/test/less-bom/mixins-important.less

@@ -0,0 +1,37 @@
+.submixin(@a) {
+  border-width: @a;
+}
+.mixin (9) {
+  border: 9 !important;
+}
+.mixin (@a: 0) {
+  border: @a;
+  boxer: @a;
+  .inner {
+    test: @a;
+  }
+  // comment
+  .submixin(@a);
+}
+
+.class {
+  .mixin(1);
+  .mixin(2) !important;
+  .mixin(3);
+  .mixin(4) !important;
+  .mixin(5);
+  .mixin !important;
+  .mixin(9);
+}
+.size(@aaa: auto) {
+  .set-width(@aaa) {
+    width: @aaa;
+  }
+  .set-width(@aaa);
+}
+.when-calling-nested-issue-2394 {
+  .size() !important;
+}
+.when-calling-nested-with-param-issue-2394 {
+  .size(10px) !important;
+}

package/test/less-bom/mixins-interpolated.less

@@ -0,0 +1,75 @@
+
+@a0: 123;
+@a1: foo;
+@a2: ~".foo";
+@a4: ~"#foo";
+
+.@{a0} {
+    a: 0;
+}
+
+.@{a1} {
+    a: 1;
+}
+
+@{a2} {
+    a: 2;
+}
+
+#@{a1} {
+    a: 3;
+}
+
+@{a4} {
+    a: 4;
+}
+
+mi-test-a {
+    .123;
+    .foo;
+    #foo;
+}
+
+.b .bb {
+    &.@{a1}-xxx .yyy-@{a1}@{a4} {
+        & @{a2}.bbb {
+            b: 1;
+        }
+    }
+}
+
+mi-test-b {
+    .b.bb.foo-xxx.yyy-foo#foo.foo.bbb;
+}
+
+@c1: @a1;
+@c2: bar;
+@c3: baz;
+
+#@{c1}-foo {
+    > .@{c2} {
+        .@{c3} {
+            c: c;
+        }
+    }
+}
+
+mi-test-c {
+    &-1 {#foo-foo;}
+    &-2 {#foo-foo > .bar;}
+    &-3 {#foo-foo > .bar.baz;}
+}
+
+.Person(@name, @gender_) {
+    .@{name} {
+        @gender: @gender_;
+        .sayGender() {
+            gender: @gender;
+        }
+    }
+}
+
+mi-test-d {
+    .Person(person, "Male");
+    .person.sayGender();
+}

package/test/less-bom/mixins-named-args.less

@@ -0,0 +1,36 @@
+.mixin (@a: 1px, @b: 50%) {
+  width: (@a * 5);
+  height: (@b - 1%);
+  args: @arguments;
+}
+.mixin (@a: 1px, @b: 50%) when (@b > 75%){
+  text-align: center;
+}
+
+.named-arg {
+  color: blue;
+  .mixin(@b: 100%);
+}
+
+.class {
+  @var: 20%;
+  .mixin(@b: @var);
+}
+
+.all-args-wrong-args {
+  .mixin(@b: 10%, @a: 2px);
+}
+
+.mixin2 (@a: 1px, @b: 50%, @c: 50) {
+  width: (@a * 5);
+  height: (@b - 1%);
+  color: (#000000 + @c);
+}
+
+.named-args2 {
+  .mixin2(3px, @c: 100);
+}
+
+.named-args3 {
+  .mixin2(@b: 30%, @c: #123456);
+}

package/test/less-bom/mixins-nested.less

@@ -0,0 +1,22 @@
+.mix-inner (@var) {
+  border-width: @var;
+}
+
+.mix (@a: 10) {
+  .inner {
+    height: (@a * 10);
+
+    .innest {
+      width: @a;
+      .mix-inner((@a * 2));
+    }
+  }
+}
+
+.class {
+  .mix(30);
+}
+
+.class2 {
+  .mix(60);
+}