pax_global_header00006660000000000000000000000064145604071170014517gustar00rootroot0000000000000052 comment=46533ec1ced0e8db61af609f4d5075ab9396e17b gulp-postcss-10.0.0/000077500000000000000000000000001456040711700142405ustar00rootroot00000000000000gulp-postcss-10.0.0/.eslintrc000066400000000000000000000011731456040711700160660ustar00rootroot00000000000000{ "env": { "node": true }, "extends": [ "eslint:recommended" ], "globals": { "Promise": true }, "rules": { "semi": [ 2, "never" ], "no-cond-assign": [ 2, "except-parens" ], "no-unused-expressions": 2, "indent": [ 2, 2, { "SwitchCase": 1 } ], "comma-style": 2, "max-len": [ 2, { "code": 100, "ignoreComments": true } ], "new-cap": 2, "strict": 0, "no-trailing-spaces": 2, "no-undef": 2, "no-unused-vars": 2, "quotes": [ 2, "single" ] } } gulp-postcss-10.0.0/.github/000077500000000000000000000000001456040711700156005ustar00rootroot00000000000000gulp-postcss-10.0.0/.github/workflows/000077500000000000000000000000001456040711700176355ustar00rootroot00000000000000gulp-postcss-10.0.0/.github/workflows/test.yml000066400000000000000000000007621456040711700213440ustar00rootroot00000000000000name: Test on: push: branches: [main] pull_request: branches: [main] jobs: npm-test: runs-on: ubuntu-latest strategy: matrix: node-version: ['18', '20', '21'] steps: - uses: actions/checkout@v2 - uses: actions/setup-node@v3 with: node-version: ${{ matrix.node-version }} - run: | npm install npm test - uses: coverallsapp/github-action@master with: github-token: ${{ secrets.GITHUB_TOKEN }} gulp-postcss-10.0.0/.gitignore000066400000000000000000000001301456040711700162220ustar00rootroot00000000000000node_modules npm-debug.log .DS_Store .nyc_output/ coverage/ package-lock.json yarn.lock gulp-postcss-10.0.0/.npmignore000066400000000000000000000004271456040711700162420ustar00rootroot00000000000000*.log *.pid *.seed .editorconfig .eslintrc* .eslintignore .gitignore .grunt .lock-wscript .node_repl_history .stylelintrc* .travis.yml .vscode .nyc_output appveyor.yml coverage gulpfile.js lib-cov logs node_modules npm-debug.log* pids test test.js yarn.lock flake.lock flake.nix gulp-postcss-10.0.0/LICENSE000066400000000000000000000020701456040711700152440ustar00rootroot00000000000000The MIT License (MIT) Copyright (c) 2014 Andrey Kuzmin 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. gulp-postcss-10.0.0/README.md000066400000000000000000000203411456040711700155170ustar00rootroot00000000000000# gulp-postcss ![Build Status](https://github.com/postcss/gulp-postcss/actions/workflows/test.yml/badge.svg?branch=main) [![Coverage Status](https://img.shields.io/coveralls/postcss/gulp-postcss.svg)](https://coveralls.io/r/postcss/gulp-postcss) [PostCSS](https://github.com/postcss/postcss) gulp plugin to pipe CSS through several plugins, but parse CSS only once. ## Install $ npm install --save-dev postcss gulp-postcss Install required [postcss plugins](https://www.npmjs.com/browse/keyword/postcss-plugin) separately. E.g. for autoprefixer, you need to install [autoprefixer](https://github.com/postcss/autoprefixer) package. ## Basic usage The configuration is loaded automatically from `postcss.config.js` as [described here](https://www.npmjs.com/package/postcss-load-config), so you don't have to specify any options. ```js var postcss = require('gulp-postcss'); var gulp = require('gulp'); gulp.task('css', function () { return gulp.src('./src/*.css') .pipe(postcss()) .pipe(gulp.dest('./dest')); }); ``` ## Passing plugins directly ```js var postcss = require('gulp-postcss'); var gulp = require('gulp'); var autoprefixer = require('autoprefixer'); var cssnano = require('cssnano'); gulp.task('css', function () { var plugins = [ autoprefixer({browsers: ['last 1 version']}), cssnano() ]; return gulp.src('./src/*.css') .pipe(postcss(plugins)) .pipe(gulp.dest('./dest')); }); ``` ## Using with .pcss extension For using gulp-postcss to have input files in .pcss format and get .css output need additional library like gulp-rename. ```js var postcss = require('gulp-postcss'); var gulp = require('gulp'); const rename = require('gulp-rename'); gulp.task('css', function () { return gulp.src('./src/*.pcss') .pipe(postcss()) .pipe(rename({ extname: '.css' })) .pipe(gulp.dest('./dest')); }); ``` This is done for more explicit transformation. According to [gulp plugin guidelines](https://github.com/gulpjs/gulp/blob/master/docs/writing-a-plugin/guidelines.md#guidelines) > Your plugin should only do one thing, and do it well. ## Passing additional options to PostCSS The second optional argument to gulp-postcss is passed to PostCSS. This, for instance, may be used to enable custom parser: ```js var gulp = require('gulp'); var postcss = require('gulp-postcss'); var nested = require('postcss-nested'); var sugarss = require('sugarss'); gulp.task('default', function () { var plugins = [nested]; return gulp.src('in.sss') .pipe(postcss(plugins, { parser: sugarss })) .pipe(gulp.dest('out')); }); ``` If you are using a `postcss.config.js` file, you can pass PostCSS options as the first argument to gulp-postcss. This, for instance, will let PostCSS know what the final file destination path is, since it will be unaware of the path given to `gulp.dest()`: ```js var gulp = require('gulp'); var postcss = require('gulp-postcss'); gulp.task('default', function () { return gulp.src('in.scss') .pipe(postcss({ to: 'out/in.css' })) .pipe(gulp.dest('out')); }); ``` ## Using a custom processor ```js var postcss = require('gulp-postcss'); var cssnext = require('postcss-cssnext'); var opacity = function (css, opts) { css.walkDecls(function(decl) { if (decl.prop === 'opacity') { decl.parent.insertAfter(decl, { prop: '-ms-filter', value: '"progid:DXImageTransform.Microsoft.Alpha(Opacity=' + (parseFloat(decl.value) * 100) + ')"' }); } }); }; gulp.task('css', function () { var plugins = [ cssnext({browsers: ['last 1 version']}), opacity ]; return gulp.src('./src/*.css') .pipe(postcss(plugins)) .pipe(gulp.dest('./dest')); }); ``` ## Source map support Source map is disabled by default, to extract map use together with [gulp-sourcemaps](https://github.com/floridoo/gulp-sourcemaps). ```js return gulp.src('./src/*.css') .pipe(sourcemaps.init()) .pipe(postcss(plugins)) .pipe(sourcemaps.write('.')) .pipe(gulp.dest('./dest')); ``` ## Advanced usage If you want to configure postcss on per-file-basis, you can pass a callback that receives [vinyl file object](https://github.com/gulpjs/vinyl) and returns `{ plugins: plugins, options: options }`. For example, when you need to parse different extensions differntly: ```js var gulp = require('gulp'); var postcss = require('gulp-postcss'); gulp.task('css', function () { function callback(file) { return { plugins: [ require('postcss-import')({ root: file.dirname }), require('postcss-modules') ], options: { parser: file.extname === '.sss' ? require('sugarss') : false } } } return gulp.src('./src/*.css') .pipe(postcss(callback)) .pipe(gulp.dest('./dest')); }); ``` The same result may be achieved with [`postcss-load-config`](https://www.npmjs.com/package/postcss-load-config), because it receives `ctx` with the context options and the vinyl file. ```js var gulp = require('gulp'); var postcss = require('gulp-postcss'); gulp.task('css', function () { var contextOptions = { modules: true }; return gulp.src('./src/*.css') .pipe(postcss(contextOptions)) .pipe(gulp.dest('./dest')); }); ``` ```js // postcss.config.js or .postcssrc.js module.exports = function (ctx) { var file = ctx.file; var options = ctx; return { parser: file.extname === '.sss' ? : 'sugarss' : false, plugins: { 'postcss-import': { root: file.dirname } 'postcss-modules': options.modules ? {} : false } } }; ``` ## Changelog * 10.0.0 * Released with the same changes as 9.1.0 * 9.1.0 **deprecated, because it breaks semver by dropping support for node <18** * Bump postcss-load-config to ^5.0.0 * Ensure options are passed to plugins when using postcss.config.js #170 * Update deps * Drop support for node <18 * Add flake.nix for local dev with `nix develop` * 9.0.1 * Bump postcss-load-config to ^3.0.0 * 9.0.0 * Bump PostCSS to 8.0 * Drop Node 6 support * PostCSS is now a peer dependency * 8.0.0 * Bump PostCSS to 7.0 * Drop Node 4 support * 7.0.1 * Drop dependency on gulp-util * 7.0.0 * Bump PostCSS to 6.0 * Smaller module size * Use eslint instead of jshint * 6.4.0 * Add more details to `PluginError` object * 6.3.0 * Integrated with postcss-load-config * Added a callback to configure postcss on per-file-basis * Dropped node 0.10 support * 6.2.0 * Fix syntax error message for PostCSS 5.2 compatibility * 6.1.1 * Fixed the error output * 6.1.0 * Support for `null` files * Updated dependencies * 6.0.1 * Added an example and a test to pass options to PostCSS (e.g. `syntax` option) * Updated vinyl-sourcemaps-apply to 0.2.0 * 6.0.0 * Updated PostCSS to version 5.0.0 * 5.1.10 * Use autoprefixer in README * 5.1.9 * Prevent unhandled exception of the following pipes from being suppressed by Promise * 5.1.8 * Prevent stream’s unhandled exception from being suppressed by Promise * 5.1.7 * Updated direct dependencies * 5.1.6 * Updated `CssSyntaxError` check * 5.1.4 * Simplified error handling * Simplified postcss execution with object plugins * 5.1.3 Updated travis banner * 5.1.2 Transferred repo into postcss org on github * 5.1.1 * Allow override of `to` option * 5.1.0 PostCSS Runner Guidelines * Set `from` and `to` processing options * Don't output js stack trace for `CssSyntaxError` * Display `result.warnings()` content * 5.0.1 * Fix to support object plugins * 5.0.0 * Use async API * 4.0.3 * Fixed bug with relative source map * 4.0.2 * Made PostCSS a simple dependency, because peer dependency is deprecated * 4.0.1 * Made PostCSS 4.x a peer dependency * 4.0.0 * Updated PostCSS to 4.0 * 3.0.0 * Updated PostCSS to 3.0 and fixed tests * 2.0.1 * Added Changelog * Added example for a custom processor in README * 2.0.0 * Disable source map by default * Test source map * Added Travis support * Use autoprefixer-core in README * 1.0.2 * Improved README * 1.0.1 * Don't add source map comment if used with gulp-sourcemaps * 1.0.0 * Initial release gulp-postcss-10.0.0/flake.lock000066400000000000000000000026701456040711700162010ustar00rootroot00000000000000{ "nodes": { "flake-utils": { "inputs": { "systems": "systems" }, "locked": { "lastModified": 1701680307, "narHash": "sha256-kAuep2h5ajznlPMD9rnQyffWG8EM/C73lejGofXvdM8=", "owner": "numtide", "repo": "flake-utils", "rev": "4022d587cbbfd70fe950c1e2083a02621806a725", "type": "github" }, "original": { "owner": "numtide", "repo": "flake-utils", "type": "github" } }, "nixpkgs": { "locked": { "lastModified": 1705084402, "narHash": "sha256-i+ipI7VgXV+nLi5ZwZ0xCamvD6Iu59vDHe6S2YOoW+Q=", "owner": "nixos", "repo": "nixpkgs", "rev": "f65e5ea4794033885e1dafff7e8632e4f8cd1909", "type": "github" }, "original": { "owner": "nixos", "repo": "nixpkgs", "type": "github" } }, "root": { "inputs": { "flake-utils": "flake-utils", "nixpkgs": "nixpkgs" } }, "systems": { "locked": { "lastModified": 1681028828, "narHash": "sha256-Vy1rq5AaRuLzOxct8nz4T6wlgyUR7zLU309k9mBC768=", "owner": "nix-systems", "repo": "default", "rev": "da67096a3b9bf56a91d16901293e51ba5b49a27e", "type": "github" }, "original": { "owner": "nix-systems", "repo": "default", "type": "github" } } }, "root": "root", "version": 7 } gulp-postcss-10.0.0/flake.nix000066400000000000000000000005771456040711700160530ustar00rootroot00000000000000{ inputs = { nixpkgs.url = "github:nixos/nixpkgs"; flake-utils.url = "github:numtide/flake-utils"; }; outputs = { self, nixpkgs, flake-utils }: flake-utils.lib.eachDefaultSystem (system: let pkgs = nixpkgs.legacyPackages.${system}; in { devShell = pkgs.mkShell { buildInputs = [ pkgs.nodejs_21 ]; }; }); } gulp-postcss-10.0.0/index.js000066400000000000000000000076741456040711700157230ustar00rootroot00000000000000var Stream = require('stream') var postcss = require('postcss') var applySourceMap = require('vinyl-sourcemaps-apply') var fancyLog = require('fancy-log') var PluginError = require('plugin-error') var path = require('path') module.exports = withConfigLoader(function (loadConfig) { var stream = new Stream.Transform({ objectMode: true }) stream._transform = function (file, encoding, cb) { if (file.isNull()) { return cb(null, file) } if (file.isStream()) { return handleError('Streams are not supported!') } // Protect `from` and `map` if using gulp-sourcemaps var isProtected = file.sourceMap ? { from: true, map: true } : {} var options = { from: file.path, to: file.path, // Generate a separate source map for gulp-sourcemaps map: file.sourceMap ? { annotation: false } : false } loadConfig(file) .then(function (config) { var configOpts = config.options || {} // Extend the default options if not protected for (var opt in configOpts) { if (configOpts.hasOwnProperty(opt) && !isProtected[opt]) { options[opt] = configOpts[opt] } else { fancyLog.info( 'gulp-postcss:', file.relative + '\nCannot override ' + opt + ' option, because it is required by gulp-sourcemaps' ) } } return postcss(config.plugins || []) .process(file.contents, options) }) .then(handleResult, handleError) function handleResult (result) { var map var warnings = result.warnings().join('\n') file.contents = Buffer.from(result.css) // Apply source map to the chain if (file.sourceMap) { map = result.map.toJSON() map.file = file.relative map.sources = [].map.call(map.sources, function (source) { return path.join(path.dirname(file.relative), source) }) applySourceMap(file, map) } if (warnings) { fancyLog.info('gulp-postcss:', file.relative + '\n' + warnings) } setImmediate(function () { cb(null, file) }) } function handleError (error) { var errorOptions = { fileName: file.path, showStack: true } if (error.name === 'CssSyntaxError') { errorOptions.error = error errorOptions.fileName = error.file || file.path errorOptions.lineNumber = error.line errorOptions.showProperties = false errorOptions.showStack = false error = error.message + '\n\n' + error.showSourceCode() + '\n' } // Prevent stream’s unhandled exception from // being suppressed by Promise setImmediate(function () { cb(new PluginError('gulp-postcss', error, errorOptions)) }) } } return stream }) function withConfigLoader(cb) { return function (plugins, options) { if (Array.isArray(plugins)) { return cb(function () { return Promise.resolve({ plugins: plugins, options: options }) }) } else if (typeof plugins === 'function') { return cb(function (file) { return Promise.resolve(plugins(file)) }) } else { var postcssLoadConfig = require('postcss-load-config') var contextOptions = plugins || {} return cb(function(file) { var configPath if (contextOptions.config) { if (path.isAbsolute(contextOptions.config)) { configPath = contextOptions.config } else { configPath = path.join(file.base, contextOptions.config) } } else { configPath = file.dirname } // @TODO: The options property is deprecated and should be removed in 10.0.0. contextOptions.options = Object.assign({}, contextOptions) contextOptions.file = file return postcssLoadConfig( contextOptions, configPath ) }) } } } gulp-postcss-10.0.0/package.json000066400000000000000000000024051456040711700165270ustar00rootroot00000000000000{ "name": "gulp-postcss", "nyc": { "lines": 100, "statements": 100, "functions": 100, "branches": 100, "reporter": [ "lcov", "text" ], "cache": true, "all": true, "check-coverage": true }, "version": "10.0.0", "description": "PostCSS gulp plugin", "main": "index.js", "engines": { "node": ">=18" }, "scripts": { "pretest": "eslint *.js", "test": "nyc mocha test.js" }, "repository": { "type": "git", "url": "https://github.com/postcss/gulp-postcss.git" }, "keywords": [ "gulpplugin", "postcss", "postcss-runner", "css" ], "author": "Andrey Kuzmin ", "license": "MIT", "bugs": { "url": "https://github.com/postcss/gulp-postcss/issues" }, "homepage": "https://github.com/postcss/gulp-postcss", "dependencies": { "fancy-log": "^2.0.0", "plugin-error": "^2.0.1", "postcss-load-config": "^5.0.0", "vinyl-sourcemaps-apply": "^0.2.1" }, "devDependencies": { "eslint": "^5.16.0", "gulp-sourcemaps": "^2.6.5", "mocha": "^10.2.0", "nyc": "^15.1.0", "postcss": "^8.0.0", "proxyquire": "^2.1.0", "sinon": "^6.3.5", "vinyl": "^2.2.0" }, "peerDependencies": { "postcss": "^8.0.0" } } gulp-postcss-10.0.0/test.js000066400000000000000000000321151456040711700155570ustar00rootroot00000000000000/* eslint-env node, mocha */ /* eslint max-len: ["off"] */ var assert = require('assert') var Vinyl = require('vinyl') var fancyLog = require('fancy-log') var PluginError = require('plugin-error') var sourceMaps = require('gulp-sourcemaps') var postcss = require('./index') var proxyquire = require('proxyquire') var sinon = require('sinon') var path = require('path') it('should pass file when it isNull()', function (cb) { var stream = postcss([ doubler ]) var emptyFile = { isNull: function () { return true } } stream.once('data', function (data) { assert.equal(data, emptyFile) cb() }) stream.write(emptyFile) stream.end() }) it('should transform css with multiple processors', function (cb) { var stream = postcss( [ asyncDoubler, objectDoubler() ] ) stream.on('data', function (file) { var result = file.contents.toString('utf8') var target = 'a { color: black; color: black; color: black; color: black }' assert.equal( result, target ) cb() }) stream.write(new Vinyl({ contents: Buffer.from('a { color: black }') })) stream.end() }) it('should not transform css with out any processor', function (cb) { var css = 'a { color: black }' var stream = postcss(function(){ return {} }) stream.on('data', function (file) { var result = file.contents.toString('utf8') var target = css assert.equal( result, target ) cb() }) stream.write(new Vinyl({ contents: Buffer.from(css) })) stream.end() }) it('should correctly wrap postcss errors', function (cb) { var stream = postcss([ doubler ]) stream.on('error', function (err) { assert.ok(err instanceof PluginError) assert.equal(err.plugin, 'gulp-postcss') assert.equal(err.column, 1) assert.equal(err.lineNumber, 1) assert.equal(err.name, 'CssSyntaxError') assert.equal(err.reason, 'Unclosed block') assert.equal(err.showStack, false) assert.equal(err.source, 'a {') assert.equal(err.fileName, path.resolve('testpath')) cb() }) stream.write(new Vinyl({ contents: Buffer.from('a {'), path: path.resolve('testpath') })) stream.end() }) it('should respond with error on stream files', function (cb) { var stream = postcss([ doubler ]) stream.on('error', function (err) { assert.ok(err instanceof PluginError) assert.equal(err.plugin, 'gulp-postcss') assert.equal(err.showStack, true) assert.equal(err.message, 'Streams are not supported!') assert.equal(err.fileName, path.resolve('testpath')) cb() }) var streamFile = { isStream: function () { return true }, isNull: function() { return false }, path: path.resolve('testpath') } stream.write(streamFile) stream.end() }) it('should generate source maps', function (cb) { var init = sourceMaps.init() var write = sourceMaps.write() var css = postcss( [ doubler, asyncDoubler ] ) init .pipe(css) .pipe(write) write.on('data', function (file) { assert.equal(file.sourceMap.mappings, 'AAAA,IAAI,YAAW,EAAX,YAAW,EAAX,YAAW,EAAX,aAAa') assert(/sourceMappingURL=data:application\/json;(?:charset=\w+;)?base64/.test(file.contents.toString())) cb() }) init.write(new Vinyl({ base: __dirname, path: __dirname + '/fixture.css', contents: Buffer.from('a { color: black }') })) init.end() }) it('should correctly generate relative source map', function (cb) { var init = sourceMaps.init() var css = postcss( [ doubler, doubler ] ) init.pipe(css) css.on('data', function (file) { assert.equal(file.sourceMap.file, 'fixture.css') assert.deepEqual(file.sourceMap.sources, ['fixture.css']) cb() }) init.write(new Vinyl({ base: __dirname + '/src', path: __dirname + '/src/fixture.css', contents: Buffer.from('a { color: black }') })) init.end() }) describe('PostCSS Guidelines', function () { var sandbox = sinon.createSandbox() var CssSyntaxError = function (message, source) { this.name = 'CssSyntaxError' this.message = message this.source = source this.showSourceCode = function () { return this.source } this.toString = function(){ var code = this.showSourceCode() if ( code ) { code = '\n\n' + code + '\n' } return this.name + ': ' + this.message + code } } var postcssStub = { use: function () {}, process: function () {} } var postcssLoadConfigStub var postcss = proxyquire('./index', { postcss: function (plugins) { postcssStub.use(plugins) return postcssStub }, 'postcss-load-config': function (ctx, configPath) { return postcssLoadConfigStub(ctx, configPath) }, 'vinyl-sourcemaps-apply': function () { return {} } }) beforeEach(function () { postcssLoadConfigStub = sandbox.stub() sandbox.stub(postcssStub, 'use') sandbox.stub(postcssStub, 'process') }) afterEach(function () { sandbox.restore() }) it('should set `from` and `to` processing options to `file.path`', function (cb) { var stream = postcss([ doubler ]) var cssPath = __dirname + '/src/fixture.css' postcssStub.process.returns(Promise.resolve({ css: '', warnings: function () { return [] } })) stream.on('data', function () { assert.equal(postcssStub.process.getCall(0).args[1].to, cssPath) assert.equal(postcssStub.process.getCall(0).args[1].from, cssPath) cb() }) stream.write(new Vinyl({ contents: Buffer.from('a {}'), path: cssPath })) stream.end() }) it('should allow override of `to` processing option', function (cb) { var stream = postcss([ doubler ], {to: 'overridden'}) postcssStub.process.returns(Promise.resolve({ css: '', warnings: function () { return [] } })) stream.on('data', function () { assert.equal(postcssStub.process.getCall(0).args[1].to, 'overridden') cb() }) stream.write(new Vinyl({ contents: Buffer.from('a {}') })) stream.end() }) it('should take plugins and options from callback', function (cb) { var cssPath = __dirname + '/fixture.css' var file = new Vinyl({ contents: Buffer.from('a {}'), path: cssPath }) var plugins = [ doubler ] var callback = sandbox.stub().returns({ plugins: plugins, options: { to: 'overridden' } }) var stream = postcss(callback) postcssStub.process.returns(Promise.resolve({ css: '', warnings: function () { return [] } })) stream.on('data', function () { assert.equal(callback.getCall(0).args[0], file) assert.equal(postcssStub.use.getCall(0).args[0], plugins) assert.equal(postcssStub.process.getCall(0).args[1].to, 'overridden') cb() }) stream.end(file) }) it('should take plugins and options from postcss-load-config', function (cb) { var cssPath = __dirname + '/fixture.css' var file = new Vinyl({ contents: Buffer.from('a {}'), path: cssPath }) var stream = postcss({ to: 'initial' }) var plugins = [ doubler ] postcssLoadConfigStub.returns(Promise.resolve({ plugins: plugins, options: { to: 'overridden' } })) postcssStub.process.returns(Promise.resolve({ css: '', warnings: function () { return [] } })) stream.on('data', function () { assert.deepEqual(postcssLoadConfigStub.getCall(0).args[0], { file: file, to: 'initial', options: { to: 'initial' } }) assert.equal(postcssStub.use.getCall(0).args[0], plugins) assert.equal(postcssStub.process.getCall(0).args[1].to, 'overridden') cb() }) stream.end(file) }) it('should point the config location to file directory', function (cb) { var cssPath = __dirname + '/fixture.css' var stream = postcss() postcssLoadConfigStub.returns(Promise.resolve({ plugins: [] })) postcssStub.process.returns(Promise.resolve({ css: '', warnings: function () { return [] } })) stream.on('data', function () { assert.deepEqual(postcssLoadConfigStub.getCall(0).args[1], __dirname) cb() }) stream.end(new Vinyl({ contents: Buffer.from('a {}'), path: cssPath })) }) it('should set the config location from option', function (cb) { var cssPath = __dirname + '/fixture.css' var stream = postcss({ config: '/absolute/path' }) postcssLoadConfigStub.returns(Promise.resolve({ plugins: [] })) postcssStub.process.returns(Promise.resolve({ css: '', warnings: function () { return [] } })) stream.on('data', function () { assert.deepEqual(postcssLoadConfigStub.getCall(0).args[1], '/absolute/path') cb() }) stream.end(new Vinyl({ contents: Buffer.from('a {}'), path: cssPath })) }) it('should set the config location from option relative to the base dir', function (cb) { var cssPath = __dirname + '/src/fixture.css' var stream = postcss({ config: './relative/path' }) postcssLoadConfigStub.returns(Promise.resolve({ plugins: [] })) postcssStub.process.returns(Promise.resolve({ css: '', warnings: function () { return [] } })) stream.on('data', function () { assert.deepEqual(postcssLoadConfigStub.getCall(0).args[1], path.join(__dirname, 'relative/path')) cb() }) stream.end(new Vinyl({ contents: Buffer.from('a {}'), path: cssPath, base: __dirname })) }) it('should not override `from` and `map` if using gulp-sourcemaps', function (cb) { var stream = postcss([ doubler ], { from: 'overridden', map: 'overridden' }) var cssPath = __dirname + '/fixture.css' postcssStub.process.returns(Promise.resolve({ css: '', warnings: function () { return [] }, map: { toJSON: function () { return { sources: [], file: '' } } } })) sandbox.stub(fancyLog, 'info') stream.on('data', function () { assert.deepEqual(postcssStub.process.getCall(0).args[1].from, cssPath) assert.deepEqual(postcssStub.process.getCall(0).args[1].map, { annotation: false }) var firstMessage = fancyLog.info.getCall(0).args[1] var secondMessage = fancyLog.info.getCall(1).args[1] assert(firstMessage, '/fixture.css\nCannot override from option, because it is required by gulp-sourcemaps') assert(secondMessage, '/fixture.css\nCannot override map option, because it is required by gulp-sourcemaps') cb() }) var file = new Vinyl({ contents: Buffer.from('a {}'), path: cssPath }) file.sourceMap = {} stream.end(file) }) it('should not output js stack trace for `CssSyntaxError`', function (cb) { var stream = postcss([ doubler ]) var cssSyntaxError = new CssSyntaxError('messageText', 'sourceCode') postcssStub.process.returns(Promise.reject(cssSyntaxError)) stream.on('error', function (error) { assert.equal(error.showStack, false) assert.equal(error.message, 'messageText\n\nsourceCode\n') assert.equal(error.source, 'sourceCode') cb() }) stream.write(new Vinyl({ contents: Buffer.from('a {}') })) stream.end() }) it('should display `result.warnings()` content', function (cb) { var stream = postcss([ doubler ]) var cssPath = __dirname + '/src/fixture.css' function Warning (msg) { this.toString = function () { return msg } } sandbox.stub(fancyLog, 'info') postcssStub.process.returns(Promise.resolve({ css: '', warnings: function () { return [new Warning('msg1'), new Warning('msg2')] } })) stream.on('data', function () { assert(fancyLog.info.calledWith('gulp-postcss:', 'src' + path.sep + 'fixture.css\nmsg1\nmsg2')) cb() }) stream.write(new Vinyl({ contents: Buffer.from('a {}'), path: cssPath })) stream.end() }) it('should pass options down to PostCSS', function (cb) { var customSyntax = function () {} var options = { syntax: customSyntax } var stream = postcss([ doubler ], options) var cssPath = __dirname + '/src/fixture.css' postcssStub.process.returns(Promise.resolve({ css: '', warnings: function () { return [] } })) stream.on('data', function () { var resultOptions = postcssStub.process.getCall(0).args[1] // remove automatically set options delete resultOptions.from delete resultOptions.to delete resultOptions.map assert.deepEqual(resultOptions, options) cb() }) stream.write(new Vinyl({ contents: Buffer.from('a {}'), path: cssPath })) stream.end() }) }) function doubler (css) { css.walkDecls(function (decl) { decl.parent.prepend(decl.clone()) }) } function asyncDoubler (css) { return new Promise(function (resolve) { setTimeout(function () { doubler(css) resolve() }) }) } function objectDoubler () { var processor = require('postcss')() processor.use(doubler) return processor }