diff options
author | Florian Dold <florian.dold@gmail.com> | 2017-05-03 15:35:00 +0200 |
---|---|---|
committer | Florian Dold <florian.dold@gmail.com> | 2017-05-03 15:35:00 +0200 |
commit | de98e0b232509d5f40c135d540a70e415272ff85 (patch) | |
tree | a79222a5b58484ab3b80d18efcaaa7ccc4769b33 /node_modules/renderkid | |
parent | e0c9d480a73fa629c1e4a47d3e721f1d2d345406 (diff) | |
download | wallet-core-de98e0b232509d5f40c135d540a70e415272ff85.tar.xz |
node_modules
Diffstat (limited to 'node_modules/renderkid')
63 files changed, 3334 insertions, 0 deletions
diff --git a/node_modules/renderkid/.npmignore b/node_modules/renderkid/.npmignore new file mode 100644 index 000000000..96345cae7 --- /dev/null +++ b/node_modules/renderkid/.npmignore @@ -0,0 +1,16 @@ +*.bat +.htaccess + +src/ +node_modules +pg + +-p + +npm-debug.log +!*.gitkeep + +xeno + +sass +.sass-cache
\ No newline at end of file diff --git a/node_modules/renderkid/.travis.yml b/node_modules/renderkid/.travis.yml new file mode 100644 index 000000000..5f6aa3f2a --- /dev/null +++ b/node_modules/renderkid/.travis.yml @@ -0,0 +1,6 @@ +language: node_js + +node_js: + - 0.10 + +sudo: false
\ No newline at end of file diff --git a/node_modules/renderkid/LICENSE b/node_modules/renderkid/LICENSE new file mode 100644 index 000000000..305ba0cd9 --- /dev/null +++ b/node_modules/renderkid/LICENSE @@ -0,0 +1,20 @@ +The MIT License (MIT) + +Copyright (c) 2015 Aria Minaei + +Permission is hereby granted, free of charge, to any person obtaining a copy of +this software and associated documentation files (the "Software"), to deal in +the Software without restriction, including without limitation the rights to +use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of +the Software, and to permit persons to whom the Software is furnished to do so, +subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS +FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR +COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER +IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN +CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. diff --git a/node_modules/renderkid/README.md b/node_modules/renderkid/README.md new file mode 100644 index 000000000..b98f93d5f --- /dev/null +++ b/node_modules/renderkid/README.md @@ -0,0 +1,189 @@ +# RenderKid +[![Build Status](https://secure.travis-ci.org/AriaMinaei/RenderKid.png)](http://travis-ci.org/AriaMinaei/RenderKid) + +RenderKid allows you to use HTML and CSS to style your CLI output, making it easy to create a beautiful, readable, and consistent look for your nodejs tool. + +## Installation + +Install with npm: +``` +$ npm install renderkid +``` + +## Usage + +```coffeescript +RenderKid = require('renderkid') + +r = new RenderKid() + +r.style({ + "ul": { + display: "block" + margin: "2 0 2" + } + + "li": { + display: "block" + marginBottom: "1" + } + + "key": { + color: "grey" + marginRight: "1" + } + + "value": { + color: "bright-white" + } +}) + +output = r.render(" +<ul> + <li> + <key>Name:</key> + <value>RenderKid</value> + </li> + <li> + <key>Version:</key> + <value>0.2</value> + </li> + <li> + <key>Last Update:</key> + <value>Jan 2015</value> + </li> +</ul> +") + +console.log(output) +``` + +![screenshot of usage](https://github.com/AriaMinaei/RenderKid/raw/master/docs/images/usage.png) + +## Stylesheet properties + +### Display mode + +Elements can have a `display` of either `inline`, `block`, or `none`: +```coffeescript +r.style({ + "div": { + display: "block" + } + + "span": { + display: "inline" # default + } + + "hidden": { + display: "none" + } +}) + +output = r.render(" +<div>This will fill one or more rows.</div> +<span>These</span> <span>will</span> <span>be</span> in the same <span>line.</span> +<hidden>This won't be displayed.</hidden> +") + +console.log(output) +``` + +![screenshot of usage](https://github.com/AriaMinaei/RenderKid/raw/master/docs/images/display.png) + + +### Margin + +Margins work just like they do in browsers: +```coffeescript +r.style({ + "li": { + display: "block" + + marginTop: "1" + marginRight: "2" + marginBottom: "3" + marginLeft: "4" + + # or the shorthand version: + "margin": "1 2 3 4" + }, + + "highlight": { + display: "inline" + marginLeft: "2" + marginRight: "2" + } +}) + +r.render(" +<ul> + <li>Item <highlgiht>1</highlight></li> + <li>Item <highlgiht>2</highlight></li> + <li>Item <highlgiht>3</highlight></li> +</ul> +") +``` + +### Padding + +See margins above. Paddings work the same way, only inward. + +### Width and Height + +Block elements can have explicit width and height: +```coffeescript +r.style({ + "box": { + display: "block" + "width": "4" + "height": "2" + } +}) + +r.render("<box>This is a box and some of its text will be truncated.</box>") +``` + +### Colors + +You can set a custom color and background color for each element: + +```coffeescript +r.style({ + "error": { + color: "black" + background: "red" + } +}) +``` + +List of colors currently supported are `black`, `red`, `green`, `yellow`, `blue`, `magenta`, `cyan`, `white`, `grey`, `bright-red`, `bright-green`, `bright-yellow`, `bright-blue`, `bright-magenta`, `bright-cyan`, `bright-white`. + +### Bullet points + +Block elements can have bullet points on their margins. Let's start with an example: +```coffeescript +r.style({ + "li": { + # To add bullet points to an element, first you + # should make some room for the bullet point by + # giving your element some margin to the left: + marginLeft: "4", + + # Now we can add a bullet point to our margin: + bullet: '"-"' + } +}) + +# The four hyphens are there for visual reference +r.render(" +---- +<li>Item 1</li> +<li>Item 2</li> +<li>Item 3</li> +---- +") +``` +And here is the result: + +![screenshot of bullet points, 1](https://github.com/AriaMinaei/RenderKid/raw/master/docs/images/bullets-1.png) diff --git a/node_modules/renderkid/docs/images/bullets-1.png b/node_modules/renderkid/docs/images/bullets-1.png Binary files differnew file mode 100644 index 000000000..fd6ab8582 --- /dev/null +++ b/node_modules/renderkid/docs/images/bullets-1.png diff --git a/node_modules/renderkid/docs/images/display.png b/node_modules/renderkid/docs/images/display.png Binary files differnew file mode 100644 index 000000000..0cac1d34a --- /dev/null +++ b/node_modules/renderkid/docs/images/display.png diff --git a/node_modules/renderkid/docs/images/usage.png b/node_modules/renderkid/docs/images/usage.png Binary files differnew file mode 100644 index 000000000..3bfd46dc5 --- /dev/null +++ b/node_modules/renderkid/docs/images/usage.png diff --git a/node_modules/renderkid/lib/AnsiPainter.js b/node_modules/renderkid/lib/AnsiPainter.js new file mode 100644 index 000000000..bd2a7ff24 --- /dev/null +++ b/node_modules/renderkid/lib/AnsiPainter.js @@ -0,0 +1,125 @@ +// Generated by CoffeeScript 1.9.3 +var AnsiPainter, object, styles, tags, tools, + hasProp = {}.hasOwnProperty, + slice = [].slice; + +tools = require('./tools'); + +tags = require('./ansiPainter/tags'); + +styles = require('./ansiPainter/styles'); + +object = require('utila').object; + +module.exports = AnsiPainter = (function() { + var self; + + function AnsiPainter() {} + + AnsiPainter.tags = tags; + + AnsiPainter.prototype.paint = function(s) { + return this._replaceSpecialStrings(this._renderDom(this._parse(s))); + }; + + AnsiPainter.prototype._replaceSpecialStrings = function(str) { + return str.replace(/&sp;/g, ' ').replace(/</g, '<').replace(/>/g, '>').replace(/"/g, '"').replace(/&/g, '&'); + }; + + AnsiPainter.prototype._parse = function(string, injectFakeRoot) { + if (injectFakeRoot == null) { + injectFakeRoot = true; + } + if (injectFakeRoot) { + string = '<none>' + string + '</none>'; + } + return tools.toDom(string); + }; + + AnsiPainter.prototype._renderDom = function(dom) { + var parentStyles; + parentStyles = { + bg: 'none', + color: 'none' + }; + return this._renderChildren(dom, parentStyles); + }; + + AnsiPainter.prototype._renderChildren = function(children, parentStyles) { + var child, n, ret; + ret = ''; + for (n in children) { + if (!hasProp.call(children, n)) continue; + child = children[n]; + ret += this._renderNode(child, parentStyles); + } + return ret; + }; + + AnsiPainter.prototype._renderNode = function(node, parentStyles) { + if (node.type === 'text') { + return this._renderTextNode(node, parentStyles); + } else { + return this._renderTag(node, parentStyles); + } + }; + + AnsiPainter.prototype._renderTextNode = function(node, parentStyles) { + return this._wrapInStyle(node.data, parentStyles); + }; + + AnsiPainter.prototype._wrapInStyle = function(str, style) { + return styles.color(style.color) + styles.bg(style.bg) + str + styles.none(); + }; + + AnsiPainter.prototype._renderTag = function(node, parentStyles) { + var currentStyles, tagStyles; + tagStyles = this._getStylesForTagName(node.name); + currentStyles = this._mixStyles(parentStyles, tagStyles); + return this._renderChildren(node.children, currentStyles); + }; + + AnsiPainter.prototype._mixStyles = function() { + var final, i, key, len, style, styles, val; + styles = 1 <= arguments.length ? slice.call(arguments, 0) : []; + final = {}; + for (i = 0, len = styles.length; i < len; i++) { + style = styles[i]; + for (key in style) { + if (!hasProp.call(style, key)) continue; + val = style[key]; + if ((final[key] == null) || val !== 'inherit') { + final[key] = val; + } + } + } + return final; + }; + + AnsiPainter.prototype._getStylesForTagName = function(name) { + if (tags[name] == null) { + throw Error("Unkown tag name `" + name + "`"); + } + return tags[name]; + }; + + self = AnsiPainter; + + AnsiPainter.getInstance = function() { + if (self._instance == null) { + self._instance = new self; + } + return self._instance; + }; + + AnsiPainter.paint = function(str) { + return self.getInstance().paint(str); + }; + + AnsiPainter.strip = function(s) { + return s.replace(/\x1b\[[0-9]+m/g, ''); + }; + + return AnsiPainter; + +})(); diff --git a/node_modules/renderkid/lib/Layout.js b/node_modules/renderkid/lib/Layout.js new file mode 100644 index 000000000..842945e29 --- /dev/null +++ b/node_modules/renderkid/lib/Layout.js @@ -0,0 +1,110 @@ +// Generated by CoffeeScript 1.9.3 +var Block, Layout, SpecialString, fn, i, len, object, prop, ref, terminalWidth; + +Block = require('./layout/Block'); + +object = require('utila').object; + +SpecialString = require('./layout/SpecialString'); + +terminalWidth = require('./tools').getCols(); + +module.exports = Layout = (function() { + var self; + + self = Layout; + + Layout._rootBlockDefaultConfig = { + linePrependor: { + options: { + amount: 0 + } + }, + lineAppendor: { + options: { + amount: 0 + } + }, + blockPrependor: { + options: { + amount: 0 + } + }, + blockAppendor: { + options: { + amount: 0 + } + } + }; + + Layout._defaultConfig = { + terminalWidth: terminalWidth + }; + + function Layout(config, rootBlockConfig) { + var rootConfig; + if (config == null) { + config = {}; + } + if (rootBlockConfig == null) { + rootBlockConfig = {}; + } + this._written = []; + this._activeBlock = null; + this._config = object.append(self._defaultConfig, config); + rootConfig = object.append(self._rootBlockDefaultConfig, rootBlockConfig); + this._root = new Block(this, null, rootConfig, '__root'); + this._root._open(); + } + + Layout.prototype.getRootBlock = function() { + return this._root; + }; + + Layout.prototype._append = function(text) { + return this._written.push(text); + }; + + Layout.prototype._appendLine = function(text) { + var s; + this._append(text); + s = SpecialString(text); + if (s.length < this._config.terminalWidth) { + this._append('<none>\n</none>'); + } + return this; + }; + + Layout.prototype.get = function() { + this._ensureClosed(); + if (this._written[this._written.length - 1] === '<none>\n</none>') { + this._written.pop(); + } + return this._written.join(""); + }; + + Layout.prototype._ensureClosed = function() { + if (this._activeBlock !== this._root) { + throw Error("Not all the blocks have been closed. Please call block.close() on all open blocks."); + } + if (this._root.isOpen()) { + this._root.close(); + } + }; + + return Layout; + +})(); + +ref = ['openBlock', 'write']; +fn = function() { + var method; + method = prop; + return Layout.prototype[method] = function() { + return this._root[method].apply(this._root, arguments); + }; +}; +for (i = 0, len = ref.length; i < len; i++) { + prop = ref[i]; + fn(); +} diff --git a/node_modules/renderkid/lib/RenderKid.js b/node_modules/renderkid/lib/RenderKid.js new file mode 100644 index 000000000..a317e2e63 --- /dev/null +++ b/node_modules/renderkid/lib/RenderKid.js @@ -0,0 +1,197 @@ +// Generated by CoffeeScript 1.9.3 +var AnsiPainter, Layout, RenderKid, Styles, blockStyleApplier, inlineStyleApplier, object, stripAnsi, terminalWidth, tools; + +inlineStyleApplier = require('./renderKid/styleApplier/inline'); + +blockStyleApplier = require('./renderKid/styleApplier/block'); + +AnsiPainter = require('./AnsiPainter'); + +Styles = require('./renderKid/Styles'); + +Layout = require('./Layout'); + +tools = require('./tools'); + +object = require('utila').object; + +stripAnsi = require('strip-ansi'); + +terminalWidth = require('./tools').getCols(); + +module.exports = RenderKid = (function() { + var self; + + self = RenderKid; + + RenderKid.AnsiPainter = AnsiPainter; + + RenderKid.Layout = Layout; + + RenderKid.quote = tools.quote; + + RenderKid.tools = tools; + + RenderKid._defaultConfig = { + layout: { + terminalWidth: terminalWidth + } + }; + + function RenderKid(config) { + if (config == null) { + config = {}; + } + this.tools = self.tools; + this._config = object.append(self._defaultConfig, config); + this._initStyles(); + } + + RenderKid.prototype._initStyles = function() { + return this._styles = new Styles; + }; + + RenderKid.prototype.style = function() { + return this._styles.setRule.apply(this._styles, arguments); + }; + + RenderKid.prototype._getStyleFor = function(el) { + return this._styles.getStyleFor(el); + }; + + RenderKid.prototype.render = function(input, withColors) { + if (withColors == null) { + withColors = true; + } + return this._paint(this._renderDom(this._toDom(input)), withColors); + }; + + RenderKid.prototype._toDom = function(input) { + if (typeof input === 'string') { + return this._parse(input); + } else if (object.isBareObject(input) || Array.isArray(input)) { + return this._objToDom(input); + } else { + throw Error("Invalid input type. Only strings, arrays and objects are accepted"); + } + }; + + RenderKid.prototype._objToDom = function(o, injectFakeRoot) { + if (injectFakeRoot == null) { + injectFakeRoot = true; + } + if (injectFakeRoot) { + o = { + body: o + }; + } + return tools.objectToDom(o); + }; + + RenderKid.prototype._paint = function(text, withColors) { + var painted; + painted = AnsiPainter.paint(text); + if (withColors) { + return painted; + } else { + return stripAnsi(painted); + } + }; + + RenderKid.prototype._parse = function(string, injectFakeRoot) { + if (injectFakeRoot == null) { + injectFakeRoot = true; + } + if (injectFakeRoot) { + string = '<body>' + string + '</body>'; + } + return tools.stringToDom(string); + }; + + RenderKid.prototype._renderDom = function(dom) { + var bodyTag, layout, rootBlock; + bodyTag = dom[0]; + layout = new Layout(this._config.layout); + rootBlock = layout.getRootBlock(); + this._renderBlockNode(bodyTag, null, rootBlock); + return layout.get(); + }; + + RenderKid.prototype._renderChildrenOf = function(parentNode, parentBlock) { + var i, len, node, nodes; + nodes = parentNode.children; + for (i = 0, len = nodes.length; i < len; i++) { + node = nodes[i]; + this._renderNode(node, parentNode, parentBlock); + } + }; + + RenderKid.prototype._renderNode = function(node, parentNode, parentBlock) { + if (node.type === 'text') { + this._renderText(node, parentNode, parentBlock); + } else if (node.name === 'br') { + this._renderBr(node, parentNode, parentBlock); + } else if (this._isBlock(node)) { + this._renderBlockNode(node, parentNode, parentBlock); + } else if (this._isNone(node)) { + return; + } else { + this._renderInlineNode(node, parentNode, parentBlock); + } + }; + + RenderKid.prototype._renderText = function(node, parentNode, parentBlock) { + var ref, text; + text = node.data; + text = text.replace(/\s+/g, ' '); + if ((parentNode != null ? (ref = parentNode.styles) != null ? ref.display : void 0 : void 0) !== 'inline') { + text = text.trim(); + } + if (text.length === 0) { + return; + } + text = text.replace(/&nl;/g, "\n"); + return parentBlock.write(text); + }; + + RenderKid.prototype._renderBlockNode = function(node, parentNode, parentBlock) { + var after, before, block, blockConfig, ref; + ref = blockStyleApplier.applyTo(node, this._getStyleFor(node)), before = ref.before, after = ref.after, blockConfig = ref.blockConfig; + block = parentBlock.openBlock(blockConfig); + if (before !== '') { + block.write(before); + } + this._renderChildrenOf(node, block); + if (after !== '') { + block.write(after); + } + return block.close(); + }; + + RenderKid.prototype._renderInlineNode = function(node, parentNode, parentBlock) { + var after, before, ref; + ref = inlineStyleApplier.applyTo(node, this._getStyleFor(node)), before = ref.before, after = ref.after; + if (before !== '') { + parentBlock.write(before); + } + this._renderChildrenOf(node, parentBlock); + if (after !== '') { + return parentBlock.write(after); + } + }; + + RenderKid.prototype._renderBr = function(node, parentNode, parentBlock) { + return parentBlock.write("\n"); + }; + + RenderKid.prototype._isBlock = function(node) { + return !(node.type === 'text' || node.name === 'br' || this._getStyleFor(node).display !== 'block'); + }; + + RenderKid.prototype._isNone = function(node) { + return !(node.type === 'text' || node.name === 'br' || this._getStyleFor(node).display !== 'none'); + }; + + return RenderKid; + +})(); diff --git a/node_modules/renderkid/lib/ansiPainter/styles.js b/node_modules/renderkid/lib/ansiPainter/styles.js new file mode 100644 index 000000000..a2d9def4e --- /dev/null +++ b/node_modules/renderkid/lib/ansiPainter/styles.js @@ -0,0 +1,68 @@ +// Generated by CoffeeScript 1.9.3 +var codes, styles; + +module.exports = styles = {}; + +styles.codes = codes = { + 'none': 0, + 'black': 30, + 'red': 31, + 'green': 32, + 'yellow': 33, + 'blue': 34, + 'magenta': 35, + 'cyan': 36, + 'white': 37, + 'grey': 90, + 'bright-red': 91, + 'bright-green': 92, + 'bright-yellow': 93, + 'bright-blue': 94, + 'bright-magenta': 95, + 'bright-cyan': 96, + 'bright-white': 97, + 'bg-black': 40, + 'bg-red': 41, + 'bg-green': 42, + 'bg-yellow': 43, + 'bg-blue': 44, + 'bg-magenta': 45, + 'bg-cyan': 46, + 'bg-white': 47, + 'bg-grey': 100, + 'bg-bright-red': 101, + 'bg-bright-green': 102, + 'bg-bright-yellow': 103, + 'bg-bright-blue': 104, + 'bg-bright-magenta': 105, + 'bg-bright-cyan': 106, + 'bg-bright-white': 107 +}; + +styles.color = function(str) { + var code; + if (str === 'none') { + return ''; + } + code = codes[str]; + if (code == null) { + throw Error("Unkown color `" + str + "`"); + } + return "\x1b[" + code + "m"; +}; + +styles.bg = function(str) { + var code; + if (str === 'none') { + return ''; + } + code = codes['bg-' + str]; + if (code == null) { + throw Error("Unkown bg color `" + str + "`"); + } + return "\x1B[" + code + "m"; +}; + +styles.none = function(str) { + return "\x1B[" + codes.none + "m"; +}; diff --git a/node_modules/renderkid/lib/ansiPainter/tags.js b/node_modules/renderkid/lib/ansiPainter/tags.js new file mode 100644 index 000000000..3e7388445 --- /dev/null +++ b/node_modules/renderkid/lib/ansiPainter/tags.js @@ -0,0 +1,35 @@ +// Generated by CoffeeScript 1.9.3 +var color, colors, i, len, tags; + +module.exports = tags = { + 'none': { + color: 'none', + bg: 'none' + }, + 'bg-none': { + color: 'inherit', + bg: 'none' + }, + 'color-none': { + color: 'none', + bg: 'inherit' + } +}; + +colors = ['black', 'red', 'green', 'yellow', 'blue', 'magenta', 'cyan', 'white', 'grey', 'bright-red', 'bright-green', 'bright-yellow', 'bright-blue', 'bright-magenta', 'bright-cyan', 'bright-white']; + +for (i = 0, len = colors.length; i < len; i++) { + color = colors[i]; + tags[color] = { + color: color, + bg: 'inherit' + }; + tags["color-" + color] = { + color: color, + bg: 'inherit' + }; + tags["bg-" + color] = { + color: 'inherit', + bg: color + }; +} diff --git a/node_modules/renderkid/lib/layout/Block.js b/node_modules/renderkid/lib/layout/Block.js new file mode 100644 index 000000000..e22e800a4 --- /dev/null +++ b/node_modules/renderkid/lib/layout/Block.js @@ -0,0 +1,253 @@ +// Generated by CoffeeScript 1.9.3 +var Block, SpecialString, object, terminalWidth; + +SpecialString = require('./SpecialString'); + +object = require('utila').object; + +terminalWidth = require('../tools').getCols(); + +module.exports = Block = (function() { + var self; + + self = Block; + + Block.defaultConfig = { + blockPrependor: { + fn: require('./block/blockPrependor/Default'), + options: { + amount: 0 + } + }, + blockAppendor: { + fn: require('./block/blockAppendor/Default'), + options: { + amount: 0 + } + }, + linePrependor: { + fn: require('./block/linePrependor/Default'), + options: { + amount: 0 + } + }, + lineAppendor: { + fn: require('./block/lineAppendor/Default'), + options: { + amount: 0 + } + }, + lineWrapper: { + fn: require('./block/lineWrapper/Default'), + options: { + lineWidth: null + } + }, + width: terminalWidth, + prefixRaw: '', + suffixRaw: '' + }; + + function Block(_layout, _parent, config, _name) { + this._layout = _layout; + this._parent = _parent; + if (config == null) { + config = {}; + } + this._name = _name != null ? _name : ''; + this._config = object.append(self.defaultConfig, config); + this._closed = false; + this._wasOpenOnce = false; + this._active = false; + this._buffer = ''; + this._didSeparateBlock = false; + this._linePrependor = new this._config.linePrependor.fn(this._config.linePrependor.options); + this._lineAppendor = new this._config.lineAppendor.fn(this._config.lineAppendor.options); + this._blockPrependor = new this._config.blockPrependor.fn(this._config.blockPrependor.options); + this._blockAppendor = new this._config.blockAppendor.fn(this._config.blockAppendor.options); + } + + Block.prototype._activate = function(deactivateParent) { + if (deactivateParent == null) { + deactivateParent = true; + } + if (this._active) { + throw Error("This block is already active. This is probably a bug in RenderKid itself"); + } + if (this._closed) { + throw Error("This block is closed and cannot be activated. This is probably a bug in RenderKid itself"); + } + this._active = true; + this._layout._activeBlock = this; + if (deactivateParent) { + if (this._parent != null) { + this._parent._deactivate(false); + } + } + return this; + }; + + Block.prototype._deactivate = function(activateParent) { + if (activateParent == null) { + activateParent = true; + } + this._ensureActive(); + this._flushBuffer(); + if (activateParent) { + if (this._parent != null) { + this._parent._activate(false); + } + } + this._active = false; + return this; + }; + + Block.prototype._ensureActive = function() { + if (!this._wasOpenOnce) { + throw Error("This block has never been open before. This is probably a bug in RenderKid itself."); + } + if (!this._active) { + throw Error("This block is not active. This is probably a bug in RenderKid itself."); + } + if (this._closed) { + throw Error("This block is already closed. This is probably a bug in RenderKid itself."); + } + }; + + Block.prototype._open = function() { + if (this._wasOpenOnce) { + throw Error("Block._open() has been called twice. This is probably a RenderKid bug."); + } + this._wasOpenOnce = true; + if (this._parent != null) { + this._parent.write(this._whatToPrependToBlock()); + } + this._activate(); + return this; + }; + + Block.prototype.close = function() { + this._deactivate(); + this._closed = true; + if (this._parent != null) { + this._parent.write(this._whatToAppendToBlock()); + } + return this; + }; + + Block.prototype.isOpen = function() { + return this._wasOpenOnce && !this._closed; + }; + + Block.prototype.write = function(str) { + this._ensureActive(); + if (str === '') { + return; + } + str = String(str); + this._buffer += str; + return this; + }; + + Block.prototype.openBlock = function(config, name) { + var block; + this._ensureActive(); + block = new Block(this._layout, this, config, name); + block._open(); + return block; + }; + + Block.prototype._flushBuffer = function() { + var str; + if (this._buffer === '') { + return; + } + str = this._buffer; + this._buffer = ''; + this._writeInline(str); + }; + + Block.prototype._toPrependToLine = function() { + var fromParent; + fromParent = ''; + if (this._parent != null) { + fromParent = this._parent._toPrependToLine(); + } + return this._linePrependor.render(fromParent); + }; + + Block.prototype._toAppendToLine = function() { + var fromParent; + fromParent = ''; + if (this._parent != null) { + fromParent = this._parent._toAppendToLine(); + } + return this._lineAppendor.render(fromParent); + }; + + Block.prototype._whatToPrependToBlock = function() { + return this._blockPrependor.render(); + }; + + Block.prototype._whatToAppendToBlock = function() { + return this._blockAppendor.render(); + }; + + Block.prototype._writeInline = function(str) { + var i, j, k, l, lineBreaksToAppend, m, ref, ref1, ref2, remaining; + if (SpecialString(str).isOnlySpecialChars()) { + this._layout._append(str); + return; + } + remaining = str; + lineBreaksToAppend = 0; + if (m = remaining.match(/^\n+/)) { + for (i = j = 1, ref = m[0].length; 1 <= ref ? j <= ref : j >= ref; i = 1 <= ref ? ++j : --j) { + this._writeLine(''); + } + remaining = remaining.substr(m[0].length, remaining.length); + } + if (m = remaining.match(/\n+$/)) { + lineBreaksToAppend = m[0].length; + remaining = remaining.substr(0, remaining.length - m[0].length); + } + while (remaining.length > 0) { + if (m = remaining.match(/^[^\n]+/)) { + this._writeLine(m[0]); + remaining = remaining.substr(m[0].length, remaining.length); + } else if (m = remaining.match(/^\n+/)) { + for (i = k = 1, ref1 = m[0].length; 1 <= ref1 ? k < ref1 : k > ref1; i = 1 <= ref1 ? ++k : --k) { + this._writeLine(''); + } + remaining = remaining.substr(m[0].length, remaining.length); + } + } + if (lineBreaksToAppend > 0) { + for (i = l = 1, ref2 = lineBreaksToAppend; 1 <= ref2 ? l <= ref2 : l >= ref2; i = 1 <= ref2 ? ++l : --l) { + this._writeLine(''); + } + } + }; + + Block.prototype._writeLine = function(str) { + var line, lineContent, lineContentLength, remaining, roomLeft, toAppend, toAppendLength, toPrepend, toPrependLength; + remaining = SpecialString(str); + while (true) { + toPrepend = this._toPrependToLine(); + toPrependLength = SpecialString(toPrepend).length; + toAppend = this._toAppendToLine(); + toAppendLength = SpecialString(toAppend).length; + roomLeft = this._layout._config.terminalWidth - (toPrependLength + toAppendLength); + lineContentLength = Math.min(this._config.width, roomLeft); + lineContent = remaining.cut(0, lineContentLength, true); + line = toPrepend + lineContent.str + toAppend; + this._layout._appendLine(line); + if (remaining.isEmpty()) { + break; + } + } + }; + + return Block; + +})(); diff --git a/node_modules/renderkid/lib/layout/SpecialString.js b/node_modules/renderkid/lib/layout/SpecialString.js new file mode 100644 index 000000000..f106b2cee --- /dev/null +++ b/node_modules/renderkid/lib/layout/SpecialString.js @@ -0,0 +1,176 @@ +// Generated by CoffeeScript 1.9.3 +var SpecialString, fn, i, len, prop, ref; + +module.exports = SpecialString = (function() { + var self; + + self = SpecialString; + + SpecialString._tabRx = /^\t/; + + SpecialString._tagRx = /^<[^>]+>/; + + SpecialString._quotedHtmlRx = /^&(gt|lt|quot|amp|apos|sp);/; + + function SpecialString(str) { + if (!(this instanceof self)) { + return new self(str); + } + this._str = String(str); + this._len = 0; + } + + SpecialString.prototype._getStr = function() { + return this._str; + }; + + SpecialString.prototype.set = function(str) { + this._str = String(str); + return this; + }; + + SpecialString.prototype.clone = function() { + return new SpecialString(this._str); + }; + + SpecialString.prototype.isEmpty = function() { + return this._str === ''; + }; + + SpecialString.prototype.isOnlySpecialChars = function() { + return !this.isEmpty() && this.length === 0; + }; + + SpecialString.prototype._reset = function() { + return this._len = 0; + }; + + SpecialString.prototype.splitIn = function(limit, trimLeftEachLine) { + var buffer, bufferLength, justSkippedSkipChar, lines; + if (trimLeftEachLine == null) { + trimLeftEachLine = false; + } + buffer = ''; + bufferLength = 0; + lines = []; + justSkippedSkipChar = false; + self._countChars(this._str, function(char, charLength) { + if (bufferLength > limit || bufferLength + charLength > limit) { + lines.push(buffer); + buffer = ''; + bufferLength = 0; + } + if (bufferLength === 0 && char === ' ' && !justSkippedSkipChar && trimLeftEachLine) { + return justSkippedSkipChar = true; + } else { + buffer += char; + bufferLength += charLength; + return justSkippedSkipChar = false; + } + }); + if (buffer.length > 0) { + lines.push(buffer); + } + return lines; + }; + + SpecialString.prototype.trim = function() { + return new SpecialString(this.str.trim()); + }; + + SpecialString.prototype.trimLeft = function() { + return new SpecialString(this.str.replace(/^\s+/, '')); + }; + + SpecialString.prototype.trimRight = function() { + return new SpecialString(this.str.replace(/\s+$/, '')); + }; + + SpecialString.prototype._getLength = function() { + var sum; + sum = 0; + self._countChars(this._str, function(char, charLength) { + sum += charLength; + }); + return sum; + }; + + SpecialString.prototype.cut = function(from, to, trimLeft) { + var after, before, cur, cut; + if (trimLeft == null) { + trimLeft = false; + } + if (to == null) { + to = this.length; + } + from = parseInt(from); + if (from >= to) { + throw Error("`from` shouldn't be larger than `to`"); + } + before = ''; + after = ''; + cut = ''; + cur = 0; + self._countChars(this._str, (function(_this) { + return function(char, charLength) { + if (_this.str === 'ab<tag>') { + console.log(charLength, char); + } + if (cur === from && char.match(/^\s+$/) && trimLeft) { + return; + } + if (cur < from) { + before += char; + } else if (cur < to || cur + charLength <= to) { + cut += char; + } else { + after += char; + } + cur += charLength; + }; + })(this)); + this._str = before + after; + this._reset(); + return SpecialString(cut); + }; + + SpecialString._countChars = function(text, cb) { + var char, charLength, m; + while (text.length !== 0) { + if (m = text.match(self._tagRx)) { + char = m[0]; + charLength = 0; + text = text.substr(char.length, text.length); + } else if (m = text.match(self._quotedHtmlRx)) { + char = m[0]; + charLength = 1; + text = text.substr(char.length, text.length); + } else if (text.match(self._tabRx)) { + char = "\t"; + charLength = 8; + text = text.substr(1, text.length); + } else { + char = text[0]; + charLength = 1; + text = text.substr(1, text.length); + } + cb.call(null, char, charLength); + } + }; + + return SpecialString; + +})(); + +ref = ['str', 'length']; +fn = function() { + var methodName; + methodName = '_get' + prop[0].toUpperCase() + prop.substr(1, prop.length); + return SpecialString.prototype.__defineGetter__(prop, function() { + return this[methodName](); + }); +}; +for (i = 0, len = ref.length; i < len; i++) { + prop = ref[i]; + fn(); +} diff --git a/node_modules/renderkid/lib/layout/block/blockAppendor/Default.js b/node_modules/renderkid/lib/layout/block/blockAppendor/Default.js new file mode 100644 index 000000000..c4d76854e --- /dev/null +++ b/node_modules/renderkid/lib/layout/block/blockAppendor/Default.js @@ -0,0 +1,21 @@ +// Generated by CoffeeScript 1.9.3 +var DefaultBlockAppendor, tools, + extend = function(child, parent) { for (var key in parent) { if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; }, + hasProp = {}.hasOwnProperty; + +tools = require('../../../tools'); + +module.exports = DefaultBlockAppendor = (function(superClass) { + extend(DefaultBlockAppendor, superClass); + + function DefaultBlockAppendor() { + return DefaultBlockAppendor.__super__.constructor.apply(this, arguments); + } + + DefaultBlockAppendor.prototype._render = function(options) { + return tools.repeatString("\n", this._config.amount); + }; + + return DefaultBlockAppendor; + +})(require('./_BlockAppendor')); diff --git a/node_modules/renderkid/lib/layout/block/blockAppendor/_BlockAppendor.js b/node_modules/renderkid/lib/layout/block/blockAppendor/_BlockAppendor.js new file mode 100644 index 000000000..fda9d76a7 --- /dev/null +++ b/node_modules/renderkid/lib/layout/block/blockAppendor/_BlockAppendor.js @@ -0,0 +1,15 @@ +// Generated by CoffeeScript 1.9.3 +var _BlockAppendor; + +module.exports = _BlockAppendor = (function() { + function _BlockAppendor(_config) { + this._config = _config; + } + + _BlockAppendor.prototype.render = function(options) { + return this._render(options); + }; + + return _BlockAppendor; + +})(); diff --git a/node_modules/renderkid/lib/layout/block/blockPrependor/Default.js b/node_modules/renderkid/lib/layout/block/blockPrependor/Default.js new file mode 100644 index 000000000..27d7353dd --- /dev/null +++ b/node_modules/renderkid/lib/layout/block/blockPrependor/Default.js @@ -0,0 +1,21 @@ +// Generated by CoffeeScript 1.9.3 +var DefaultBlockPrependor, tools, + extend = function(child, parent) { for (var key in parent) { if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; }, + hasProp = {}.hasOwnProperty; + +tools = require('../../../tools'); + +module.exports = DefaultBlockPrependor = (function(superClass) { + extend(DefaultBlockPrependor, superClass); + + function DefaultBlockPrependor() { + return DefaultBlockPrependor.__super__.constructor.apply(this, arguments); + } + + DefaultBlockPrependor.prototype._render = function(options) { + return tools.repeatString("\n", this._config.amount); + }; + + return DefaultBlockPrependor; + +})(require('./_BlockPrependor')); diff --git a/node_modules/renderkid/lib/layout/block/blockPrependor/_BlockPrependor.js b/node_modules/renderkid/lib/layout/block/blockPrependor/_BlockPrependor.js new file mode 100644 index 000000000..737719155 --- /dev/null +++ b/node_modules/renderkid/lib/layout/block/blockPrependor/_BlockPrependor.js @@ -0,0 +1,15 @@ +// Generated by CoffeeScript 1.9.3 +var _BlockPrependor; + +module.exports = _BlockPrependor = (function() { + function _BlockPrependor(_config) { + this._config = _config; + } + + _BlockPrependor.prototype.render = function(options) { + return this._render(options); + }; + + return _BlockPrependor; + +})(); diff --git a/node_modules/renderkid/lib/layout/block/lineAppendor/Default.js b/node_modules/renderkid/lib/layout/block/lineAppendor/Default.js new file mode 100644 index 000000000..4da2c30ad --- /dev/null +++ b/node_modules/renderkid/lib/layout/block/lineAppendor/Default.js @@ -0,0 +1,21 @@ +// Generated by CoffeeScript 1.9.3 +var DefaultLineAppendor, tools, + extend = function(child, parent) { for (var key in parent) { if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; }, + hasProp = {}.hasOwnProperty; + +tools = require('../../../tools'); + +module.exports = DefaultLineAppendor = (function(superClass) { + extend(DefaultLineAppendor, superClass); + + function DefaultLineAppendor() { + return DefaultLineAppendor.__super__.constructor.apply(this, arguments); + } + + DefaultLineAppendor.prototype._render = function(inherited, options) { + return inherited + tools.repeatString(" ", this._config.amount); + }; + + return DefaultLineAppendor; + +})(require('./_LineAppendor')); diff --git a/node_modules/renderkid/lib/layout/block/lineAppendor/_LineAppendor.js b/node_modules/renderkid/lib/layout/block/lineAppendor/_LineAppendor.js new file mode 100644 index 000000000..75829099b --- /dev/null +++ b/node_modules/renderkid/lib/layout/block/lineAppendor/_LineAppendor.js @@ -0,0 +1,17 @@ +// Generated by CoffeeScript 1.9.3 +var _LineAppendor; + +module.exports = _LineAppendor = (function() { + function _LineAppendor(_config) { + this._config = _config; + this._lineNo = 0; + } + + _LineAppendor.prototype.render = function(inherited, options) { + this._lineNo++; + return '<none>' + this._render(inherited, options) + '</none>'; + }; + + return _LineAppendor; + +})(); diff --git a/node_modules/renderkid/lib/layout/block/linePrependor/Default.js b/node_modules/renderkid/lib/layout/block/linePrependor/Default.js new file mode 100644 index 000000000..891ffcb8f --- /dev/null +++ b/node_modules/renderkid/lib/layout/block/linePrependor/Default.js @@ -0,0 +1,58 @@ +// Generated by CoffeeScript 1.9.3 +var DefaultLinePrependor, SpecialString, tools, + extend = function(child, parent) { for (var key in parent) { if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; }, + hasProp = {}.hasOwnProperty; + +tools = require('../../../tools'); + +SpecialString = require('../../SpecialString'); + +module.exports = DefaultLinePrependor = (function(superClass) { + var self; + + extend(DefaultLinePrependor, superClass); + + function DefaultLinePrependor() { + return DefaultLinePrependor.__super__.constructor.apply(this, arguments); + } + + self = DefaultLinePrependor; + + DefaultLinePrependor.pad = function(howMuch) { + return tools.repeatString(" ", howMuch); + }; + + DefaultLinePrependor.prototype._render = function(inherited, options) { + var addToLeft, addToRight, alignment, bullet, char, charLen, diff, left, output, space, toWrite; + if (this._lineNo === 0 && (bullet = this._config.bullet)) { + char = bullet.char; + charLen = SpecialString(char).length; + alignment = bullet.alignment; + space = this._config.amount; + toWrite = char; + addToLeft = ''; + addToRight = ''; + if (space > charLen) { + diff = space - charLen; + if (alignment === 'right') { + addToLeft = self.pad(diff); + } else if (alignment === 'left') { + addToRight = self.pad(diff); + } else if (alignment === 'center') { + left = Math.round(diff / 2); + addToLeft = self.pad(left); + addToRight = self.pad(diff - left); + } else { + throw Error("Unkown alignment `" + alignment + "`"); + } + } + output = addToLeft + char + addToRight; + } else { + output = self.pad(this._config.amount); + } + return inherited + output; + }; + + return DefaultLinePrependor; + +})(require('./_LinePrependor')); diff --git a/node_modules/renderkid/lib/layout/block/linePrependor/_LinePrependor.js b/node_modules/renderkid/lib/layout/block/linePrependor/_LinePrependor.js new file mode 100644 index 000000000..cd6821af9 --- /dev/null +++ b/node_modules/renderkid/lib/layout/block/linePrependor/_LinePrependor.js @@ -0,0 +1,17 @@ +// Generated by CoffeeScript 1.9.3 +var _LinePrependor; + +module.exports = _LinePrependor = (function() { + function _LinePrependor(_config) { + this._config = _config; + this._lineNo = -1; + } + + _LinePrependor.prototype.render = function(inherited, options) { + this._lineNo++; + return '<none>' + this._render(inherited, options) + '</none>'; + }; + + return _LinePrependor; + +})(); diff --git a/node_modules/renderkid/lib/layout/block/lineWrapper/Default.js b/node_modules/renderkid/lib/layout/block/lineWrapper/Default.js new file mode 100644 index 000000000..9fbe5097d --- /dev/null +++ b/node_modules/renderkid/lib/layout/block/lineWrapper/Default.js @@ -0,0 +1,17 @@ +// Generated by CoffeeScript 1.9.3 +var DefaultLineWrapper, + extend = function(child, parent) { for (var key in parent) { if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; }, + hasProp = {}.hasOwnProperty; + +module.exports = DefaultLineWrapper = (function(superClass) { + extend(DefaultLineWrapper, superClass); + + function DefaultLineWrapper() { + return DefaultLineWrapper.__super__.constructor.apply(this, arguments); + } + + DefaultLineWrapper.prototype._render = function() {}; + + return DefaultLineWrapper; + +})(require('./_LineWrapper')); diff --git a/node_modules/renderkid/lib/layout/block/lineWrapper/_LineWrapper.js b/node_modules/renderkid/lib/layout/block/lineWrapper/_LineWrapper.js new file mode 100644 index 000000000..c3abcc3dd --- /dev/null +++ b/node_modules/renderkid/lib/layout/block/lineWrapper/_LineWrapper.js @@ -0,0 +1,13 @@ +// Generated by CoffeeScript 1.9.3 +var _LineWrapper; + +module.exports = _LineWrapper = (function() { + function _LineWrapper() {} + + _LineWrapper.prototype.render = function(str, options) { + return this._render(str, options); + }; + + return _LineWrapper; + +})(); diff --git a/node_modules/renderkid/lib/renderKid/Styles.js b/node_modules/renderkid/lib/renderKid/Styles.js new file mode 100644 index 000000000..52651aa01 --- /dev/null +++ b/node_modules/renderkid/lib/renderKid/Styles.js @@ -0,0 +1,76 @@ +// Generated by CoffeeScript 1.9.3 +var MixedDeclarationSet, StyleSheet, Styles, terminalWidth; + +StyleSheet = require('./styles/StyleSheet'); + +MixedDeclarationSet = require('./styles/rule/MixedDeclarationSet'); + +terminalWidth = require('../tools').getCols(); + +module.exports = Styles = (function() { + var self; + + self = Styles; + + Styles.defaultRules = { + '*': { + display: 'inline' + }, + 'body': { + background: 'none', + color: 'white', + display: 'block', + width: terminalWidth + ' !important' + } + }; + + function Styles() { + this._defaultStyles = new StyleSheet; + this._userStyles = new StyleSheet; + this._setDefaultStyles(); + } + + Styles.prototype._setDefaultStyles = function() { + this._defaultStyles.setRule(self.defaultRules); + }; + + Styles.prototype.setRule = function(selector, rules) { + this._userStyles.setRule.apply(this._userStyles, arguments); + return this; + }; + + Styles.prototype.getStyleFor = function(el) { + var styles; + styles = el.styles; + if (styles == null) { + el.styles = styles = this._getComputedStyleFor(el); + } + return styles; + }; + + Styles.prototype._getRawStyleFor = function(el) { + var def, user; + def = this._defaultStyles.getRulesFor(el); + user = this._userStyles.getRulesFor(el); + return MixedDeclarationSet.mix(def, user).toObject(); + }; + + Styles.prototype._getComputedStyleFor = function(el) { + var decs, parent, prop, ref, val; + decs = {}; + parent = el.parent; + ref = this._getRawStyleFor(el); + for (prop in ref) { + val = ref[prop]; + if (val !== 'inherit') { + decs[prop] = val; + } else { + throw Error("Inherited styles are not supported yet."); + } + } + return decs; + }; + + return Styles; + +})(); diff --git a/node_modules/renderkid/lib/renderKid/styleApplier/_common.js b/node_modules/renderkid/lib/renderKid/styleApplier/_common.js new file mode 100644 index 000000000..8e3bc5627 --- /dev/null +++ b/node_modules/renderkid/lib/renderKid/styleApplier/_common.js @@ -0,0 +1,35 @@ +// Generated by CoffeeScript 1.9.3 +var AnsiPainter, _common; + +AnsiPainter = require('../../AnsiPainter'); + +module.exports = _common = { + getStyleTagsFor: function(style) { + var i, len, ret, tag, tagName, tagsToAdd; + tagsToAdd = []; + if (style.color != null) { + tagName = 'color-' + style.color; + if (AnsiPainter.tags[tagName] == null) { + throw Error("Unkown color `" + style.color + "`"); + } + tagsToAdd.push(tagName); + } + if (style.background != null) { + tagName = 'bg-' + style.background; + if (AnsiPainter.tags[tagName] == null) { + throw Error("Unkown background `" + style.background + "`"); + } + tagsToAdd.push(tagName); + } + ret = { + before: '', + after: '' + }; + for (i = 0, len = tagsToAdd.length; i < len; i++) { + tag = tagsToAdd[i]; + ret.before = ("<" + tag + ">") + ret.before; + ret.after = ret.after + ("</" + tag + ">"); + } + return ret; + } +}; diff --git a/node_modules/renderkid/lib/renderKid/styleApplier/block.js b/node_modules/renderkid/lib/renderKid/styleApplier/block.js new file mode 100644 index 000000000..de091d72b --- /dev/null +++ b/node_modules/renderkid/lib/renderKid/styleApplier/block.js @@ -0,0 +1,83 @@ +// Generated by CoffeeScript 1.9.3 +var _common, blockStyleApplier, object, self; + +_common = require('./_common'); + +object = require('utila').object; + +module.exports = blockStyleApplier = self = { + applyTo: function(el, style) { + var config, ret; + ret = _common.getStyleTagsFor(style); + ret.blockConfig = config = {}; + this._margins(style, config); + this._bullet(style, config); + this._dims(style, config); + return ret; + }, + _margins: function(style, config) { + if (style.marginLeft != null) { + object.appendOnto(config, { + linePrependor: { + options: { + amount: parseInt(style.marginLeft) + } + } + }); + } + if (style.marginRight != null) { + object.appendOnto(config, { + lineAppendor: { + options: { + amount: parseInt(style.marginRight) + } + } + }); + } + if (style.marginTop != null) { + object.appendOnto(config, { + blockPrependor: { + options: { + amount: parseInt(style.marginTop) + } + } + }); + } + if (style.marginBottom != null) { + object.appendOnto(config, { + blockAppendor: { + options: { + amount: parseInt(style.marginBottom) + } + } + }); + } + }, + _bullet: function(style, config) { + var after, before, bullet, conf, ref; + if ((style.bullet != null) && style.bullet.enabled) { + bullet = style.bullet; + conf = {}; + conf.alignment = style.bullet.alignment; + ref = _common.getStyleTagsFor({ + color: bullet.color, + background: bullet.background + }), before = ref.before, after = ref.after; + conf.char = before + bullet.char + after; + object.appendOnto(config, { + linePrependor: { + options: { + bullet: conf + } + } + }); + } + }, + _dims: function(style, config) { + var w; + if (style.width != null) { + w = parseInt(style.width); + config.width = w; + } + } +}; diff --git a/node_modules/renderkid/lib/renderKid/styleApplier/inline.js b/node_modules/renderkid/lib/renderKid/styleApplier/inline.js new file mode 100644 index 000000000..0978fb07d --- /dev/null +++ b/node_modules/renderkid/lib/renderKid/styleApplier/inline.js @@ -0,0 +1,26 @@ +// Generated by CoffeeScript 1.9.3 +var _common, inlineStyleApplier, self, tools; + +tools = require('../../tools'); + +_common = require('./_common'); + +module.exports = inlineStyleApplier = self = { + applyTo: function(el, style) { + var ret; + ret = _common.getStyleTagsFor(style); + if (style.marginLeft != null) { + ret.before = (tools.repeatString("&sp;", parseInt(style.marginLeft))) + ret.before; + } + if (style.marginRight != null) { + ret.after += tools.repeatString("&sp;", parseInt(style.marginRight)); + } + if (style.paddingLeft != null) { + ret.before += tools.repeatString("&sp;", parseInt(style.paddingLeft)); + } + if (style.paddingRight != null) { + ret.after = (tools.repeatString("&sp;", parseInt(style.paddingRight))) + ret.after; + } + return ret; + } +}; diff --git a/node_modules/renderkid/lib/renderKid/styles/Rule.js b/node_modules/renderkid/lib/renderKid/styles/Rule.js new file mode 100644 index 000000000..8e289281a --- /dev/null +++ b/node_modules/renderkid/lib/renderKid/styles/Rule.js @@ -0,0 +1,21 @@ +// Generated by CoffeeScript 1.9.3 +var DeclarationBlock, Rule, Selector; + +Selector = require('./rule/Selector'); + +DeclarationBlock = require('./rule/DeclarationBlock'); + +module.exports = Rule = (function() { + function Rule(selector) { + this.selector = new Selector(selector); + this.styles = new DeclarationBlock; + } + + Rule.prototype.setStyles = function(styles) { + this.styles.set(styles); + return this; + }; + + return Rule; + +})(); diff --git a/node_modules/renderkid/lib/renderKid/styles/StyleSheet.js b/node_modules/renderkid/lib/renderKid/styles/StyleSheet.js new file mode 100644 index 000000000..2ea260751 --- /dev/null +++ b/node_modules/renderkid/lib/renderKid/styles/StyleSheet.js @@ -0,0 +1,72 @@ +// Generated by CoffeeScript 1.9.3 +var Rule, StyleSheet; + +Rule = require('./Rule'); + +module.exports = StyleSheet = (function() { + var self; + + self = StyleSheet; + + function StyleSheet() { + this._rulesBySelector = {}; + } + + StyleSheet.prototype.setRule = function(selector, styles) { + var key, val; + if (typeof selector === 'string') { + this._setRule(selector, styles); + } else if (typeof selector === 'object') { + for (key in selector) { + val = selector[key]; + this._setRule(key, val); + } + } + return this; + }; + + StyleSheet.prototype._setRule = function(s, styles) { + var i, len, ref, selector; + ref = self.splitSelectors(s); + for (i = 0, len = ref.length; i < len; i++) { + selector = ref[i]; + this._setSingleRule(selector, styles); + } + return this; + }; + + StyleSheet.prototype._setSingleRule = function(s, styles) { + var rule, selector; + selector = self.normalizeSelector(s); + if (!(rule = this._rulesBySelector[selector])) { + rule = new Rule(selector); + this._rulesBySelector[selector] = rule; + } + rule.setStyles(styles); + return this; + }; + + StyleSheet.prototype.getRulesFor = function(el) { + var ref, rule, rules, selector; + rules = []; + ref = this._rulesBySelector; + for (selector in ref) { + rule = ref[selector]; + if (rule.selector.matches(el)) { + rules.push(rule); + } + } + return rules; + }; + + StyleSheet.normalizeSelector = function(selector) { + return selector.replace(/[\s]+/g, ' ').replace(/[\s]*([>\,\+]{1})[\s]*/g, '$1').trim(); + }; + + StyleSheet.splitSelectors = function(s) { + return s.trim().split(','); + }; + + return StyleSheet; + +})(); diff --git a/node_modules/renderkid/lib/renderKid/styles/rule/DeclarationBlock.js b/node_modules/renderkid/lib/renderKid/styles/rule/DeclarationBlock.js new file mode 100644 index 000000000..b2821804b --- /dev/null +++ b/node_modules/renderkid/lib/renderKid/styles/rule/DeclarationBlock.js @@ -0,0 +1,65 @@ +// Generated by CoffeeScript 1.9.3 +var Arbitrary, DeclarationBlock, declarationClasses; + +module.exports = DeclarationBlock = (function() { + var self; + + self = DeclarationBlock; + + function DeclarationBlock() { + this._declarations = {}; + } + + DeclarationBlock.prototype.set = function(prop, value) { + var key, val; + if (typeof prop === 'object') { + for (key in prop) { + val = prop[key]; + this.set(key, val); + } + return this; + } + prop = self.sanitizeProp(prop); + this._getDeclarationClass(prop).setOnto(this._declarations, prop, value); + return this; + }; + + DeclarationBlock.prototype._getDeclarationClass = function(prop) { + var cls; + if (prop[0] === '_') { + return Arbitrary; + } + if (!(cls = declarationClasses[prop])) { + throw Error("Unkown property `" + prop + "`. Write it as `_" + prop + "` if you're defining a custom property"); + } + return cls; + }; + + DeclarationBlock.sanitizeProp = function(prop) { + return String(prop).trim(); + }; + + return DeclarationBlock; + +})(); + +Arbitrary = require('./declarationBlock/Arbitrary'); + +declarationClasses = { + color: require('./declarationBlock/Color'), + background: require('./declarationBlock/Background'), + width: require('./declarationBlock/Width'), + height: require('./declarationBlock/Height'), + bullet: require('./declarationBlock/Bullet'), + display: require('./declarationBlock/Display'), + margin: require('./declarationBlock/Margin'), + marginTop: require('./declarationBlock/MarginTop'), + marginLeft: require('./declarationBlock/MarginLeft'), + marginRight: require('./declarationBlock/MarginRight'), + marginBottom: require('./declarationBlock/MarginBottom'), + padding: require('./declarationBlock/Padding'), + paddingTop: require('./declarationBlock/PaddingTop'), + paddingLeft: require('./declarationBlock/PaddingLeft'), + paddingRight: require('./declarationBlock/PaddingRight'), + paddingBottom: require('./declarationBlock/PaddingBottom') +}; diff --git a/node_modules/renderkid/lib/renderKid/styles/rule/MixedDeclarationSet.js b/node_modules/renderkid/lib/renderKid/styles/rule/MixedDeclarationSet.js new file mode 100644 index 000000000..ceea06ed7 --- /dev/null +++ b/node_modules/renderkid/lib/renderKid/styles/rule/MixedDeclarationSet.js @@ -0,0 +1,78 @@ +// Generated by CoffeeScript 1.9.3 +var MixedDeclarationSet, + slice = [].slice; + +module.exports = MixedDeclarationSet = (function() { + var self; + + self = MixedDeclarationSet; + + MixedDeclarationSet.mix = function() { + var i, len, mixed, ruleSets, rules; + ruleSets = 1 <= arguments.length ? slice.call(arguments, 0) : []; + mixed = new self; + for (i = 0, len = ruleSets.length; i < len; i++) { + rules = ruleSets[i]; + mixed.mixWithList(rules); + } + return mixed; + }; + + function MixedDeclarationSet() { + this._declarations = {}; + } + + MixedDeclarationSet.prototype.mixWithList = function(rules) { + var i, len, rule; + rules.sort(function(a, b) { + return a.selector.priority > b.selector.priority; + }); + for (i = 0, len = rules.length; i < len; i++) { + rule = rules[i]; + this._mixWithRule(rule); + } + return this; + }; + + MixedDeclarationSet.prototype._mixWithRule = function(rule) { + var dec, prop, ref; + ref = rule.styles._declarations; + for (prop in ref) { + dec = ref[prop]; + this._mixWithDeclaration(dec); + } + }; + + MixedDeclarationSet.prototype._mixWithDeclaration = function(dec) { + var cur; + cur = this._declarations[dec.prop]; + if ((cur != null) && cur.important && !dec.important) { + return; + } + this._declarations[dec.prop] = dec; + }; + + MixedDeclarationSet.prototype.get = function(prop) { + if (prop == null) { + return this._declarations; + } + if (this._declarations[prop] == null) { + return null; + } + return this._declarations[prop].val; + }; + + MixedDeclarationSet.prototype.toObject = function() { + var dec, obj, prop, ref; + obj = {}; + ref = this._declarations; + for (prop in ref) { + dec = ref[prop]; + obj[prop] = dec.val; + } + return obj; + }; + + return MixedDeclarationSet; + +})(); diff --git a/node_modules/renderkid/lib/renderKid/styles/rule/Selector.js b/node_modules/renderkid/lib/renderKid/styles/rule/Selector.js new file mode 100644 index 000000000..7b23903d3 --- /dev/null +++ b/node_modules/renderkid/lib/renderKid/styles/rule/Selector.js @@ -0,0 +1,38 @@ +// Generated by CoffeeScript 1.9.3 +var CSSSelect, Selector; + +CSSSelect = require('css-select'); + +module.exports = Selector = (function() { + var self; + + self = Selector; + + function Selector(text1) { + this.text = text1; + this._fn = CSSSelect.compile(this.text); + this.priority = self.calculatePriority(this.text); + } + + Selector.prototype.matches = function(elem) { + return CSSSelect.is(elem, this._fn); + }; + + Selector.calculatePriority = function(text) { + var n, priotrity; + priotrity = 0; + if (n = text.match(/[\#]{1}/g)) { + priotrity += 100 * n.length; + } + if (n = text.match(/[a-zA-Z]+/g)) { + priotrity += 2 * n.length; + } + if (n = text.match(/\*/g)) { + priotrity += 1 * n.length; + } + return priotrity; + }; + + return Selector; + +})(); diff --git a/node_modules/renderkid/lib/renderKid/styles/rule/declarationBlock/Arbitrary.js b/node_modules/renderkid/lib/renderKid/styles/rule/declarationBlock/Arbitrary.js new file mode 100644 index 000000000..5411b3a73 --- /dev/null +++ b/node_modules/renderkid/lib/renderKid/styles/rule/declarationBlock/Arbitrary.js @@ -0,0 +1,17 @@ +// Generated by CoffeeScript 1.9.3 +var Arbitrary, _Declaration, + extend = function(child, parent) { for (var key in parent) { if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; }, + hasProp = {}.hasOwnProperty; + +_Declaration = require('./_Declaration'); + +module.exports = Arbitrary = (function(superClass) { + extend(Arbitrary, superClass); + + function Arbitrary() { + return Arbitrary.__super__.constructor.apply(this, arguments); + } + + return Arbitrary; + +})(_Declaration); diff --git a/node_modules/renderkid/lib/renderKid/styles/rule/declarationBlock/Background.js b/node_modules/renderkid/lib/renderKid/styles/rule/declarationBlock/Background.js new file mode 100644 index 000000000..e02b377cd --- /dev/null +++ b/node_modules/renderkid/lib/renderKid/styles/rule/declarationBlock/Background.js @@ -0,0 +1,17 @@ +// Generated by CoffeeScript 1.9.3 +var Background, _Declaration, + extend = function(child, parent) { for (var key in parent) { if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; }, + hasProp = {}.hasOwnProperty; + +_Declaration = require('./_Declaration'); + +module.exports = Background = (function(superClass) { + extend(Background, superClass); + + function Background() { + return Background.__super__.constructor.apply(this, arguments); + } + + return Background; + +})(_Declaration); diff --git a/node_modules/renderkid/lib/renderKid/styles/rule/declarationBlock/Bullet.js b/node_modules/renderkid/lib/renderKid/styles/rule/declarationBlock/Bullet.js new file mode 100644 index 000000000..a04e0c7be --- /dev/null +++ b/node_modules/renderkid/lib/renderKid/styles/rule/declarationBlock/Bullet.js @@ -0,0 +1,63 @@ +// Generated by CoffeeScript 1.9.3 +var Bullet, _Declaration, + extend = function(child, parent) { for (var key in parent) { if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; }, + hasProp = {}.hasOwnProperty; + +_Declaration = require('./_Declaration'); + +module.exports = Bullet = (function(superClass) { + var self; + + extend(Bullet, superClass); + + function Bullet() { + return Bullet.__super__.constructor.apply(this, arguments); + } + + self = Bullet; + + Bullet.prototype._set = function(val) { + var alignment, bg, char, color, enabled, m, original; + val = String(val); + original = val; + char = null; + enabled = false; + color = 'none'; + bg = 'none'; + if (m = val.match(/\"([^"]+)\"/) || (m = val.match(/\'([^']+)\'/))) { + char = m[1]; + val = val.replace(m[0], ''); + enabled = true; + } + if (m = val.match(/(none|left|right|center)/)) { + alignment = m[1]; + val = val.replace(m[0], ''); + } else { + alignment = 'left'; + } + if (alignment === 'none') { + enabled = false; + } + if (m = val.match(/color\:([\w\-]+)/)) { + color = m[1]; + val = val.replace(m[0], ''); + } + if (m = val.match(/bg\:([\w\-]+)/)) { + bg = m[1]; + val = val.replace(m[0], ''); + } + if (val.trim() !== '') { + throw Error("Unrecognizable value `" + original + "` for `" + this.prop + "`"); + } + return this.val = { + enabled: enabled, + char: char, + alignment: alignment, + background: bg, + color: color + }; + }; + + return Bullet; + +})(_Declaration); diff --git a/node_modules/renderkid/lib/renderKid/styles/rule/declarationBlock/Color.js b/node_modules/renderkid/lib/renderKid/styles/rule/declarationBlock/Color.js new file mode 100644 index 000000000..709dd89ea --- /dev/null +++ b/node_modules/renderkid/lib/renderKid/styles/rule/declarationBlock/Color.js @@ -0,0 +1,17 @@ +// Generated by CoffeeScript 1.9.3 +var Color, _Declaration, + extend = function(child, parent) { for (var key in parent) { if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; }, + hasProp = {}.hasOwnProperty; + +_Declaration = require('./_Declaration'); + +module.exports = Color = (function(superClass) { + extend(Color, superClass); + + function Color() { + return Color.__super__.constructor.apply(this, arguments); + } + + return Color; + +})(_Declaration); diff --git a/node_modules/renderkid/lib/renderKid/styles/rule/declarationBlock/Display.js b/node_modules/renderkid/lib/renderKid/styles/rule/declarationBlock/Display.js new file mode 100644 index 000000000..80a9ae440 --- /dev/null +++ b/node_modules/renderkid/lib/renderKid/styles/rule/declarationBlock/Display.js @@ -0,0 +1,32 @@ +// Generated by CoffeeScript 1.9.3 +var Display, _Declaration, + extend = function(child, parent) { for (var key in parent) { if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; }, + hasProp = {}.hasOwnProperty, + indexOf = [].indexOf || function(item) { for (var i = 0, l = this.length; i < l; i++) { if (i in this && this[i] === item) return i; } return -1; }; + +_Declaration = require('./_Declaration'); + +module.exports = Display = (function(superClass) { + var self; + + extend(Display, superClass); + + function Display() { + return Display.__super__.constructor.apply(this, arguments); + } + + self = Display; + + Display._allowed = ['inline', 'block', 'none']; + + Display.prototype._set = function(val) { + val = String(val).toLowerCase(); + if (indexOf.call(self._allowed, val) < 0) { + throw Error("Unrecognizable value `" + val + "` for `" + this.prop + "`"); + } + return this.val = val; + }; + + return Display; + +})(_Declaration); diff --git a/node_modules/renderkid/lib/renderKid/styles/rule/declarationBlock/Height.js b/node_modules/renderkid/lib/renderKid/styles/rule/declarationBlock/Height.js new file mode 100644 index 000000000..35bf7ba78 --- /dev/null +++ b/node_modules/renderkid/lib/renderKid/styles/rule/declarationBlock/Height.js @@ -0,0 +1,17 @@ +// Generated by CoffeeScript 1.9.3 +var Height, _Length, + extend = function(child, parent) { for (var key in parent) { if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; }, + hasProp = {}.hasOwnProperty; + +_Length = require('./_Length'); + +module.exports = Height = (function(superClass) { + extend(Height, superClass); + + function Height() { + return Height.__super__.constructor.apply(this, arguments); + } + + return Height; + +})(_Length); diff --git a/node_modules/renderkid/lib/renderKid/styles/rule/declarationBlock/Margin.js b/node_modules/renderkid/lib/renderKid/styles/rule/declarationBlock/Margin.js new file mode 100644 index 000000000..6dfe0764d --- /dev/null +++ b/node_modules/renderkid/lib/renderKid/styles/rule/declarationBlock/Margin.js @@ -0,0 +1,64 @@ +// Generated by CoffeeScript 1.9.3 +var Margin, MarginBottom, MarginLeft, MarginRight, MarginTop, _Declaration, + extend = function(child, parent) { for (var key in parent) { if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; }, + hasProp = {}.hasOwnProperty; + +_Declaration = require('./_Declaration'); + +MarginTop = require('./MarginTop'); + +MarginLeft = require('./MarginLeft'); + +MarginRight = require('./MarginRight'); + +MarginBottom = require('./MarginBottom'); + +module.exports = Margin = (function(superClass) { + var self; + + extend(Margin, superClass); + + function Margin() { + return Margin.__super__.constructor.apply(this, arguments); + } + + self = Margin; + + Margin.setOnto = function(declarations, prop, originalValue) { + var append, val, vals; + append = ''; + val = _Declaration.sanitizeValue(originalValue); + if (_Declaration.importantClauseRx.test(String(val))) { + append = ' !important'; + val = val.replace(_Declaration.importantClauseRx, ''); + } + val = val.trim(); + if (val.length === 0) { + return self._setAllDirections(declarations, append, append, append, append); + } + vals = val.split(" ").map(function(val) { + return val + append; + }); + if (vals.length === 1) { + return self._setAllDirections(declarations, vals[0], vals[0], vals[0], vals[0]); + } else if (vals.length === 2) { + return self._setAllDirections(declarations, vals[0], vals[1], vals[0], vals[1]); + } else if (vals.length === 3) { + return self._setAllDirections(declarations, vals[0], vals[1], vals[2], vals[1]); + } else if (vals.length === 4) { + return self._setAllDirections(declarations, vals[0], vals[1], vals[2], vals[3]); + } else { + throw Error("Can't understand value for margin: `" + originalValue + "`"); + } + }; + + Margin._setAllDirections = function(declarations, top, right, bottom, left) { + MarginTop.setOnto(declarations, 'marginTop', top); + MarginTop.setOnto(declarations, 'marginRight', right); + MarginTop.setOnto(declarations, 'marginBottom', bottom); + MarginTop.setOnto(declarations, 'marginLeft', left); + }; + + return Margin; + +})(_Declaration); diff --git a/node_modules/renderkid/lib/renderKid/styles/rule/declarationBlock/MarginBottom.js b/node_modules/renderkid/lib/renderKid/styles/rule/declarationBlock/MarginBottom.js new file mode 100644 index 000000000..45f2e21af --- /dev/null +++ b/node_modules/renderkid/lib/renderKid/styles/rule/declarationBlock/MarginBottom.js @@ -0,0 +1,17 @@ +// Generated by CoffeeScript 1.9.3 +var MarginBottom, _Length, + extend = function(child, parent) { for (var key in parent) { if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; }, + hasProp = {}.hasOwnProperty; + +_Length = require('./_Length'); + +module.exports = MarginBottom = (function(superClass) { + extend(MarginBottom, superClass); + + function MarginBottom() { + return MarginBottom.__super__.constructor.apply(this, arguments); + } + + return MarginBottom; + +})(_Length); diff --git a/node_modules/renderkid/lib/renderKid/styles/rule/declarationBlock/MarginLeft.js b/node_modules/renderkid/lib/renderKid/styles/rule/declarationBlock/MarginLeft.js new file mode 100644 index 000000000..e4b1ddd6d --- /dev/null +++ b/node_modules/renderkid/lib/renderKid/styles/rule/declarationBlock/MarginLeft.js @@ -0,0 +1,17 @@ +// Generated by CoffeeScript 1.9.3 +var MarginLeft, _Length, + extend = function(child, parent) { for (var key in parent) { if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; }, + hasProp = {}.hasOwnProperty; + +_Length = require('./_Length'); + +module.exports = MarginLeft = (function(superClass) { + extend(MarginLeft, superClass); + + function MarginLeft() { + return MarginLeft.__super__.constructor.apply(this, arguments); + } + + return MarginLeft; + +})(_Length); diff --git a/node_modules/renderkid/lib/renderKid/styles/rule/declarationBlock/MarginRight.js b/node_modules/renderkid/lib/renderKid/styles/rule/declarationBlock/MarginRight.js new file mode 100644 index 000000000..3d6fcdc03 --- /dev/null +++ b/node_modules/renderkid/lib/renderKid/styles/rule/declarationBlock/MarginRight.js @@ -0,0 +1,17 @@ +// Generated by CoffeeScript 1.9.3 +var MarginRight, _Length, + extend = function(child, parent) { for (var key in parent) { if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; }, + hasProp = {}.hasOwnProperty; + +_Length = require('./_Length'); + +module.exports = MarginRight = (function(superClass) { + extend(MarginRight, superClass); + + function MarginRight() { + return MarginRight.__super__.constructor.apply(this, arguments); + } + + return MarginRight; + +})(_Length); diff --git a/node_modules/renderkid/lib/renderKid/styles/rule/declarationBlock/MarginTop.js b/node_modules/renderkid/lib/renderKid/styles/rule/declarationBlock/MarginTop.js new file mode 100644 index 000000000..ffd5ef329 --- /dev/null +++ b/node_modules/renderkid/lib/renderKid/styles/rule/declarationBlock/MarginTop.js @@ -0,0 +1,17 @@ +// Generated by CoffeeScript 1.9.3 +var MarginTop, _Length, + extend = function(child, parent) { for (var key in parent) { if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; }, + hasProp = {}.hasOwnProperty; + +_Length = require('./_Length'); + +module.exports = MarginTop = (function(superClass) { + extend(MarginTop, superClass); + + function MarginTop() { + return MarginTop.__super__.constructor.apply(this, arguments); + } + + return MarginTop; + +})(_Length); diff --git a/node_modules/renderkid/lib/renderKid/styles/rule/declarationBlock/Padding.js b/node_modules/renderkid/lib/renderKid/styles/rule/declarationBlock/Padding.js new file mode 100644 index 000000000..9681204ba --- /dev/null +++ b/node_modules/renderkid/lib/renderKid/styles/rule/declarationBlock/Padding.js @@ -0,0 +1,64 @@ +// Generated by CoffeeScript 1.9.3 +var Padding, PaddingBottom, PaddingLeft, PaddingRight, PaddingTop, _Declaration, + extend = function(child, parent) { for (var key in parent) { if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; }, + hasProp = {}.hasOwnProperty; + +_Declaration = require('./_Declaration'); + +PaddingTop = require('./PaddingTop'); + +PaddingLeft = require('./PaddingLeft'); + +PaddingRight = require('./PaddingRight'); + +PaddingBottom = require('./PaddingBottom'); + +module.exports = Padding = (function(superClass) { + var self; + + extend(Padding, superClass); + + function Padding() { + return Padding.__super__.constructor.apply(this, arguments); + } + + self = Padding; + + Padding.setOnto = function(declarations, prop, originalValue) { + var append, val, vals; + append = ''; + val = _Declaration.sanitizeValue(originalValue); + if (_Declaration.importantClauseRx.test(String(val))) { + append = ' !important'; + val = val.replace(_Declaration.importantClauseRx, ''); + } + val = val.trim(); + if (val.length === 0) { + return self._setAllDirections(declarations, append, append, append, append); + } + vals = val.split(" ").map(function(val) { + return val + append; + }); + if (vals.length === 1) { + return self._setAllDirections(declarations, vals[0], vals[0], vals[0], vals[0]); + } else if (vals.length === 2) { + return self._setAllDirections(declarations, vals[0], vals[1], vals[0], vals[1]); + } else if (vals.length === 3) { + return self._setAllDirections(declarations, vals[0], vals[1], vals[2], vals[1]); + } else if (vals.length === 4) { + return self._setAllDirections(declarations, vals[0], vals[1], vals[2], vals[3]); + } else { + throw Error("Can't understand value for padding: `" + originalValue + "`"); + } + }; + + Padding._setAllDirections = function(declarations, top, right, bottom, left) { + PaddingTop.setOnto(declarations, 'paddingTop', top); + PaddingTop.setOnto(declarations, 'paddingRight', right); + PaddingTop.setOnto(declarations, 'paddingBottom', bottom); + PaddingTop.setOnto(declarations, 'paddingLeft', left); + }; + + return Padding; + +})(_Declaration); diff --git a/node_modules/renderkid/lib/renderKid/styles/rule/declarationBlock/PaddingBottom.js b/node_modules/renderkid/lib/renderKid/styles/rule/declarationBlock/PaddingBottom.js new file mode 100644 index 000000000..7052a6064 --- /dev/null +++ b/node_modules/renderkid/lib/renderKid/styles/rule/declarationBlock/PaddingBottom.js @@ -0,0 +1,17 @@ +// Generated by CoffeeScript 1.9.3 +var PaddingBottom, _Length, + extend = function(child, parent) { for (var key in parent) { if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; }, + hasProp = {}.hasOwnProperty; + +_Length = require('./_Length'); + +module.exports = PaddingBottom = (function(superClass) { + extend(PaddingBottom, superClass); + + function PaddingBottom() { + return PaddingBottom.__super__.constructor.apply(this, arguments); + } + + return PaddingBottom; + +})(_Length); diff --git a/node_modules/renderkid/lib/renderKid/styles/rule/declarationBlock/PaddingLeft.js b/node_modules/renderkid/lib/renderKid/styles/rule/declarationBlock/PaddingLeft.js new file mode 100644 index 000000000..35d5fbd68 --- /dev/null +++ b/node_modules/renderkid/lib/renderKid/styles/rule/declarationBlock/PaddingLeft.js @@ -0,0 +1,17 @@ +// Generated by CoffeeScript 1.9.3 +var PaddingLeft, _Length, + extend = function(child, parent) { for (var key in parent) { if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; }, + hasProp = {}.hasOwnProperty; + +_Length = require('./_Length'); + +module.exports = PaddingLeft = (function(superClass) { + extend(PaddingLeft, superClass); + + function PaddingLeft() { + return PaddingLeft.__super__.constructor.apply(this, arguments); + } + + return PaddingLeft; + +})(_Length); diff --git a/node_modules/renderkid/lib/renderKid/styles/rule/declarationBlock/PaddingRight.js b/node_modules/renderkid/lib/renderKid/styles/rule/declarationBlock/PaddingRight.js new file mode 100644 index 000000000..31d2af99c --- /dev/null +++ b/node_modules/renderkid/lib/renderKid/styles/rule/declarationBlock/PaddingRight.js @@ -0,0 +1,17 @@ +// Generated by CoffeeScript 1.9.3 +var PaddingRight, _Length, + extend = function(child, parent) { for (var key in parent) { if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; }, + hasProp = {}.hasOwnProperty; + +_Length = require('./_Length'); + +module.exports = PaddingRight = (function(superClass) { + extend(PaddingRight, superClass); + + function PaddingRight() { + return PaddingRight.__super__.constructor.apply(this, arguments); + } + + return PaddingRight; + +})(_Length); diff --git a/node_modules/renderkid/lib/renderKid/styles/rule/declarationBlock/PaddingTop.js b/node_modules/renderkid/lib/renderKid/styles/rule/declarationBlock/PaddingTop.js new file mode 100644 index 000000000..a6cf14ac3 --- /dev/null +++ b/node_modules/renderkid/lib/renderKid/styles/rule/declarationBlock/PaddingTop.js @@ -0,0 +1,17 @@ +// Generated by CoffeeScript 1.9.3 +var PaddingTop, _Length, + extend = function(child, parent) { for (var key in parent) { if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; }, + hasProp = {}.hasOwnProperty; + +_Length = require('./_Length'); + +module.exports = PaddingTop = (function(superClass) { + extend(PaddingTop, superClass); + + function PaddingTop() { + return PaddingTop.__super__.constructor.apply(this, arguments); + } + + return PaddingTop; + +})(_Length); diff --git a/node_modules/renderkid/lib/renderKid/styles/rule/declarationBlock/Width.js b/node_modules/renderkid/lib/renderKid/styles/rule/declarationBlock/Width.js new file mode 100644 index 000000000..4f573b62f --- /dev/null +++ b/node_modules/renderkid/lib/renderKid/styles/rule/declarationBlock/Width.js @@ -0,0 +1,17 @@ +// Generated by CoffeeScript 1.9.3 +var Width, _Length, + extend = function(child, parent) { for (var key in parent) { if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; }, + hasProp = {}.hasOwnProperty; + +_Length = require('./_Length'); + +module.exports = Width = (function(superClass) { + extend(Width, superClass); + + function Width() { + return Width.__super__.constructor.apply(this, arguments); + } + + return Width; + +})(_Length); diff --git a/node_modules/renderkid/lib/renderKid/styles/rule/declarationBlock/_Declaration.js b/node_modules/renderkid/lib/renderKid/styles/rule/declarationBlock/_Declaration.js new file mode 100644 index 000000000..dce27e213 --- /dev/null +++ b/node_modules/renderkid/lib/renderKid/styles/rule/declarationBlock/_Declaration.js @@ -0,0 +1,84 @@ +// Generated by CoffeeScript 1.9.3 +var _Declaration; + +module.exports = _Declaration = (function() { + var self; + + self = _Declaration; + + _Declaration.importantClauseRx = /(\s\!important)$/; + + _Declaration.setOnto = function(declarations, prop, val) { + var dec; + if (!(dec = declarations[prop])) { + return declarations[prop] = new this(prop, val); + } else { + return dec.set(val); + } + }; + + _Declaration.sanitizeValue = function(val) { + return String(val).trim().replace(/[\s]+/g, ' '); + }; + + _Declaration.inheritAllowed = false; + + function _Declaration(prop1, val) { + this.prop = prop1; + this.important = false; + this.set(val); + } + + _Declaration.prototype.get = function() { + return this._get(); + }; + + _Declaration.prototype._get = function() { + return this.val; + }; + + _Declaration.prototype._pickImportantClause = function(val) { + if (self.importantClauseRx.test(String(val))) { + this.important = true; + return val.replace(self.importantClauseRx, ''); + } else { + this.important = false; + return val; + } + }; + + _Declaration.prototype.set = function(val) { + val = self.sanitizeValue(val); + val = this._pickImportantClause(val); + val = val.trim(); + if (this._handleNullOrInherit(val)) { + return this; + } + this._set(val); + return this; + }; + + _Declaration.prototype._set = function(val) { + return this.val = val; + }; + + _Declaration.prototype._handleNullOrInherit = function(val) { + if (val === '') { + this.val = ''; + return true; + } + if (val === 'inherit') { + if (this.constructor.inheritAllowed) { + this.val = 'inherit'; + } else { + throw Error("Inherit is not allowed for `" + this.prop + "`"); + } + return true; + } else { + return false; + } + }; + + return _Declaration; + +})(); diff --git a/node_modules/renderkid/lib/renderKid/styles/rule/declarationBlock/_Length.js b/node_modules/renderkid/lib/renderKid/styles/rule/declarationBlock/_Length.js new file mode 100644 index 000000000..0440d30c3 --- /dev/null +++ b/node_modules/renderkid/lib/renderKid/styles/rule/declarationBlock/_Length.js @@ -0,0 +1,24 @@ +// Generated by CoffeeScript 1.9.3 +var _Declaration, _Length, + extend = function(child, parent) { for (var key in parent) { if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; }, + hasProp = {}.hasOwnProperty; + +_Declaration = require('./_Declaration'); + +module.exports = _Length = (function(superClass) { + extend(_Length, superClass); + + function _Length() { + return _Length.__super__.constructor.apply(this, arguments); + } + + _Length.prototype._set = function(val) { + if (!/^[0-9]+$/.test(String(val))) { + throw Error("`" + this.prop + "` only takes an integer for value"); + } + return this.val = parseInt(val); + }; + + return _Length; + +})(_Declaration); diff --git a/node_modules/renderkid/lib/tools.js b/node_modules/renderkid/lib/tools.js new file mode 100644 index 000000000..80be44746 --- /dev/null +++ b/node_modules/renderkid/lib/tools.js @@ -0,0 +1,88 @@ +// Generated by CoffeeScript 1.9.3 +var htmlparser, object, objectToDom, self; + +htmlparser = require('htmlparser2'); + +object = require('utila').object; + +objectToDom = require('dom-converter').objectToDom; + +module.exports = self = { + repeatString: function(str, times) { + var i, j, output, ref; + output = ''; + for (i = j = 0, ref = times; 0 <= ref ? j < ref : j > ref; i = 0 <= ref ? ++j : --j) { + output += str; + } + return output; + }, + toDom: function(subject) { + if (typeof subject === 'string') { + return self.stringToDom(subject); + } else if (object.isBareObject(subject)) { + return self._objectToDom(subject); + } else { + throw Error("tools.toDom() only supports strings and objects"); + } + }, + stringToDom: function(string) { + var handler, parser; + handler = new htmlparser.DomHandler; + parser = new htmlparser.Parser(handler); + parser.write(string); + parser.end(); + return handler.dom; + }, + _fixQuotesInDom: function(input) { + var j, len, node; + if (Array.isArray(input)) { + for (j = 0, len = input.length; j < len; j++) { + node = input[j]; + self._fixQuotesInDom(node); + } + return input; + } + node = input; + if (node.type === 'text') { + return node.data = self._quoteNodeText(node.data); + } else { + return self._fixQuotesInDom(node.children); + } + }, + objectToDom: function(o) { + if (!Array.isArray(o)) { + if (!object.isBareObject(o)) { + throw Error("objectToDom() only accepts a bare object or an array"); + } + } + return self._fixQuotesInDom(objectToDom(o)); + }, + quote: function(str) { + return String(str).replace(/</g, '<').replace(/>/g, '>').replace(/\"/g, '"').replace(/\ /g, '&sp;').replace(/\n/g, '<br />'); + }, + _quoteNodeText: function(text) { + return String(text).replace(/\&/g, '&').replace(/</g, '<').replace(/>/g, '>').replace(/\"/g, '"').replace(/\ /g, '&sp;').replace(/\n/g, "&nl;"); + }, + getCols: function() { + var cols, tty; + tty = require('tty'); + cols = (function() { + try { + if (tty.isatty(1) && tty.isatty(2)) { + if (process.stdout.getWindowSize) { + return process.stdout.getWindowSize(1)[0]; + } else if (tty.getWindowSize) { + return tty.getWindowSize()[1]; + } else if (process.stdout.columns && process.stdout.rows) { + return process.stdout.rows; + } + } + } catch (_error) {} + })(); + if (typeof cols === 'number' && cols > 30) { + return cols; + } else { + return 80; + } + } +}; diff --git a/node_modules/renderkid/package.json b/node_modules/renderkid/package.json new file mode 100644 index 000000000..77f1e6b67 --- /dev/null +++ b/node_modules/renderkid/package.json @@ -0,0 +1,43 @@ +{ + "name": "renderkid", + "version": "2.0.1", + "description": "Stylish console.log for node", + "main": "lib/RenderKid.js", + "dependencies": { + "css-select": "^1.1.0", + "dom-converter": "~0.1", + "htmlparser2": "~3.3.0", + "strip-ansi": "^3.0.0", + "utila": "~0.3" + }, + "devDependencies": { + "chai": "^2.2.0", + "chai-changes": "^1.3.4", + "chai-fuzzy": "^1.5.0", + "coffee-script": "^1.9.1", + "jitter": "^1.3.0", + "mocha": "^2.0.1", + "mocha-pretty-spec-reporter": "0.1.0-beta.2", + "sinon": "^1.14.1", + "sinon-chai": "^2.7.0", + "underscore": "^1.8.3" + }, + "scripts": { + "test": "mocha \"test/**/*.coffee\"", + "test:watch": "mocha \"test/**/*.coffee\" --watch", + "compile": "coffee --bare --compile --output ./lib ./src", + "compile:watch": "jitter src lib -b", + "watch": "npm run compile:watch & npm run test:watch", + "winwatch": "start/b npm run compile:watch & npm run test:watch", + "prepublish": "npm run compile" + }, + "repository": { + "type": "git", + "url": "https://github.com/AriaMinaei/RenderKid.git" + }, + "bugs": { + "url": "https://github.com/AriaMinaei/RenderKid/issues" + }, + "author": "Aria Minaei", + "license": "MIT" +} diff --git a/node_modules/renderkid/test/AnsiPainter.coffee b/node_modules/renderkid/test/AnsiPainter.coffee new file mode 100644 index 000000000..a33898675 --- /dev/null +++ b/node_modules/renderkid/test/AnsiPainter.coffee @@ -0,0 +1,22 @@ +AnsiPainter = require '../src/AnsiPainter' + +paint = (t) -> + AnsiPainter.paint(t) + +describe "AnsiPainter", -> + describe "paint()", -> + it "should handle basic coloring", -> + t = "<bg-white><black>a</black></bg-white>" + paint(t).should.equal '\u001b[30m\u001b[47ma\u001b[0m' + + it "should handle color in color", -> + t = "<red>a<blue>b</blue></red>" + paint(t).should.equal '\u001b[31ma\u001b[0m\u001b[34mb\u001b[0m' + + it "should skip empty tags", -> + t = "<blue></blue>a" + paint(t).should.equal 'a\u001b[0m' + + describe "_replaceSpecialStrings()", -> + it "should work", -> + AnsiPainter::_replaceSpecialStrings('<>"&sp;&').should.equal '<>" &'
\ No newline at end of file diff --git a/node_modules/renderkid/test/Layout.coffee b/node_modules/renderkid/test/Layout.coffee new file mode 100644 index 000000000..845502609 --- /dev/null +++ b/node_modules/renderkid/test/Layout.coffee @@ -0,0 +1,16 @@ +Layout = require '../src/Layout' + +describe "Layout", -> + describe "constructor()", -> + it "should create root block", -> + l = new Layout + expect(l._root).to.exist + l._root._name.should.equal '__root' + + describe "get()", -> + it "should not be allowed when any block is open", -> + l = new Layout + l.openBlock() + (-> + l.get() + ).should.throw Error
\ No newline at end of file diff --git a/node_modules/renderkid/test/RenderKid.coffee b/node_modules/renderkid/test/RenderKid.coffee new file mode 100644 index 000000000..3ca4852f5 --- /dev/null +++ b/node_modules/renderkid/test/RenderKid.coffee @@ -0,0 +1,273 @@ +RenderKid = require '../src/RenderKid' +{strip} = require '../src/AnsiPainter' + +match = (input, expected, setStuff) -> + r = new RenderKid + r.style + span: + display: 'inline' + div: + display: 'block' + + setStuff?(r) + strip(r.render(input)).trim().should.equal expected.trim() + +describe "RenderKid", -> + describe "constructor()", -> + it "should work", -> + new RenderKid + + describe "whitespace management - inline", -> + it "shouldn't put extra whitespaces", -> + input = """ + + a<span>b</span>c + + """ + + expected = """ + + abc + + """ + + match input, expected + + it "should allow 1 whitespace character on each side", -> + input = """ + + a<span> b </span>c + + """ + + expected = """ + + a b c + + """ + + match input, expected + + it "should eliminate extra whitespaces inside text", -> + input = """ + + a<span>b1 \n b2</span>c + + """ + + expected = """ + + ab1 b2c + + """ + + match input, expected + + it "should allow line breaks with <br />", -> + input = """ + + a<span>b1<br />b2</span>c + + """ + + expected = """ + + ab1\nb2c + + """ + + match input, expected + + it "should allow line breaks with &nl;", -> + input = """ + + a<span>b1&nl;b2</span>c + + """ + + expected = """ + + ab1\nb2c + + """ + + match input, expected + + it "should allow whitespaces with &sp;", -> + input = """ + + a<span>b1&sp;b2</span>c + + """ + + expected = """ + + ab1 b2c + + """ + + match input, expected + + describe "whitespace management - block", -> + it "should add one linebreak between two blocks", -> + input = """ + + <div>a</div> + <div>b</div> + + """ + + expected = """ + + a + b + + """ + + match input, expected + + it "should ignore empty blocks", -> + input = """ + + <div>a</div> + <div></div> + <div>b</div> + + """ + + expected = """ + + a + b + + """ + + match input, expected + + it "should add an extra linebreak between two adjacent blocks inside an inline", -> + input = """ + + <span> + <div>a</div> + <div>b</div> + </span> + + """ + + expected = """ + + a + + b + + """ + + match input, expected + + it "example: div(marginBottom:1)+div", -> + input = """ + + <div class="first">a</div> + <div>b</div> + + """ + + expected = """ + + a + + b + + """ + + match input, expected, (r) -> + r.style '.first': marginBottom: 1 + + it "example: div+div(marginTop:1)", -> + input = """ + + <div>a</div> + <div class="second">b</div> + + """ + + expected = """ + + a + + b + + """ + + match input, expected, (r) -> + r.style '.second': marginTop: 1 + + it "example: div(marginBottom:1)+div(marginTop:1)", -> + input = """ + + <div class="first">a</div> + <div class="second">b</div> + + """ + + expected = """ + + a + + + b + + """ + + match input, expected, (r) -> + r.style + '.first': marginBottom: 1 + '.second': marginTop: 1 + + it "example: div(marginBottom:2)+div(marginTop:1)", -> + input = """ + + <div class="first">a</div> + <div class="second">b</div> + + """ + + expected = """ + + a + + + + b + + """ + + match input, expected, (r) -> + r.style + '.first': marginBottom: 2 + '.second': marginTop: 1 + + it "example: div(marginBottom:2)+span+div(marginTop:1)", -> + input = """ + + <div class="first">a</div> + <span>span</span> + <div class="second">b</div> + + """ + + expected = """ + + a + + + span + + b + + """ + + match input, expected, (r) -> + r.style + '.first': marginBottom: 2 + '.second': marginTop: 1
\ No newline at end of file diff --git a/node_modules/renderkid/test/layout/Block.coffee b/node_modules/renderkid/test/layout/Block.coffee new file mode 100644 index 000000000..e5b5ebe38 --- /dev/null +++ b/node_modules/renderkid/test/layout/Block.coffee @@ -0,0 +1,312 @@ +Layout = require '../../src/Layout' +{object} = require 'utila' + +{open, get, conf} = do -> + show = (layout) -> + got = layout.get() + got = got.replace /<[^>]+>/g, '' + + defaultBlockConfig = + linePrependor: options: amount: 2 + + c = (add = {}) -> + object.append defaultBlockConfig, add + + ret = {} + + ret.open = (block, name, top = 0, bottom = 0) -> + config = c + blockPrependor: options: amount: top + blockAppendor: options: amount: bottom + + b = block.openBlock config, name + b.write name + ' | top ' + top + ' bottom ' + bottom + b + + ret.get = (layout) -> + layout.get().replace(/<[^>]+>/g, '') + + ret.conf = (props) -> + config = {} + if props.left? + object.appendOnto config, linePrependor: options: amount: props.left + + if props.right? + object.appendOnto config, lineAppendor: options: amount: props.right + + if props.top? + object.appendOnto config, blockPrependor: options: amount: props.top + + if props.bottom? + object.appendOnto config, blockAppendor: options: amount: props.bottom + + if props.width? + object.appendOnto config, width: props.width + + if props.bullet is yes + object.appendOnto config, linePrependor: options: bullet: {char: '-', alignment: 'left'} + + config + + ret + + +describe "Layout", -> + describe "inline inputs", -> + it "should be merged", -> + l = new Layout + + l.write 'a' + l.write 'b' + + get(l).should.equal 'ab' + + it "should be correctly wrapped", -> + l = new Layout + block = l.openBlock conf width: 20 + block.write '123456789012345678901234567890' + block.close() + get(l).should.equal '12345678901234567890\n1234567890' + + it "should trim from left when wrapping to a new line", -> + l = new Layout + block = l.openBlock conf width: 20 + block.write '12345678901234567890 \t 123456789012345678901' + block.close() + get(l).should.equal '12345678901234567890\n12345678901234567890\n1' + + it "should handle line breaks correctly", -> + l = new Layout + block = l.openBlock conf width: 20 + block.write '\na\n\nb\n' + block.close() + get(l).should.equal '\na\n\nb\n' + + it "should not put extra line breaks when a line is already broken", -> + l = new Layout + block = l.openBlock conf width: 20 + block.write '01234567890123456789\n0123456789' + block.close() + get(l).should.equal '01234567890123456789\n0123456789' + + describe "horizontal margins", -> + it "should account for left margins", -> + l = new Layout + block = l.openBlock conf width: 20, left: 2 + block.write '01' + block.close() + get(l).should.equal ' 01' + + it "should account for right margins", -> + l = new Layout + block = l.openBlock conf width: 20, right: 2 + block.write '01' + block.close() + get(l).should.equal '01 ' + + it "should account for both margins", -> + l = new Layout + block = l.openBlock conf width: 20, right: 2, left: 1 + block.write '01' + block.close() + get(l).should.equal ' 01 ' + + it "should break lines according to left margins", -> + l = new Layout + global.tick = yes + block = l.openBlock conf width: 20, left: 2 + block.write '01234567890123456789' + block.close() + global.tick = no + get(l).should.equal ' 01234567890123456789' + + it "should break lines according to right margins", -> + l = new Layout + block = l.openBlock conf width: 20, right: 2 + block.write '01234567890123456789' + block.close() + get(l).should.equal '01234567890123456789 ' + + it "should break lines according to both margins", -> + l = new Layout + block = l.openBlock conf width: 20, right: 2, left: 1 + block.write '01234567890123456789' + block.close() + get(l).should.equal ' 01234567890123456789 ' + + it "should break lines according to terminal width", -> + l = new Layout terminalWidth: 20 + block = l.openBlock conf right: 2, left: 1 + block.write '01234567890123456789' + block.close() + + # Note: We don't expect ' 01234567890123456 \n 789 ', + # since the first line (' 01234567890123456 ') is a full line + # according to layout.config.terminalWidth and doesn't need + # a break line. + get(l).should.equal ' 01234567890123456 789 ' + + describe "lines and blocks", -> + it "should put one break line between: line, block", -> + l = new Layout + l.write 'a' + l.openBlock().write('b').close() + get(l).should.equal 'a\nb' + + it "should put one break line between: block, line", -> + l = new Layout + l.openBlock().write('a').close() + l.write 'b' + get(l).should.equal 'a\nb' + + it "should put one break line between: line, block, line", -> + l = new Layout + l.write 'a' + l.openBlock().write('b').close() + l.write 'c' + get(l).should.equal 'a\nb\nc' + + it "margin top should work for: line, block", -> + l = new Layout + l.write 'a' + l.openBlock(conf top: 2).write('b').close() + get(l).should.equal 'a\n\n\nb' + + it "margin top should work for: block, line", -> + l = new Layout + l.openBlock(conf top: 1).write('a').close() + l.write 'b' + get(l).should.equal '\na\nb' + + it "margin top should work for: block, line, when block starts with a break", -> + l = new Layout + l.openBlock(conf top: 1).write('\na').close() + l.write 'b' + get(l).should.equal '\n\na\nb' + + it "margin top should work for: line, block, when line ends with a break", -> + l = new Layout + l.write 'a\n' + l.openBlock(conf top: 1).write('b').close() + get(l).should.equal 'a\n\n\nb' + + it "margin top should work for: line, block, when there are two breaks in between", -> + l = new Layout + l.write 'a\n' + l.openBlock(conf top: 1).write('\nb').close() + get(l).should.equal 'a\n\n\n\nb' + + it "margin bottom should work for: line, block", -> + l = new Layout + l.write 'a' + l.openBlock(conf bottom: 1).write('b').close() + get(l).should.equal 'a\nb\n' + + it "margin bottom should work for: block, line", -> + l = new Layout + l.openBlock(conf bottom: 1).write('a').close() + l.write 'b' + get(l).should.equal 'a\n\nb' + + it "margin bottom should work for: block, line, when block ends with a break", -> + l = new Layout + l.openBlock(conf bottom: 1).write('a\n').close() + l.write 'b' + get(l).should.equal 'a\n\n\nb' + + it "margin bottom should work for: block, line, when line starts with a break", -> + l = new Layout + l.openBlock(conf bottom: 1).write('a').close() + l.write '\nb' + get(l).should.equal 'a\n\n\nb' + + it "margin bottom should work for: block, line, when there are two breaks in between", -> + l = new Layout + l.openBlock(conf bottom: 1).write('a\n').close() + l.write '\nb' + get(l).should.equal 'a\n\n\n\nb' + + describe "blocks and blocks", -> + it "should not get extra break lines for full-width lines", -> + l = new Layout + l.openBlock(conf width: 20).write('01234567890123456789').close() + l.openBlock().write('b').close() + get(l).should.equal '01234567890123456789\nb' + + it "should not get extra break lines for full-width lines followed by a margin", -> + l = new Layout + l.openBlock(conf width: 20, bottom: 1).write('01234567890123456789').close() + l.openBlock().write('b').close() + get(l).should.equal '01234567890123456789\n\nb' + + it "a(top: 0, bottom: 0) b(top: 0, bottom: 0)", -> + l = new Layout + l.openBlock().write('a').close() + l.openBlock().write('b').close() + get(l).should.equal 'a\nb' + + it "a(top: 0, bottom: 0) b(top: 1, bottom: 0)", -> + l = new Layout + l.openBlock().write('a').close() + l.openBlock(conf(top: 1)).write('b').close() + get(l).should.equal 'a\n\nb' + + it "a(top: 0, bottom: 1) b(top: 0, bottom: 0)", -> + l = new Layout + l.openBlock(conf(bottom: 1)).write('a').close() + l.openBlock().write('b').close() + get(l).should.equal 'a\n\nb' + + it "a(top: 0, bottom: 1 ) b( top: 1, bottom: 0)", -> + l = new Layout + l.openBlock(conf(bottom: 1)).write('a').close() + l.openBlock(conf(top: 1)).write('b').close() + get(l).should.equal 'a\n\n\nb' + + it "a(top: 0, bottom: 1 br) b(br top: 1, bottom: 0)", -> + l = new Layout + l.openBlock(conf(bottom: 1)).write('a\n').close() + l.openBlock(conf(top: 1)).write('\nb').close() + get(l).should.equal 'a\n\n\n\n\nb' + + it "a(top: 2, bottom: 3 a1-br-a2) b(br-b1-br-br-b2-br top: 2, bottom: 3)", -> + l = new Layout + l.openBlock(conf(top: 2, bottom: 3)).write('a1\na2').close() + l.openBlock(conf(top: 2, bottom: 3)).write('\nb1\n\nb2\n').close() + get(l).should.equal '\n\na1\na2\n\n\n\n\n\n\nb1\n\nb2\n\n\n\n' + + describe "nesting", -> + it "should break one line for nested blocks", -> + l = new Layout + l.write 'a' + b = l.openBlock() + c = b.openBlock().write('c').close() + b.close() + get(l).should.equal 'a\nc' + + it "a(left: 2) > b(top: 2)", -> + l = new Layout + a = l.openBlock(conf(left: 2)) + a.openBlock(conf(top: 2)).write('b').close() + a.close() + get(l).should.equal ' \n \n b' + + it "a(left: 2) > b(bottom: 2)", -> + l = new Layout + a = l.openBlock(conf(left: 2)) + a.openBlock(conf(bottom: 2)).write('b').close() + a.close() + get(l).should.equal ' b\n \n ' + + describe "bullets", -> + it "basic bullet", -> + l = new Layout + l.openBlock(conf(left: 3, bullet: yes)).write('a').close() + get(l).should.equal '- a' + + it "a(left: 3, bullet) > b(top:1)", -> + l = new Layout + a = l.openBlock(conf(left: 3, bullet: yes)) + b = a.openBlock(conf(top: 1)).write('b').close() + a.close() + get(l).should.equal '- \n b'
\ No newline at end of file diff --git a/node_modules/renderkid/test/layout/SpecialString.coffee b/node_modules/renderkid/test/layout/SpecialString.coffee new file mode 100644 index 000000000..acc166fbd --- /dev/null +++ b/node_modules/renderkid/test/layout/SpecialString.coffee @@ -0,0 +1,82 @@ +S = require '../../src/layout/SpecialString' + +describe "SpecialString", -> + describe 'SpecialString()', -> + it 'should return instance', -> + S('s').should.be.instanceOf S + + describe 'length()', -> + it 'should return correct length for normal text', -> + S('hello').length.should.equal 5 + + it 'should return correct length for text containing tabs and tags', -> + S('<a>he<you />l\tlo</a>').length.should.equal 13 + + it "shouldn't count empty tags as tags", -> + S('<>><').length.should.equal 4 + + it "should count length of single tag as 0", -> + S('<html>').length.should.equal 0 + + it "should work correctly with html quoted characters", -> + S(' >< &sp;').length.should.equal 5 + + describe 'splitIn()', -> + it "should work correctly with normal text", -> + S("123456").splitIn(3).should.be.like ['123', '456'] + + it "should work correctly with normal text containing tabs and tags", -> + S("12\t3<hello>456").splitIn(3).should.be.like ['12', '\t', '3<hello>45', '6'] + + it "should not trimLeft all lines when trimLeft is no", -> + S('abc def').splitIn(3).should.be.like ['abc', ' de', 'f'] + + it "should trimLeft all lines when trimLeft is true", -> + S('abc def').splitIn(3, yes).should.be.like ['abc', 'def'] + + describe 'cut()', -> + it "should work correctly with text containing tabs and tags", -> + original = S("12\t3<hello>456") + cut = original.cut(2, 3) + original.str.should.equal '123<hello>456' + cut.str.should.equal '\t' + + it "should trim left when trimLeft is true", -> + original = S ' 132' + cut = original.cut 0, 1, yes + original.str.should.equal '32' + cut.str.should.equal '1' + + it "should be greedy", -> + S("ab<tag>a").cut(0, 2).str.should.equal "ab<tag>" + + describe 'isOnlySpecialChars()', -> + it "should work", -> + S("12\t3<hello>456").isOnlySpecialChars().should.equal no + S("<hello>").isOnlySpecialChars().should.equal yes + + describe 'clone()', -> + it "should return independent instance", -> + a = S('hello') + b = a.clone() + a.str.should.equal b.str + a.should.not.equal b + + describe 'trim()', -> + it "should return an independent instance", -> + s = S('') + s.trim().should.not.equal s + + it 'should return the same string when trim is not required', -> + S('hello').trim().str.should.equal 'hello' + + it 'should return trimmed string', -> + S(' hello').trim().str.should.equal 'hello' + + describe 'trimLeft()', -> + it "should only trim on the left", -> + S(' hello ').trimLeft().str.should.equal 'hello ' + + describe 'trimRight()', -> + it "should only trim on the right", -> + S(' hello ').trimRight().str.should.equal ' hello'
\ No newline at end of file diff --git a/node_modules/renderkid/test/mocha.opts b/node_modules/renderkid/test/mocha.opts new file mode 100644 index 000000000..0b4468244 --- /dev/null +++ b/node_modules/renderkid/test/mocha.opts @@ -0,0 +1,6 @@ +--compilers coffee:coffee-script/register +--recursive +--reporter mocha-pretty-spec-reporter +--ui bdd +--timeout 20000 +--require ./test/mochaHelpers.coffee
\ No newline at end of file diff --git a/node_modules/renderkid/test/mochaHelpers.coffee b/node_modules/renderkid/test/mochaHelpers.coffee new file mode 100644 index 000000000..1e388d33d --- /dev/null +++ b/node_modules/renderkid/test/mochaHelpers.coffee @@ -0,0 +1,10 @@ +chai = require('chai') + +chai +.use(require 'chai-fuzzy') +.use(require 'chai-changes') +.use(require 'sinon-chai') +.should() + +global.expect = chai.expect +global.sinon = require 'sinon'
\ No newline at end of file diff --git a/node_modules/renderkid/test/renderKid/styles/StyleSheet.coffee b/node_modules/renderkid/test/renderKid/styles/StyleSheet.coffee new file mode 100644 index 000000000..d0764c2d1 --- /dev/null +++ b/node_modules/renderkid/test/renderKid/styles/StyleSheet.coffee @@ -0,0 +1,7 @@ +StyleSheet = require '../../../src/renderKid/styles/StyleSheet' + +describe "StyleSheet", -> + describe "normalizeSelector()", -> + it 'should remove unnecessary spaces', -> + StyleSheet.normalizeSelector(' body+a s > a ') + .should.equal 'body+a s>a'
\ No newline at end of file diff --git a/node_modules/renderkid/test/tools.coffee b/node_modules/renderkid/test/tools.coffee new file mode 100644 index 000000000..143d9c5c6 --- /dev/null +++ b/node_modules/renderkid/test/tools.coffee @@ -0,0 +1,19 @@ +tools = require '../src/tools' + +describe "tools", -> + describe "quote()", -> + it "should convert html special strings to their entities", -> + tools.quote(" abc<>\"\n") + .should.equal '&sp;abc<>"<br />' + + describe "stringToDom()", -> + it "should work", -> + tools.stringToDom('<a> text<a1>text</a1> text <a2>text</a2><a3>text</a3>text</a>text') + + describe "objectToDom()", -> + it "should work", -> + tools.objectToDom({a: 'text'}) + + it "should have quoted text nodes", -> + tools.objectToDom({a: '&<> "'}).should.have.deep + .property '[0].children[0].data', '&<>&sp;"'
\ No newline at end of file |