sass-list-maps 0.9.9 → 1.0.0
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.
- checksums.yaml +4 -4
- data/README.md +30 -16
- data/_sass-list-maps.scss +434 -87
- metadata +8 -7
checksums.yaml
CHANGED
|
@@ -1,7 +1,7 @@
|
|
|
1
1
|
---
|
|
2
2
|
SHA1:
|
|
3
|
-
metadata.gz:
|
|
4
|
-
data.tar.gz:
|
|
3
|
+
metadata.gz: 4cdb2fd397cd4a3805836350c1e574d9956b3c8c
|
|
4
|
+
data.tar.gz: 544594422b60254ab7f37371d94cad608d9f74f8
|
|
5
5
|
SHA512:
|
|
6
|
-
metadata.gz:
|
|
7
|
-
data.tar.gz:
|
|
6
|
+
metadata.gz: d20eb2fa1bec7f96d1e9f618754f6ec4ae21595826f6556109bbc87dd2cae4cf9c213e7688d93c697af0753e1e3a3abc2aab5ff97f5f47d471e6102deaef731a
|
|
7
|
+
data.tar.gz: 3252ce935c5396903ff6324e02e37b92a00964bf6537e66a0cf149ddede15410112760a00c7101f5a6259b4ad49ef1bc10d026a43e919e6fbd025ea686b61e4d
|
data/README.md
CHANGED
|
@@ -1,11 +1,16 @@
|
|
|
1
1
|
## Sass List–Maps
|
|
2
2
|
|
|
3
|
-
These functions provide forward-compatible map (hash) data-type functionality
|
|
3
|
+
These functions provide a forward-compatible polyfill for SassScript `map` (hash) data-type functionality in [libsass](http://libsass.org/) and [ruby-sass](http://sass-lang.com/) 3.2.x using the `list` data-type. They feature-match all the current native (ruby-sass) `map` functions, and add nested (or 'chained') `get()`, `set()` and `merge()` functions and inspection / debugging functions as well.
|
|
4
4
|
|
|
5
|
-
|
|
5
|
+
#### NB: these functions may soon be obsolete, as [SassScript Maps may soon land in libsass](https://github.com/sass/libsass/pull/481). At that point I will put up a new library that offers the same advanced functions for the native implementation as for this polyfill.
|
|
6
|
+
|
|
7
|
+
|
|
6
8
|
|
|
7
9
|
#### Updates
|
|
8
10
|
|
|
11
|
+
* 1.0.0-b3 -- altered use of `list-map-check()` in `map-get()` and `map-get-z()` functions, to avoid double-wrapped-output edge case
|
|
12
|
+
* 1.0.0-b2 -- updated `map-remove()` function to allow removing multiple keys; conformant to ruby-sass 3.4.
|
|
13
|
+
* 1.0.0-b -- preparing for 1.0; added npm distribution and newly commented source code thanks to Hugo Giraudel. Next version will use SassDoc-style comments.
|
|
9
14
|
* 0.9.9 -- added `map-pretty()` function to inspect/debug list-maps in pretty-printed form
|
|
10
15
|
* 0.9.6-0.9.8 -- argument-handling enhancements; typo fixes
|
|
11
16
|
* 0.9.3-0.9.5 -- handling single-pair lists automatically. This means no more need for `list()` or `zip()` functions, which are now deprecated.
|
|
@@ -14,17 +19,21 @@ These functions provide forward-compatible map (hash) data-type functionality fo
|
|
|
14
19
|
|
|
15
20
|
#### Try it
|
|
16
21
|
|
|
17
|
-
You can test-drive these functions at [Sassmeister, in this pre-loaded gist](http://sassmeister.com/gist/
|
|
22
|
+
You can test-drive these functions at [Sassmeister, in this pre-loaded gist](http://sassmeister.com/gist/4787415116ed1adbc8d9)—but note that the libsass version at Sassmeister might be a couple of point-releases behind this repo.
|
|
18
23
|
|
|
19
24
|
#### Install it
|
|
20
25
|
|
|
21
|
-
'Sass List-Maps' can be installed as a Bower component for non-ruby setups (see [node-sass options](http://github.com/sindresorhus/grunt-sass#includepaths) if you are using libsass via node) or as a gem-based Compass extension for ruby setups:
|
|
26
|
+
'Sass List-Maps' can be installed as a Bower component or NPM module for non-ruby setups (see [node-sass options](http://github.com/sindresorhus/grunt-sass#includepaths) if you are using libsass via node) or as a gem-based Compass extension for ruby setups:
|
|
22
27
|
|
|
23
28
|
```sh
|
|
29
|
+
# installation with npm
|
|
30
|
+
npm install sass-list-maps
|
|
31
|
+
|
|
24
32
|
# installation with bower
|
|
25
33
|
bower install sass-list-maps
|
|
26
34
|
|
|
27
|
-
# if using grunt-sass, you
|
|
35
|
+
# if using grunt-sass, you might want to set 'includePaths'
|
|
36
|
+
# to match install location of bower or npm.
|
|
28
37
|
options: {
|
|
29
38
|
includePaths: [
|
|
30
39
|
'./bower_components/sass-list-maps'
|
|
@@ -42,15 +51,17 @@ You can of course also just fork or download this repo or copy-and-paste, as the
|
|
|
42
51
|
|
|
43
52
|
### Introduction
|
|
44
53
|
|
|
45
|
-
Maps (known in programming as hashes, dictionaries, or objects<sup>1</sup>) allow dynamic creating, setting, merging and retrieving of data. They are native to ruby-sass as of version 3.3.x, but for earlier ruby-sass versions, and for the libsass C-based compiler (until the point at which maps are integrated there natively), this is an alternative solution which feature-matches ruby-sass' 3.3.x map functionality using the `list` data-type.
|
|
54
|
+
Maps (known in programming as hashes, dictionaries, or objects<sup>1</sup>) allow dynamic creating, setting, merging and retrieving of data. They are native to ruby-sass as of version 3.3.x, but for earlier ruby-sass versions, and for the libsass C-based compiler (until the point at which maps are integrated there natively), this is an alternative solution which feature-matches ruby-sass' 3.3.x map functionality using the `list` data-type.
|
|
55
|
+
|
|
56
|
+
Some additional functions are also provided to allow nested (chained) getting and merging/setting, and inspection for debugging.
|
|
46
57
|
|
|
47
58
|
*<sup>1</sup>objects (as in javascript) are not exactly the same thing as maps and hashes, but for these purposes close enough.*
|
|
48
59
|
|
|
49
60
|
#### Syntax
|
|
50
61
|
|
|
51
|
-
Compared to ruby-sass' native maps, 'list-maps' are lists like any other list in Sass, but they are *lists of pairs*, formatted in such a way as to be interpreted like a map. To this purpose, the first item in each pair is interpreted as the 'key'
|
|
62
|
+
Compared to ruby-sass' native maps, 'list-maps' are lists like any other list in Sass, but they are *lists of pairs*, formatted in such a way as to be interpreted like a map. To this purpose, the first item in each pair is interpreted as the 'key', while the second is interpreted as the correspondent 'value'. This 'value' can be any Sass-script data-type, including a list—which means list-maps can contain other list-maps, allowing them to form nested data structures. The formatting used here keeps as close as possible to the syntax of native maps, with the difference that there no colons (`:`) used.
|
|
52
63
|
|
|
53
|
-
|
|
64
|
+
*NB: in ruby-sass 3.2.x or lower, the placement of commas is also very critical (no comma after the last item); but in libsass as of 2.0 you can put commas after each item if you wish.*
|
|
54
65
|
|
|
55
66
|
```scss
|
|
56
67
|
/* a single-line list-map -- compatible with any
|
|
@@ -81,11 +92,11 @@ s$native-map-z: (
|
|
|
81
92
|
);
|
|
82
93
|
```
|
|
83
94
|
|
|
84
|
-
It should be clear that
|
|
95
|
+
It should be clear that 'list-maps' and ruby-sass 'native' maps are very similar—in fact, they are in principle the same. For this reason it was possible to reverse engineer the map functions of ruby-sass' 3.3+ to use the SassScript `list` data-type. Moreover, as with native maps in ruby-sass, list functions (e.g. `nth()`, `index()`) can be used on list-maps, since they are still lists.
|
|
85
96
|
|
|
86
97
|
### The Functions
|
|
87
98
|
|
|
88
|
-
These functions have the same names as the map functions in ruby-sass >= 3.3.x, which means that if they were used in ruby-sass 3.3.x or higher they would conflict. Therefore, the following code assume
|
|
99
|
+
These functions have the same names as the built-in map functions in ruby-sass >= 3.3.x, which means that if they were used in ruby-sass 3.3.x or higher they would conflict with (or at least overwrite) the built-in ones. Therefore, the following code assume you are using either ruby-sass 3.2.x or earlier, or libsass (currently 2.1b).
|
|
89
100
|
|
|
90
101
|
#### Core (matching the ruby-sass 3.3.x native map functions)
|
|
91
102
|
|
|
@@ -132,7 +143,7 @@ $short-map: map-remove($list-map, alpha);
|
|
|
132
143
|
// -> $short-map = ( beta 2, gamma 3)
|
|
133
144
|
```
|
|
134
145
|
|
|
135
|
-
**NB**: you might notice in the second example above, that the second argument to map-merge isn't really a 'list-map' it's just a list of two items. This is the so-called "single item" list conundrum in Sass
|
|
146
|
+
**NB**: you might notice in the second example above, that the second argument to map-merge isn't really a 'list-map' it's just a list of two items. This is the so-called "single item" list conundrum in Sass. As of v0.9.5 these functions handle this type of input so the API can mimic the native syntax as closely as possible.
|
|
136
147
|
|
|
137
148
|
#### Advanced (beyond the ruby-sass 3.3.x native map functions)
|
|
138
149
|
|
|
@@ -262,17 +273,20 @@ Since the 'advanced' nested/chained `map-get-z()` and `map-merge-z()` take a var
|
|
|
262
273
|
|
|
263
274
|
There are a few points that bear mentioning/repeating:
|
|
264
275
|
|
|
265
|
-
* operating on global variables in libsass and in ruby-sass 3.2.x or earlier
|
|
266
|
-
*
|
|
267
|
-
*
|
|
276
|
+
* operating on global variables in libsass and in ruby-sass 3.2.x or earlier works differently than in 3.3.x and later: You can make changes to global variables from inside a mixin scope but you can't create them from there. There is no `!global` flag. This has implications for how you declare and change global variables.
|
|
277
|
+
* there is no error-checking for the data-type itself (e.g. native maps will produce a warning if you have duplicate keys).
|
|
278
|
+
* special features of native maps in ruby-sass, such as passing a map to a function in the form `my-function($map...)` whereupon you can reference the key/value pairs inside the function as if they were named variables, doesn't work here.
|
|
279
|
+
* as noted, the 'list-map' syntax is in ruby-sass 3.2.x or earlier is still less forgiving than that of native maps (watch your commas), but it's a bit more easygoing in libsass, which is the more likely use-case.
|
|
280
|
+
* as of this writing, this code contains no test-suites or inline error-catches or warnings of any kind. I've been using it in my own work and incrementally optimizing it, but I welcome reports and contributions!
|
|
268
281
|
|
|
269
282
|
### To-Dos
|
|
270
283
|
|
|
271
|
-
*
|
|
284
|
+
* Push a SassDoc documented version (this will be 1.0.0 final)
|
|
285
|
+
* Implement an error/warning system (probably 1.1.0)
|
|
272
286
|
* Push a native maps version of the 'advanced' functions above
|
|
273
287
|
|
|
274
288
|
### Acknowledgements
|
|
275
289
|
|
|
276
290
|
First and foremost, gratitude to the core Sass devs (@nex3 and @chriseppstein) for their tireless advancement of the gold-standard of CSS pre-processing, and secondly to @jedfoster and @anotheruiguy for [Sassmeister](http://sassmeister.com/), which makes developing complex functions and mixins relatively painless.
|
|
277
291
|
|
|
278
|
-
Also acknowledgements to @HugoGiraudel for [SassyLists](http://sassylists.com/), from which I adapted some early functions, and especially for his list `debug()` function, without which I would not have been able to figure out what was going on (and going wrong) in ruby-sass 3.2.x and libsass.
|
|
292
|
+
Also acknowledgements to @HugoGiraudel for [SassyLists](http://sassylists.com/), from which I adapted some early functions, and especially for his list `debug()` function, without which I would not have been able to figure out what was going on (and going wrong) in ruby-sass 3.2.x and libsass.
|
data/_sass-list-maps.scss
CHANGED
|
@@ -1,175 +1,522 @@
|
|
|
1
|
-
//
|
|
2
|
-
//
|
|
3
|
-
//
|
|
1
|
+
// Sass List-Maps 1.0.0-b3
|
|
2
|
+
// a libsass polyfill for rubysass "maps" data-type -- using lists
|
|
3
|
+
// by @lunelson
|
|
4
|
+
// MIT License
|
|
4
5
|
|
|
5
|
-
|
|
6
|
-
|
|
7
|
-
|
|
8
|
-
|
|
9
|
-
|
|
10
|
-
|
|
6
|
+
// 88 88 88 88
|
|
7
|
+
// ,d "" 88 "" ,d ""
|
|
8
|
+
// 88 88 88
|
|
9
|
+
// 88 88 MM88MMM 88 88 88 MM88MMM 88 ,adPPYba, ,adPPYba,
|
|
10
|
+
// 88 88 88 88 88 88 88 88 a8P_____88 I8[ ""
|
|
11
|
+
// 88 88 88 88 88 88 88 88 8PP""""""" `"Y8ba,
|
|
12
|
+
// "8a, ,a88 88, 88 88 88 88, 88 "8b, ,aa aa ]8I
|
|
13
|
+
// `"YbbdP'Y8 "Y888 88 88 88 "Y888 88 `"Ybbd8"' `"YbbdP"'
|
|
14
|
+
//
|
|
15
|
+
|
|
16
|
+
///////////////////////////
|
|
17
|
+
// list helper functions //
|
|
18
|
+
///////////////////////////
|
|
19
|
+
|
|
20
|
+
// list-slice(): return a sub-list from a list, 'sliced' from/to given indices
|
|
21
|
+
// ---
|
|
22
|
+
// @alias slice()
|
|
23
|
+
// ---
|
|
24
|
+
// @param [list] $list: list to slice
|
|
25
|
+
// @param [number] $start (1): start index
|
|
26
|
+
// @param [number] $end (length($list)): end index
|
|
27
|
+
// @param [string] $sep ('comma'): default list separator
|
|
28
|
+
// ---
|
|
29
|
+
// @return [list]
|
|
30
|
+
@function list-slice($list, $start: 1, $end: length($list), $sep: 'comma') {
|
|
11
31
|
$output: ();
|
|
12
32
|
@for $i from $start through $end {
|
|
13
33
|
$output: append($output, nth($list, $i), $sep); }
|
|
14
34
|
@return $output;
|
|
15
35
|
}
|
|
16
|
-
|
|
17
|
-
|
|
18
|
-
|
|
19
|
-
|
|
36
|
+
// alias
|
|
37
|
+
@function slice($args...) { @return list-slice($args...); }
|
|
38
|
+
|
|
39
|
+
// list-set-nth(): return a list with value at index set/updated to new value
|
|
40
|
+
// ---
|
|
41
|
+
// @alias set-nth()
|
|
42
|
+
// ---
|
|
43
|
+
// @param [list] $list: list to set
|
|
44
|
+
// @param [number] $index: index to set
|
|
45
|
+
// @param [literal] $value: new value
|
|
46
|
+
// @param [string] $sep ('comma'): list separator
|
|
47
|
+
// ---
|
|
48
|
+
// @return [list]
|
|
49
|
+
@function list-set-nth($list, $index, $value, $sep: 'comma') {
|
|
50
|
+
$length: length($list);
|
|
51
|
+
$output: ();
|
|
52
|
+
@if $index > $length or $index <= 0 {
|
|
53
|
+
@return $list;
|
|
54
|
+
}
|
|
55
|
+
@if $index > 1 {
|
|
56
|
+
@for $i from 1 through $index - 1 {
|
|
57
|
+
$output: append($output, nth($list, $i), $sep);
|
|
58
|
+
}
|
|
59
|
+
}
|
|
20
60
|
$output: append($output, $value, $sep);
|
|
21
|
-
@if $length > 1 {
|
|
61
|
+
@if $length > 1 {
|
|
62
|
+
@for $i from $index + 1 through $length {
|
|
63
|
+
$output: append($output, nth($list, $i), $sep);
|
|
64
|
+
}
|
|
65
|
+
}
|
|
22
66
|
@return $output;
|
|
23
67
|
}
|
|
68
|
+
// alias
|
|
69
|
+
@function set-nth($args...) { @return list-set-nth($args...); }
|
|
24
70
|
|
|
25
|
-
|
|
26
|
-
//
|
|
27
|
-
|
|
71
|
+
///////////////////////////////
|
|
72
|
+
// list-map helper functions //
|
|
73
|
+
///////////////////////////////
|
|
28
74
|
|
|
29
|
-
|
|
30
|
-
|
|
75
|
+
// tuple-key(): return the key (first value) from a tuple (pair)
|
|
76
|
+
// ---
|
|
77
|
+
// @alias key()
|
|
78
|
+
// ---
|
|
79
|
+
// [0.9.3] added alias
|
|
80
|
+
// ---
|
|
81
|
+
// @param [list] $tuple: pair (list of length 2), to extract key from
|
|
82
|
+
// ---
|
|
83
|
+
// @return [literal]
|
|
84
|
+
@function tuple-key($tuple) {
|
|
85
|
+
@if length($tuple) < 1 { @return null; }
|
|
86
|
+
@return nth($tuple, 1);
|
|
87
|
+
}
|
|
88
|
+
// alias
|
|
31
89
|
@function key($tuple) { @return tuple-key($tuple); }
|
|
90
|
+
|
|
91
|
+
// tuple-value(): return the value (second value) from a tuple (pair)
|
|
92
|
+
// ---
|
|
93
|
+
// @alias value()
|
|
94
|
+
// ---
|
|
95
|
+
// [0.9.3] added alias
|
|
96
|
+
// ---
|
|
97
|
+
// @param [list] $tuple: pair (list of length 2), to extract value from
|
|
98
|
+
// ---
|
|
99
|
+
// @return [literal]
|
|
100
|
+
@function tuple-value($tuple) {
|
|
101
|
+
@if length($tuple) < 2 { @return null; }
|
|
102
|
+
@return nth($tuple, 2);
|
|
103
|
+
}
|
|
104
|
+
// alias
|
|
32
105
|
@function value($tuple) { @return tuple-value($tuple); }
|
|
33
106
|
|
|
34
|
-
//
|
|
107
|
+
// list-map-check(): return list-map from list; ensure input list-maps are lists-of-lists
|
|
108
|
+
// ---
|
|
109
|
+
// [0.9.5] added; replaces use of 'list()' function
|
|
110
|
+
// @param [list] $list: list-map to check
|
|
111
|
+
// ---
|
|
112
|
+
// @return [list]
|
|
113
|
+
@function list-map-check($list) {
|
|
114
|
+
@if length($list) == 2 and length(nth($list, 1)) == 1 {
|
|
115
|
+
@return append((), $list, 'comma');
|
|
116
|
+
}
|
|
117
|
+
@return $list;
|
|
118
|
+
}
|
|
35
119
|
|
|
36
|
-
|
|
120
|
+
//
|
|
121
|
+
// ,adPPYba, ,adPPYba, 8b,dPPYba, ,adPPYba,
|
|
122
|
+
// a8" "" a8" "8a 88P' "Y8 a8P_____88
|
|
123
|
+
// 8b 8b d8 88 8PP"""""""
|
|
124
|
+
// "8a, ,aa "8a, ,a8" 88 "8b, ,aa
|
|
125
|
+
// `"Ybbd8"' `"YbbdP"' 88 `"Ybbd8"'
|
|
126
|
+
//
|
|
37
127
|
|
|
38
|
-
|
|
39
|
-
//
|
|
40
|
-
|
|
128
|
+
/////////////////////////////////////////////////////////////////////////
|
|
129
|
+
// list-map versions of map-keys(), -values() and -has-key() functions //
|
|
130
|
+
/////////////////////////////////////////////////////////////////////////
|
|
41
131
|
|
|
132
|
+
// map-keys(): return comma-separated list of keys from map [conformant with rubysass map-keys()]
|
|
133
|
+
// ---
|
|
134
|
+
// @alias keys()
|
|
135
|
+
// ---
|
|
136
|
+
// [0.9.5] use list-map-check to handle single pairs automatically
|
|
137
|
+
// ---
|
|
138
|
+
// @param [argList] $list: list to retrieve keys from
|
|
139
|
+
// ---
|
|
140
|
+
// @return [list]
|
|
42
141
|
@function map-keys($list...) {
|
|
43
|
-
|
|
44
|
-
|
|
45
|
-
@each $tuple in $list {
|
|
142
|
+
$list: if(length($list) == 1, list-map-check($list...), list-map-check($list));
|
|
143
|
+
$output: ();
|
|
144
|
+
@each $tuple in $list {
|
|
145
|
+
$output: append($output, tuple-key($tuple), 'comma');
|
|
146
|
+
}
|
|
46
147
|
@return $output;
|
|
47
148
|
}
|
|
149
|
+
// alias
|
|
150
|
+
@function keys($list...) { @return map-keys($list...); }
|
|
151
|
+
|
|
152
|
+
// map-values(): return comma-separated list of values from map [conformant with rubysass map-values()]
|
|
153
|
+
// ---
|
|
154
|
+
// @alias values()
|
|
155
|
+
// ---
|
|
156
|
+
// [0.9.5] use list-map-check to handle single pairs automatically
|
|
157
|
+
// ---
|
|
158
|
+
// @param [argList] $list: list to retrieve values from
|
|
159
|
+
// ---
|
|
160
|
+
// @return [list]
|
|
48
161
|
@function map-values($list...) {
|
|
49
|
-
|
|
50
|
-
|
|
51
|
-
@each $tuple in $list {
|
|
162
|
+
$list: if(length($list) == 1, list-map-check($list...), list-map-check($list));
|
|
163
|
+
$output: ();
|
|
164
|
+
@each $tuple in $list {
|
|
165
|
+
$output: append($output, tuple-value($tuple), 'comma');
|
|
166
|
+
}
|
|
52
167
|
@return $output;
|
|
53
168
|
}
|
|
169
|
+
// alias
|
|
170
|
+
@function values($list...) { @return map-values($list...); }
|
|
171
|
+
|
|
172
|
+
// map-has-key(): check whether key exists in map at root level [conformant with rubysass map-has-key()]
|
|
173
|
+
// ---
|
|
174
|
+
// @alias has-key()
|
|
175
|
+
// ---
|
|
176
|
+
// @param [list] $list: list to check
|
|
177
|
+
// @param [literal] $key: key to check in list
|
|
178
|
+
// ---
|
|
179
|
+
// @return [bool]
|
|
54
180
|
@function map-has-key($list, $key) {
|
|
55
181
|
$list: list-map-check($list);
|
|
56
|
-
@each $tuple in $list {
|
|
182
|
+
@each $tuple in $list {
|
|
183
|
+
@if tuple-key($tuple) == $key {
|
|
184
|
+
@return true;
|
|
185
|
+
}
|
|
186
|
+
}
|
|
57
187
|
@return false;
|
|
58
188
|
}
|
|
59
|
-
|
|
60
|
-
|
|
61
|
-
@return nth($keys, index($keys, $key) - 1);
|
|
62
|
-
}
|
|
63
|
-
@function map-next-key($list, $key) {
|
|
64
|
-
$list: list-map-check($list); $keys: map-keys($list);
|
|
65
|
-
@return nth($keys, index($keys, $key) + 1);
|
|
66
|
-
}
|
|
189
|
+
// alias
|
|
190
|
+
@function has-key($list, $key) { @return map-has-key($list, $key); }
|
|
67
191
|
|
|
68
|
-
|
|
69
|
-
//
|
|
192
|
+
////////////////////////////////////////////////////////////
|
|
193
|
+
// list-map versions of map-get(), -merge() and -remove() //
|
|
194
|
+
////////////////////////////////////////////////////////////
|
|
70
195
|
|
|
71
|
-
|
|
72
|
-
|
|
73
|
-
|
|
74
|
-
|
|
196
|
+
// map-get(): return value corresponding to key in map; conformant to rubysass map-get()
|
|
197
|
+
// ---
|
|
198
|
+
// [0.9.5] list-map-check() now handles single-pair inputs / outputs
|
|
199
|
+
// ---
|
|
200
|
+
// @param [list] $list: map
|
|
201
|
+
// @param [literal] $key: key by which to look up value
|
|
202
|
+
// @param [bool] $check (true): whether or not to check the map format first
|
|
203
|
+
// ---
|
|
204
|
+
// @return [literal] | [null]
|
|
205
|
+
@function map-get($list, $key) {
|
|
206
|
+
$list: list-map-check($list);
|
|
207
|
+
@each $tuple in $list {
|
|
208
|
+
@if tuple-key($tuple) == $key {
|
|
209
|
+
@return tuple-value($tuple);
|
|
210
|
+
}
|
|
211
|
+
}
|
|
75
212
|
@return null;
|
|
76
213
|
}
|
|
214
|
+
|
|
215
|
+
// map-merge(): return a merge of second map in to first map; conformant to rubysass map-merge()
|
|
216
|
+
// ---
|
|
217
|
+
// [0.9.5] list-map-check() handles single pairs; $check param for internal use
|
|
218
|
+
// ---
|
|
219
|
+
// @param [list] $list1: first map
|
|
220
|
+
// @param [list] $list2: second map
|
|
221
|
+
// @param [bool] $check (true): whether or not to check the map first
|
|
222
|
+
// ---
|
|
223
|
+
// @return [list]
|
|
77
224
|
@function map-merge($list1, $list2, $check: true) {
|
|
78
|
-
@if $check {
|
|
225
|
+
@if $check {
|
|
226
|
+
$list1: list-map-check($list1);
|
|
227
|
+
$list2: list-map-check($list2);
|
|
228
|
+
}
|
|
79
229
|
$keys1: map-keys($list1);
|
|
80
230
|
@each $tuple in $list2 {
|
|
81
231
|
$index: index($keys1, tuple-key($tuple));
|
|
82
232
|
@if $index { $list1: set-nth($list1, $index, $tuple); }
|
|
83
|
-
@else { $list1: append($list1, $tuple, 'comma'); }
|
|
233
|
+
@else { $list1: append($list1, $tuple, 'comma'); }
|
|
234
|
+
}
|
|
84
235
|
@return $list1;
|
|
85
236
|
}
|
|
86
|
-
|
|
237
|
+
|
|
238
|
+
// map-remove(): return map with tuples removed, according to keys (if found); conformant to rubysass 3.4 map-remove()
|
|
239
|
+
// ---
|
|
240
|
+
// @param [list] $list: map
|
|
241
|
+
// @param [literal] $key: key
|
|
242
|
+
// ---
|
|
243
|
+
// @return [list]
|
|
244
|
+
@function map-remove($list, $keys...) {
|
|
87
245
|
$list: list-map-check($list);
|
|
88
|
-
$
|
|
89
|
-
@
|
|
90
|
-
@if
|
|
246
|
+
$output: ();
|
|
247
|
+
@each $tuple in $list {
|
|
248
|
+
@if index($keys, tuple-key($tuple)) == false {
|
|
249
|
+
$output: append($output, $tuple, 'comma');
|
|
250
|
+
}
|
|
251
|
+
}
|
|
91
252
|
@return $output;
|
|
92
253
|
}
|
|
93
254
|
|
|
94
|
-
//
|
|
95
|
-
//
|
|
255
|
+
//
|
|
256
|
+
// 88 88
|
|
257
|
+
// 88 88
|
|
258
|
+
// 88 88
|
|
259
|
+
// ,adPPYYba, ,adPPYb,88 8b d8 ,adPPYYba, 8b,dPPYba, ,adPPYba, ,adPPYba, ,adPPYb,88
|
|
260
|
+
// "" `Y8 a8" `Y88 `8b d8' "" `Y8 88P' `"8a a8" "" a8P_____88 a8" `Y88
|
|
261
|
+
// ,adPPPPP88 8b 88 `8b d8' ,adPPPPP88 88 88 8b 8PP""""""" 8b 88
|
|
262
|
+
// 88, ,88 "8a, ,d88 `8b,d8' 88, ,88 88 88 "8a, ,aa "8b, ,aa "8a, ,d88
|
|
263
|
+
// `"8bbdP"Y8 `"8bbdP"Y8 "8" `"8bbdP"Y8 88 88 `"Ybbd8"' `"Ybbd8"' `"8bbdP"Y8
|
|
264
|
+
//
|
|
265
|
+
|
|
266
|
+
//////////////////////////////////////////////////////////////
|
|
267
|
+
// deep/nested map functions: map-get-z() and map-merge-z() //
|
|
268
|
+
//////////////////////////////////////////////////////////////
|
|
96
269
|
|
|
270
|
+
// map-get-z(): a 'deep', nested or chained version of `map-get` (see above); unique
|
|
271
|
+
// ---
|
|
272
|
+
// [0.9.5] now uses list-map-check to handle single-pair list-maps
|
|
273
|
+
// [0.9.2] aliased to get(); can replace map-get() and map-get-z() in usage
|
|
274
|
+
// ---
|
|
275
|
+
// @alias get()
|
|
276
|
+
// ---
|
|
277
|
+
// @param [list] $list: map
|
|
278
|
+
// @param [argList] $keys: nested / chained key list (where to get value)
|
|
279
|
+
// ---
|
|
280
|
+
// @return [literal] | [null]
|
|
97
281
|
@function map-get-z($list, $keys...) {
|
|
98
|
-
@if $list == null { @return
|
|
282
|
+
@if $list == null { @return $list; }
|
|
99
283
|
$length: length($keys);
|
|
100
284
|
$list: map-get($list, nth($keys, 1));
|
|
101
285
|
@if $length > 1 {
|
|
102
286
|
@for $n from 2 through $length {
|
|
103
|
-
@if $list == null { @return
|
|
104
|
-
$list: map-get($list, nth($keys, $n)
|
|
105
|
-
|
|
106
|
-
|
|
287
|
+
@if $list == null { @return $list; }
|
|
288
|
+
$list: map-get($list, nth($keys, $n));
|
|
289
|
+
}
|
|
290
|
+
@return $list;
|
|
291
|
+
}
|
|
292
|
+
@return $list;
|
|
107
293
|
}
|
|
294
|
+
// alias
|
|
295
|
+
@function get($args...) { @return map-get-z($args...); }
|
|
296
|
+
|
|
297
|
+
// map-merge-z(): a 'deep', nested or chained version of `map-merge`; offers `map-set` syntax too
|
|
298
|
+
// ---
|
|
299
|
+
// [0.9.5] now uses list-map-check to handle single-pair list-maps
|
|
300
|
+
// [0.9.2] aliased to merge() and set(); can replace map-merge() and map-merge-z() in usage
|
|
301
|
+
// ---
|
|
302
|
+
// @alias merge(), set()
|
|
303
|
+
// ---
|
|
304
|
+
// @param [list] $list: map
|
|
305
|
+
// @param [argList] $keys-and-values: nested / chained key list (where to merge value); final item in list is the value to be merged
|
|
306
|
+
// ---
|
|
307
|
+
// @return [list]
|
|
108
308
|
@function map-merge-z($list, $keys-and-value...) {
|
|
109
309
|
$arg-length: length($keys-and-value);
|
|
110
310
|
$value: nth($keys-and-value, $arg-length);
|
|
111
311
|
$key-length: $arg-length - 1;
|
|
112
312
|
$list: list-map-check($list);
|
|
113
313
|
@if $key-length == 0 {
|
|
114
|
-
$value: if(type-of($value) == 'list', map-merge($list, list-map-check($value), false), map-merge($list, append((), $value (), 'comma'), false));
|
|
115
|
-
|
|
314
|
+
$value: if(type-of($value) == 'list', map-merge($list, list-map-check($value), false), map-merge($list, append((), $value (), 'comma'), false));
|
|
315
|
+
}
|
|
316
|
+
@else {
|
|
317
|
+
$start: 1;
|
|
318
|
+
@if type-of($value) == 'list' {
|
|
319
|
+
$start: 0;
|
|
320
|
+
$value: list-map-check($value);
|
|
321
|
+
}
|
|
116
322
|
@for $i from $start through $key-length {
|
|
117
323
|
$new-list: (); $old-list: ();
|
|
118
|
-
@if $i == 0 { $new-list: $value; }
|
|
119
|
-
@
|
|
120
|
-
$
|
|
324
|
+
@if $i == 0 { $new-list: $value; }
|
|
325
|
+
@else { $new-list: append((), nth($keys-and-value, $key-length + 1 - $i) $value, 'comma'); }
|
|
326
|
+
@if $i == $key-length { $old-list: $list; }
|
|
327
|
+
@else { $old-list: map-get-z($list, slice($keys-and-value, 1, $key-length - $i)...) or (); }
|
|
328
|
+
$value: map-merge($old-list, $new-list);
|
|
329
|
+
}
|
|
330
|
+
}
|
|
121
331
|
@return $value;
|
|
122
332
|
}
|
|
123
|
-
|
|
124
|
-
// aliases added as of 0.9.2: unify and replace map-*() and map-*-z() variants
|
|
125
|
-
|
|
126
|
-
@function get($args...) { @return map-get-z($args...); }
|
|
333
|
+
// aliases
|
|
127
334
|
@function merge($args...) { @return map-merge-z($args...); }
|
|
128
335
|
@function set($args...) { @return map-merge-z($args...); }
|
|
129
336
|
|
|
130
|
-
//
|
|
337
|
+
//
|
|
338
|
+
// ,d
|
|
339
|
+
// 88
|
|
340
|
+
// ,adPPYba, 8b, ,d8 MM88MMM 8b,dPPYba, ,adPPYYba, ,adPPYba,
|
|
341
|
+
// a8P_____88 `Y8, ,8P' 88 88P' "Y8 "" `Y8 I8[ ""
|
|
342
|
+
// 8PP""""""" )888( 88 88 ,adPPPPP88 `"Y8ba,
|
|
343
|
+
// "8b, ,aa ,d8" "8b, 88, 88 88, ,88 aa ]8I
|
|
344
|
+
// `"Ybbd8"' 8P' `Y8 "Y888 88 `"8bbdP"Y8 `"YbbdP"'
|
|
345
|
+
//
|
|
346
|
+
|
|
347
|
+
/////////////////////////////////////
|
|
348
|
+
// additional map helper functions //
|
|
349
|
+
/////////////////////////////////////
|
|
350
|
+
|
|
351
|
+
// map-prev-key(): return previous key from map
|
|
352
|
+
// ---
|
|
353
|
+
// [0.9.5] added
|
|
354
|
+
// ---
|
|
355
|
+
// @alias prev-key()
|
|
356
|
+
// ---
|
|
357
|
+
// @param [list] $list: map
|
|
358
|
+
// @param [literal] $key: pivot key
|
|
359
|
+
// ---
|
|
360
|
+
// @return [literal]
|
|
361
|
+
@function map-prev-key($list, $key) {
|
|
362
|
+
$list: list-map-check($list);
|
|
363
|
+
$keys: map-keys($list);
|
|
364
|
+
@return nth($keys, index($keys, $key) - 1);
|
|
365
|
+
}
|
|
366
|
+
// alias
|
|
367
|
+
@function prev-key($list, $key) { @return map-prev-key($list, $key); }
|
|
131
368
|
|
|
369
|
+
// map-next-key(): return next key from map
|
|
370
|
+
// ---
|
|
371
|
+
// [0.9.5] added
|
|
372
|
+
// ---
|
|
373
|
+
// @alias next-key()
|
|
374
|
+
// ---
|
|
375
|
+
// @param [list] $list: map
|
|
376
|
+
// @param [literal] $key: pivot key
|
|
377
|
+
// ---
|
|
378
|
+
// @return [literal]
|
|
379
|
+
@function map-next-key($list, $key) {
|
|
380
|
+
$list: list-map-check($list);
|
|
381
|
+
$keys: map-keys($list);
|
|
382
|
+
@return nth($keys, index($keys, $key) + 1);
|
|
383
|
+
}
|
|
384
|
+
// alias
|
|
385
|
+
@function next-key($list, $key) { @return map-next-key($list, $key); }
|
|
386
|
+
|
|
387
|
+
// map-inspect(): return the string representation of a map
|
|
388
|
+
// ---
|
|
389
|
+
// [0.9.5] added
|
|
390
|
+
// ---
|
|
391
|
+
// @param [argList] $list: map
|
|
392
|
+
// ---
|
|
393
|
+
// @return [string]
|
|
132
394
|
@function map-inspect($list...) {
|
|
133
|
-
|
|
134
|
-
|
|
135
|
-
$
|
|
395
|
+
$list: if(length($list) == 1, list-map-check($list...), list-map-check($list));
|
|
396
|
+
$output: '(';
|
|
397
|
+
$i: 1;
|
|
136
398
|
@each $tuple in $list {
|
|
137
399
|
@if length($tuple) != 2 {
|
|
138
|
-
$output: $output + '#{$tuple}';
|
|
400
|
+
$output: $output + '#{$tuple}';
|
|
401
|
+
}
|
|
139
402
|
@else {
|
|
140
|
-
$key:
|
|
141
|
-
$value:
|
|
142
|
-
|
|
143
|
-
|
|
144
|
-
@if $i < length(map-keys($list)) {
|
|
403
|
+
$key: tuple-key($tuple);
|
|
404
|
+
$value: tuple-value($tuple);
|
|
405
|
+
$output: $output + '#{$key} ' + if(type-of($value) == 'list', '#{map-inspect($value)}', '#{$value}');
|
|
406
|
+
}
|
|
407
|
+
@if $i < length(map-keys($list)) {
|
|
408
|
+
$output: $output + ', ';
|
|
409
|
+
}
|
|
145
410
|
$i: $i + 1;
|
|
146
411
|
}
|
|
147
412
|
@return $output + ')';
|
|
148
413
|
}
|
|
149
414
|
|
|
150
|
-
//
|
|
151
|
-
|
|
415
|
+
// map-pretty(): return the string representation of a map with indents and line breaks
|
|
416
|
+
// ---
|
|
417
|
+
// [0.9.9] added
|
|
418
|
+
// ---
|
|
419
|
+
// @alias map-inspect-pretty()
|
|
420
|
+
// ---
|
|
421
|
+
// @param [list] $list: map
|
|
422
|
+
// @param [number] $level (1): internal variable, do not touch
|
|
423
|
+
// ---
|
|
424
|
+
// @return [string]
|
|
152
425
|
@function map-pretty($list, $level: 1) {
|
|
153
|
-
|
|
154
|
-
|
|
426
|
+
$tab: ' ';
|
|
427
|
+
$cr: '
|
|
428
|
+
';
|
|
429
|
+
$list: if(length($list) == 1, list-map-check($list...), list-map-check($list));
|
|
155
430
|
$indent: $tab; $outdent: $tab;
|
|
156
431
|
@for $n from 1 through $level { $indent: $indent + $tab; }
|
|
157
432
|
@for $n from 1 through $level - 1 { $outdent: $outdent + $tab; }
|
|
158
|
-
$output: '(' + $cr + $indent;
|
|
433
|
+
$output: '(' + $cr + $indent;
|
|
434
|
+
$i: 1;
|
|
159
435
|
@each $tuple in $list {
|
|
160
436
|
@if length($tuple) != 2 {
|
|
161
|
-
$output: $output + '#{$tuple}';
|
|
437
|
+
$output: $output + '#{$tuple}';
|
|
438
|
+
}
|
|
162
439
|
@else {
|
|
163
440
|
$key: nth($tuple, 1); $value: nth($tuple, 2);
|
|
164
441
|
@if type-of($value) == 'list' { $output: $output + '#{$key} #{map-pretty($value, $level+1)}'; }
|
|
165
|
-
@else { $output: $output + '#{$key} #{$value}'; }
|
|
442
|
+
@else { $output: $output + '#{$key} #{$value}'; }
|
|
443
|
+
}
|
|
166
444
|
@if $i < length(map-keys($list)) { $output: $output + ',' + $cr + $indent; }
|
|
167
445
|
$i: $i + 1;
|
|
168
446
|
}
|
|
169
|
-
// @return unquote($output + $cr + $outdent + ')'); // replace last line with this one for unquoted output in libsass
|
|
170
447
|
@return $output + $cr + $outdent + ')';
|
|
171
448
|
}
|
|
172
|
-
// aliases
|
|
449
|
+
// aliases
|
|
173
450
|
@function map-inspect-pretty($list...) { @return map-pretty($list...); }
|
|
174
|
-
@function map-inspect-p($list...) { @return map-pretty($list...); }
|
|
175
451
|
|
|
452
|
+
// map-sort(): return sorted list-map, based on values at given key(s)
|
|
453
|
+
// ---
|
|
454
|
+
// [0.9.9] added
|
|
455
|
+
//
|
|
456
|
+
// @param [list] $list: map
|
|
457
|
+
// @param [argList] $keys: nested / chained key list
|
|
458
|
+
// ---
|
|
459
|
+
// @return [list]
|
|
460
|
+
$list-map-sort-dir: 'asc'; // global sort dir variable
|
|
461
|
+
@function map-sort($list-map, $keys...) {
|
|
462
|
+
@if length($keys) < 1 { @return $list-map; }
|
|
463
|
+
$list-map: list-map-check($list-map);
|
|
464
|
+
@if length($list-map) > 1 {
|
|
465
|
+
$less: (); $equal: (); $greater: ();
|
|
466
|
+
$seed: nth($list-map, ceil(length($list-map) / 2));
|
|
467
|
+
$seed-value: map-get-z(nth($seed, 2), $keys...);
|
|
468
|
+
@each $item in $list-map {
|
|
469
|
+
$item-value: map-get-z(nth($item, 2), $keys...);
|
|
470
|
+
@if $list-map-sort-dir == 'asc' {
|
|
471
|
+
@if $item-value == $seed-value { $equal: append($equal, $item, 'comma'); }
|
|
472
|
+
@else if $item-value < $seed-value { $less: append($less, $item, 'comma'); }
|
|
473
|
+
@else { $greater: append($greater, $item, 'comma'); }
|
|
474
|
+
}
|
|
475
|
+
@else {
|
|
476
|
+
@if $item-value == $seed-value { $equal: append($equal, $item, 'comma'); }
|
|
477
|
+
@else if $item-value > $seed-value { $less: append($less, $item, 'comma'); }
|
|
478
|
+
@else { $greater: append($greater, $item, 'comma'); }
|
|
479
|
+
}
|
|
480
|
+
}
|
|
481
|
+
@return join(join(map-sort($less, $keys...), $equal), map-sort($greater, $keys...));
|
|
482
|
+
}
|
|
483
|
+
@return $list-map;
|
|
484
|
+
}
|
|
485
|
+
|
|
486
|
+
// map-json(): return json string representation of a map
|
|
487
|
+
// ---
|
|
488
|
+
// [1.0.0] added
|
|
489
|
+
// ---
|
|
490
|
+
// @param [list] $list: map
|
|
491
|
+
// @param [number] $level (1): internal variable, do not touch
|
|
492
|
+
// ---
|
|
493
|
+
// @return [string]
|
|
494
|
+
@function map-json($list...) {
|
|
495
|
+
$list: if(length($list) == 1, list-map-check($list...), list-map-check($list));
|
|
496
|
+
$output: '{ '; $i: 1;
|
|
497
|
+
@each $tuple in $list {
|
|
498
|
+
@if length($tuple) != 2 {
|
|
499
|
+
$output: $output + '#{$tuple}';
|
|
500
|
+
}
|
|
501
|
+
@else {
|
|
502
|
+
$key: nth($tuple, 1);
|
|
503
|
+
$value: nth($tuple, 2);
|
|
504
|
+
@if type-of($value) == 'list' {
|
|
505
|
+
$output: $output + '"#{$key}": #{map-json($value)}';
|
|
506
|
+
}
|
|
507
|
+
@else if type-of($value) == 'number' {
|
|
508
|
+
$value: if(unitless($value), $value, '"#{$value}"');
|
|
509
|
+
$output: $output + '"#{$key}": #{$value}';
|
|
510
|
+
}
|
|
511
|
+
@else {
|
|
512
|
+
$value: if(type-of($value) == 'bool', $value, '"#{$value}"');
|
|
513
|
+
$output: $output + '"#{$key}": #{$value}';
|
|
514
|
+
}
|
|
515
|
+
}
|
|
516
|
+
@if $i < length(map-keys($list)) {
|
|
517
|
+
$output: $output + ', ';
|
|
518
|
+
}
|
|
519
|
+
$i: $i + 1;
|
|
520
|
+
}
|
|
521
|
+
@return $output + ' }';
|
|
522
|
+
}
|
metadata
CHANGED
|
@@ -1,14 +1,14 @@
|
|
|
1
1
|
--- !ruby/object:Gem::Specification
|
|
2
2
|
name: sass-list-maps
|
|
3
3
|
version: !ruby/object:Gem::Version
|
|
4
|
-
version: 0.
|
|
4
|
+
version: 1.0.0
|
|
5
5
|
platform: ruby
|
|
6
6
|
authors:
|
|
7
7
|
- Lu Nelson
|
|
8
8
|
autorequire:
|
|
9
9
|
bindir: bin
|
|
10
10
|
cert_chain: []
|
|
11
|
-
date: 2014-
|
|
11
|
+
date: 2014-09-30 00:00:00.000000000 Z
|
|
12
12
|
dependencies:
|
|
13
13
|
- !ruby/object:Gem::Dependency
|
|
14
14
|
name: compass
|
|
@@ -38,15 +38,15 @@ dependencies:
|
|
|
38
38
|
- - ~>
|
|
39
39
|
- !ruby/object:Gem::Version
|
|
40
40
|
version: 3.2.0
|
|
41
|
-
description:
|
|
42
|
-
|
|
41
|
+
description: Polyfill for map (hash/object) data functionality in libsass and ruby-sass
|
|
42
|
+
< 3.3.x.
|
|
43
43
|
email: lunelson@gmail.com
|
|
44
44
|
executables: []
|
|
45
45
|
extensions: []
|
|
46
46
|
extra_rdoc_files: []
|
|
47
47
|
files:
|
|
48
|
-
- LICENSE
|
|
49
48
|
- README.md
|
|
49
|
+
- LICENSE
|
|
50
50
|
- _sass-list-maps.scss
|
|
51
51
|
- lib/sass-list-maps.rb
|
|
52
52
|
homepage: https://github.com/lunelson/sass-list-maps
|
|
@@ -69,8 +69,9 @@ required_rubygems_version: !ruby/object:Gem::Requirement
|
|
|
69
69
|
version: '0'
|
|
70
70
|
requirements: []
|
|
71
71
|
rubyforge_project:
|
|
72
|
-
rubygems_version: 2.
|
|
72
|
+
rubygems_version: 2.0.14
|
|
73
73
|
signing_key:
|
|
74
74
|
specification_version: 4
|
|
75
|
-
summary:
|
|
75
|
+
summary: Polyfill for map (hash/object) data functionality in libsass and ruby-sass
|
|
76
|
+
< 3.3.x.
|
|
76
77
|
test_files: []
|