import io.bit3.jsass.CompilationException; //导入依赖的package包/类
@GET
@Path("{fileName:.+}")
@Produces("text/css")
public Response getCSS(@PathParam("fileName") String name, @Context Request request) {
    try {
        MCRServletContextResourceImporter importer = new MCRServletContextResourceImporter(context);
        Optional<String> cssFile = MCRSassCompilerManager.getInstance()
            .getCSSFile(name, Stream.of(importer).collect(Collectors.toList()));

        if (cssFile.isPresent()) {
            CacheControl cc = new CacheControl();
            cc.setMaxAge(SECONDS_OF_ONE_DAY);

            String etagString = MCRSassCompilerManager.getInstance().getLastMD5(name).get();
            EntityTag etag = new EntityTag(etagString);

            Response.ResponseBuilder builder = request.evaluatePreconditions(etag);
            if (builder != null) {
                return builder.cacheControl(cc).tag(etag).build();
            }

            return Response.ok().status(Response.Status.OK)
                .cacheControl(cc)
                .tag(etag)
                .entity(cssFile.get())
                .build();
        } else {
            return Response.status(Response.Status.NOT_FOUND)
                .build();
        }
    } catch (IOException | CompilationException e) {
        StreamingOutput so = (OutputStream os) -> e.printStackTrace(new PrintStream(os, true, "UTF-8"));
        return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(so).build();
    }
}
 

import io.bit3.jsass.CompilationException; //导入依赖的package包/类
private File cssFromSass(File source) throws IOException
{
    String sourceName = source.getName();

    int lastDotIndex = sourceName.lastIndexOf(SASS_SUFFIX);
    String cssName = sourceName.substring(0, lastDotIndex) + CSS_SUFFIX;
    File cssFile = new File(source.getParentFile(), cssName);

    //ONLY FROM CACHE IF WAS MODIFIED AFTER SASS FILE
    if (cssFile.exists() && source.lastModified() <= cssFile.lastModified())
    {
        List<String> lines = IOUtils.readLines(new FileInputStream(cssFile));
        if (lines != null && !lines.isEmpty())
        {
            return cssFile;
        }
    }

    if (!cssFile.exists() && !cssFile.createNewFile())
    {
        LOG.log(Level.SEVERE, "Could not create: {0} to compile sass", cssFile.getAbsolutePath());
        return null;
    }

    Compiler compiler = new Compiler();
    Options options = new Options();//TODO: options
    try
    {
        Output output = compiler.compileFile(source.toURI(), cssFile.toURI(), options);
        IOUtils.copy(new StringReader(output.getCss()), new FileOutputStream(cssFile));

        return cssFile;
    }
    catch (CompilationException ex)
    {
        LOG.log(Level.SEVERE, "Error compiling SASS: {0}", ex.getMessage());
        return null;
    }
}
 

import io.bit3.jsass.CompilationException; //导入依赖的package包/类
private static void sassify(File sassFile) {
    final File outputFile = getOutputFile(sassFile, Suffix.CSS);

    final URI inputURI = sassFile.toURI();
    final URI outputURI = outputFile.toURI();

    final Compiler compiler = new Compiler();
    try {
      final Output output = compiler.compileFile(inputURI, outputURI, new Options());
      FileUtils.writeStringToFile(outputFile, output.getCss(), Default.ENCODING.toString());
      logPreprocess(sassFile, outputFile);
    } catch (CompilationException | IOException e) {
        LOG.error("Failed to preprocess SASS file", e);
    }
}
 

import io.bit3.jsass.CompilationException; //导入依赖的package包/类
@Override
public void doDeploy(File root, String path, URL entry, MProperties config) {
	File f = new File(root, path);
	root = f.getParentFile();
	root.mkdirs();
	File out = new File(root, MFile.replaceSuffix(f.getName(), "css") );
	
	try {
		Output output = compiler.compileFile(f.toURI(), out.toURI(), options);
	} catch (CompilationException e) {
		log().e(f,e);
	}
	
}
 

import io.bit3.jsass.CompilationException; //导入依赖的package包/类
@Override
// If checkCacheInvalidation is true and, before invocation, a cached value exists and is not up to date, we evict the cache entry. 
@CacheEvict(value = "scssService.compiledStylesheets", 
		key = "T(fr.openwide.core.wicket.more.css.scss.service.ScssServiceImpl).getCacheKey(#scope, #path)",
		beforeInvocation = true,
		condition= "#checkCacheEntryUpToDate && !(caches.?[name=='scssService.compiledStylesheets'][0]?.get(T(fr.openwide.core.wicket.more.css.scss.service.ScssServiceImpl).getCacheKey(#scope, #path))?.get()?.isUpToDate() ?: false)"
		)
