How to use rework - 10 common examples

var grunt = env.grunt;
		var imported = [];
		var style = rework(inlineImports.read(file.absPath));

		grunt.verbose.writeln('');

		if (config.inline) {
			grunt.verbose.writeln('Inlining ' + file.catalogPath.cyan);
			style.use(inlineImports(config.srcWebroot, file.absPath, imported));
		}

		if (config.rewriteUrl) {
			grunt.verbose.writeln('Rewriting URLs in ' + file.catalogPath.cyan);
			// rewrite urls to external resources
			style.use(rework.url(function(url) {
				return rewriteUrl(url, file, config);
			}));
		}

		var out = style.toString();

		if (config.minify) {
			// minify CSS
			grunt.verbose.writeln('Minifying ' + file.catalogPath.cyan);
			out = csso.justDoIt(out, true);
		}

		if (config.postProcess) {
			// do additional postprocessing, if required
			grunt.verbose.writeln('Postprocessing ' + file.catalogPath.cyan);
			out = config.postProcess(out, file);

preProcess: function(ast, options) {
            return ast
                .use(rework.url(function(url) {
                    var srcDir,
                      resourcePath,
                      destDir;

                    if (isAbsoluteUrl(url) || isRootRelativeUrl(url)) {
                      return url;
                    }

                    // rebase relative url(...) found in CSS to be imported
                    // @import url(...) handled by rework-importer; not passed through here

                    srcDir = path.dirname(options.path);
                    resourcePath = path.resolve(srcDir, url);
                    destDir = path.dirname(file.path);

                    return path.relative(destDir, resourcePath);

declClone[key] = i[key];
                                }
                                return declClone;
                            });

                        clone.keyframes.push(keyframeClone);
                    });


                    clone.vendor = prefix;
                    style.rules.push(clone);
                });
             });
        }

        rework.visit.declarations(style, function (list, node) {
            var rules = new Rules(list);

            // Properties
            rules.forEach(function (rule) {
                var prop = props[rule.property];

                if ( !prop || !prop.prefixes ) {
                    return;
                }
                if ( prop.check && !prop.check.call(rule.value, rule) ) {
                    return;
                }

                prop.prefixes.forEach(function (prefix) {
                    if ( node.vendor && node.vendor !== prefix ) {
                        return;

unprefixer: function (remove, style) {
        var all = remove.values['*'];

        // Keyframes
        style.rules = style.rules.filter(function (rule) {
            return !(rule.keyframes && remove.keyframes[rule.vendor]);
        });

        rework.visit.declarations(style, function (list) {
            var rules = new Rules(list);

            rules.forEach(function (rule) {
                // Properties
                if ( remove.props[rule.property] ) {
                    rules.removeCurrent();
                    return;
                }

                // Values
                var prop   = splitPrefix(rule.property).name;
                var values = all;
                if ( remove.values[prop] ) {
                    values = values.concat(remove.values[prop]);
                }
                if ( prop === 'transition' || prop === 'transition-property' ) {

const modifyUrls = (filePath, fileContents, sourcemap, options = {}) => {
  const {append, modify, prepend} = options

  return rework(fileContents, {source: filePath})
    .use(reworkFunc({
      url(url) {
        /**
         * The split/join/trim logic is copied from rework-plugin-url to remove redundant quotes.
         * Currently removed due to: https://github.com/reworkcss/rework-plugin-url/issues/7
         */
        if (url.indexOf('data:') === 0) {
          return `url("${url}")`
        }

        let formattedUrl = url
          .split('"')
          .join('')
          .split('\'')
          .join('')
          .trim()

}

    output = rework(read(src, 'utf8'));
    output.use(imprt());
    if(useVars) {
      output.use(vars());
    }
    output.use(dedupe());
    if(useExtend) {
      output.use(inherit());
    }
    if(namespace) {
      output.use(namespace(ns));
    }
    if(urlString) {
      output.use(rework.url(function(url) {
        return urlString + url;
      }));
    }
    output.use(autoprefixer(browsers).rework);
    output = output.toString({sourcemap: debug})
      .replace(/(\/\*\*[\s\S]*?(license)[\s\S]*?\*\/)([\s\t]*(\r\n|\n|\r))/gi, '');

    if(license) {
      if(exists(license)) {
        output = read(license) + output;
      } else {
        throw new Error("Sorry, I couldn't find the license file. Make sure you supply a valid path.");
      }
    }

    return output;

var autoprefixer = require('autoprefixer')('last 2 versions')
  , clean = require('clean-css')
  , rework = require('rework')
  , fs = require('fs')

var css = fs.readFileSync(__dirname + '/../src/style.css', 'utf8')

css = rework(css)
  .use(rework.inline(__dirname + '/../img'))
  .toString()

css = autoprefixer.process(
  css
).css

css = new clean()
  .minify(css)

console.log(css)

Style.prototype.toString = function(){
  this.use(rework.mixin(mixins));
  this.use(rework.keyframes());
  this.use(rework.ease());
  this.use(rework.prefixValue('linear-gradient'));
  this.use(rework.prefixValue('radial-gradient'));
  this.use(rework.prefixValue('transform'));
  this.use(rework.prefix(props));
  this.use(rework.colors());
  this.use(rework.references());
  this.use(rework.at2x());
  this.use(rework.extend());
  return this.rework.toString({ compress: this.compress });
};

Style.prototype.toString = function(){
  this.use(rework.mixin(mixins));
  this.use(rework.keyframes());
  this.use(rework.ease());
  this.use(rework.prefixValue('linear-gradient'));
  this.use(rework.prefixValue('radial-gradient'));
  this.use(rework.prefixValue('transform'));
  this.use(rework.prefix(props));
  this.use(rework.colors());
  this.use(rework.references());
  this.use(rework.at2x());
  this.use(rework.extend());
  return this.rework.toString({ compress: this.compress });
};

function compile(css) {
  css = whitespace(css);
  return rework(css)
    .vendors(vendors)
    .use(rework.colors())
    .use(rework.references())
    .use(rework.keyframes())
    .use(rework.ease())
    .use(rework.prefixValue('transform'))
    .use(rework.prefix(props))
    .use(rework.mixin(mixins))
    .use(rework.at2x())
    .toString();
}