// THEN, we check if a cached value exists. If it does, it is returned ; if not, the method is called. 
@Cacheable(value = "scssService.compiledStylesheets",
		key = "T(fr.openwide.core.wicket.more.css.scss.service.ScssServiceImpl).getCacheKey(#scope, #path)")
public ScssStylesheetInformation getCompiledStylesheet(Class<?> scope, String path, boolean checkCacheEntryUpToDate)
		throws ServiceException {
	String scssPath = getFullPath(scope, path);
	
	try {
		JSassScopeAwareImporter importer = new JSassScopeAwareImporter(SCOPES);
		importer.addSourceUri(scssPath);
		
		Compiler compiler = new Compiler();
		Options options = new Options();
		options.setOutputStyle(OutputStyle.EXPANDED);
		options.setIndent("\t");
		options.getImporters().add(importer);
		
		ClassPathResource scssCpr = new ClassPathResource(scssPath);
		
		Context fileContext = new StringContext(IOUtils.toString(scssCpr.getInputStream()), new URI("classpath", "/" + scssPath, null), null, options);
		Output output = compiler.compile(fileContext);
		// Write result
		ScssStylesheetInformation compiledStylesheet = new ScssStylesheetInformation(scssPath, output.getCss());
		
		for (String sourceUri : importer.getSourceUris()) {
			ClassPathResource cpr = new ClassPathResource(sourceUri);
			compiledStylesheet.addImportedStylesheet(new ScssStylesheetInformation(sourceUri, cpr.lastModified()));
		}
		
		return compiledStylesheet;
	} catch (RuntimeException | IOException | URISyntaxException | CompilationException e) {
		throw new ServiceException(String.format("Error compiling %1$s", scssPath), e);
	}
}
 

import io.bit3.jsass.CompilationException; //导入依赖的package包/类
@Override
public String process(final String filename, final String source, final Config conf, final ClassLoader loader)
    throws Exception {
  String syntax = get("syntax");
  String importer = get("importer").toString().toUpperCase();
  Function<String, URI> resolver;
  if("FILE".equals(importer)) {
    resolver = FS;
  } else {
    resolver = CP.apply(loader);
  }
  OutputStyle style = OutputStyle.valueOf(get("style").toString().toUpperCase());

  Options options = new Options();
  options.setIsIndentedSyntaxSrc("sass".equals(syntax));
  options.getImporters().add(new SassImporter(syntax, resolver));
  options.setOutputStyle(style);
  options.setIndent(get("indent"));
  options.setLinefeed(get("linefeed"));
  options.setOmitSourceMapUrl(get("omitSourceMapUrl"));
  options.setPrecision(get("precision"));
  options.setSourceComments(get("sourceComments"));

  String sourcemap = get("sourcemap");
  if ("inline".equals(sourcemap)) {
    options.setSourceMapEmbed(true);
  } else if ("file".equals(sourcemap)) {
    options.setSourceMapFile(URI.create(filename + ".map"));
  }
  try {
    URI input = URI.create(filename);
    StringContext ctx = new StringContext(source, input, null, options);
    Output output = new Compiler().compile(ctx);
    return filename.endsWith(".map") ? output.getSourceMap() : output.getCss();
  } catch (CompilationException x) {
    Matcher matcher = LOCATION.matcher(x.getErrorJson());
    Map<String, Integer> location = new HashMap<>();
    while (matcher.find()) {
      location.put(matcher.group(1), Integer.parseInt(matcher.group(2)));
    }
    int line = location.getOrDefault("line", -1);
    int column = location.getOrDefault("column", -1);
    throw new AssetException(name(),
        new AssetProblem(Optional.ofNullable(x.getErrorFile()).orElse(filename), line, column,
            x.getErrorText(), null));
  }
}
 

import io.bit3.jsass.CompilationException; //导入依赖的package包/类
/**
 * Gets the compiled(&compressed) CSS
 *
 * @param file     the path to a .scss file. File should end with .css or .min.css (The compiler will look for the
 *                 .scss file, then compiles and decides to minify or not).
 * @param importer a additional list of importers
 * @return Optional with the compiled css as string. Empty optional if the fileName is not valid.
 * @throws CompilationException if {@link Compiler#compile(FileContext)} throws
 */
public synchronized Optional<String> getCSSFile(String file, List<Importer> importer)
    throws CompilationException, IOException {
    if (!isDeveloperMode() && fileCompiledContentMap.containsKey(file)) {
        return Optional.of(fileCompiledContentMap.get(file));
    } else {
        return Optional.ofNullable(compile(file, importer));
    }
}