示例#1
0
        internal static bool Compile(string currentDir, string inputFile, string outputFile, Context context, bool minify, bool warnAsErrors, bool autoCacheBreak, bool autoPrefix)
        {
            var opts = Options.None;
            var writerMode = WriterMode.Pretty;

            if (minify)
            {
                opts |= Options.Minify;
                writerMode = WriterMode.Minimize;
            }

            if (warnAsErrors)
            {
                opts |= Options.WarningsAsErrors;
            }

            if (autoCacheBreak)
            {
                opts |= Options.GenerateCacheBreakers;
            }

            if (autoPrefix)
            {
                opts |= Options.AutomateVendorPrefixes;
            }

            return Compiler.Get().Compile(currentDir, inputFile, outputFile, FileLookup.Singleton, context, opts, writerMode);
        }
示例#2
0
        private string TryCompile(string text, IFileLookup lookup = null, bool reset = true)
        {
            Context context;
            Options opts;
            WriterMode mode;

            if (reset)
            {
                context = new Context(new FileCache());
                opts = Options.None;
                mode = WriterMode.Minimize;
            }
            else
            {
                context = Current.InnerContext.Value;
                opts = Current.Options;
                mode = Current.WriterMode;
            }

            var fakeFile = "error-fake-file" + Interlocked.Increment(ref TryCompileNumber) + ".more";
            var fileLookup = new TestLookup(new Dictionary<string, string>() { { fakeFile, text } }, lookup);

            var compiler = Compiler.Get();
            compiler.Compile(Environment.CurrentDirectory, fakeFile, fakeFile + ".out", fileLookup, context, opts, mode);
            return fileLookup.WriteMap.ElementAt(0).Value;
        }
示例#3
0
        private string TryCompile(string text, string fakeFile = null, IFileLookup lookup = null, bool minify = false, WriterMode mode = WriterMode.Minimize, bool cacheBreak = false, bool prefix = false)
        {
            if (mode == WriterMode.Minimize)
            {
                try
                {
                    TryCompile(text, null, lookup, minify, WriterMode.Pretty);
                }
                catch (Exception e)
                {
                    Assert.Fail("Pretty writing failed");
                }
            }

            fakeFile = fakeFile ?? "compiler-fake-file " + Interlocked.Increment(ref TryCompileNumber) + ".more";

            Options opts = Options.None;
            if (minify)
            {
                opts |= Options.Minify;
            }

            if (cacheBreak)
            {
                opts |= Options.GenerateCacheBreakers;
            }

            if (prefix)
            {
                opts |= Options.AutomateVendorPrefixes;
            }

            var fileLookup = new TestLookup(new Dictionary<string, string>() { { fakeFile, text } }, lookup);

            var compiler = Compiler.Get();
            var ctx = new Context(new FileCache());

            // it's hard to test minification steps if they all always run, so let's just go for a single pass in the "text comparison" cases
            //   still do the full thing when we're doing our test "pretty pass" elsewhere to make sure it always terminates
            ctx.DisableMultipleMinificationPasses = mode != WriterMode.Pretty;

            compiler.Compile(Environment.CurrentDirectory, fakeFile, fakeFile + ".out", fileLookup, ctx, opts, mode);
            var ret =  fileLookup.WriteMap.ElementAt(0).Value;

            return ret;
        }
示例#4
0
        public void MergeContexts()
        {
            var a = new Context(new FileCache());
            var b = new Context(new FileCache());

            a.Errors[ErrorType.Compiler] = new List<Error>() { Error.Create(ErrorType.Compiler, -1, -1, "test error", "dummy file 1") };
            a.Errors[ErrorType.Parser] = new List<Error>() { Error.Create(ErrorType.Parser, -1, -1, "test error", "dummy file 1") };
            a.Warnings[ErrorType.Parser] = new List<Error>() { Error.Create(ErrorType.Parser, -1, -1, "test error", "dummy file 1"), Error.Create(ErrorType.Compiler, -1, -1, "test error", "dummy file 3") };
            a.Warnings[ErrorType.Compiler] = new List<Error>() { Error.Create(ErrorType.Compiler, -1, -1, "test error", "dummy file 1") };

            b.Errors[ErrorType.Compiler] = new List<Error>() { Error.Create(ErrorType.Compiler, -1, -1, "test error", "dummy file 2") };
            b.Errors[ErrorType.Parser] = new List<Error>() { Error.Create(ErrorType.Parser, -1, -1, "test error", "dummy file 2") };
            b.Warnings[ErrorType.Parser] = new List<Error>() { Error.Create(ErrorType.Parser, -1, -1, "test error", "dummy file 2"), Error.Create(ErrorType.Compiler, -1, -1, "test error", "dummy file 3") };
            b.Warnings[ErrorType.Compiler] = new List<Error>() { Error.Create(ErrorType.Compiler, -1, -1, "test error", "dummy file 2") };

            var c = a.Merge(b);

            Assert.AreEqual(2, c.Errors.Count);
            Assert.AreEqual(2, c.Warnings.Count);

            Assert.AreEqual(2, c.GetErrors()[ErrorType.Compiler].Count());
            Assert.AreEqual(2, c.GetErrors()[ErrorType.Parser].Count());
            Assert.AreEqual(2, c.GetWarnings()[ErrorType.Parser].Count());
            Assert.AreEqual(4, c.GetWarnings()[ErrorType.Compiler].Count());
        }
示例#5
0
        static bool MultiThreadedCompile(int maxParallelism, string workingDirectory, List<string> toCompile, bool overwrite, bool warnAsErrors, bool minify, bool verbose, string spriteProg, string spriteArguments, bool autoCacheBreak, bool autoPrefix, out DependencyGraph dependencies)
        {
            var @lock = new Semaphore(0, toCompile.Count);
            var contexts = new ConcurrentBag<Context>();
            var outMsg = new ConcurrentBag<string>();

            toCompile.AsParallel()
                .WithDegreeOfParallelism(maxParallelism)
                .WithExecutionMode(ParallelExecutionMode.ForceParallelism)
                .ForAll(
                    delegate(string compile)
                    {
                        try
                        {
                            var threadContext = new Context(FileCache);
                            contexts.Add(threadContext);

                            var buffer = new StringBuilder();

                            var outputFile = OutputFileFor(compile, overwrite: overwrite);
                            buffer.AppendLine("\t" + compile);
                            buffer.Append("\tto " + outputFile);

                            var timer = new Stopwatch();
                            timer.Start();

                            var result = Compile(workingDirectory, compile, outputFile, threadContext, minify, warnAsErrors, autoCacheBreak, autoPrefix);

                            timer.Stop();

                            if (result)
                            {
                                buffer.AppendLine(" in " + timer.ElapsedMilliseconds + "ms");
                            }
                            else
                            {
                                buffer.AppendLine(" failed after " + timer.ElapsedMilliseconds + "ms");
                            }

                            outMsg.Add(buffer.ToString());
                        }
                        finally
                        {
                            @lock.Release();
                        }
                    }
                );

            for (int i = 0; i < toCompile.Count; i++)
                @lock.WaitOne();

            var mergedContext = contexts.ElementAt(0);
            for (int i = 1; i < contexts.Count; i++)
            {
                mergedContext = mergedContext.Merge(contexts.ElementAt(i));
            }

            dependencies = mergedContext.Dependecies;

            var infoMessages = mergedContext.GetInfoMessages().ToList();
            var errors = mergedContext.GetErrors();

            if (spriteProg.HasValue())
            {
                foreach (var sprite in mergedContext.GetSpriteFiles())
                {
                    var commandErrors = RunSpriteCommand(spriteProg, workingDirectory, sprite, spriteArguments, infoMessages);

                    errors = errors.SelectMany(s => s.ToList()).Union(commandErrors).ToLookup(k => k.Type);
                }
            }

            if (verbose)
            {
                foreach (var msg in outMsg)
                {
                    Console.Write(msg);
                }

                if (outMsg.Count > 0) Console.WriteLine();
            }

            if (errors.Count > 0)
            {
                var parseErrors = errors.Where(e => e.Key == ErrorType.Parser).SelectMany(s => s.ToList()).Distinct().ToList();
                var compileErrors = errors.Where(e => e.Key == ErrorType.Compiler).SelectMany(s => s.ToList()).Distinct().ToList();

                Print("Errors", parseErrors, compileErrors);
            }

            if (mergedContext.GetWarnings().Count > 0)
            {
                var parseWarnings = mergedContext.GetWarnings().Where(e => e.Key == ErrorType.Parser).SelectMany(s => s.ToList()).Distinct().ToList();
                var compileWarnings = mergedContext.GetWarnings().Where(e => e.Key == ErrorType.Compiler).SelectMany(s => s.ToList()).Distinct().ToList();

                Print("Warnings", parseWarnings, compileWarnings);
            }

            if (verbose && infoMessages.Count > 0)
            {
                Console.WriteLine("INFO");
                Console.WriteLine("====");
                foreach (var i in infoMessages)
                {
                    Console.WriteLine(i);
                }
            }

            return mergedContext.GetErrors().Count == 0;
        }
示例#6
0
文件: Current.cs 项目: repos-css/More
 public static void SetContext(Context context)
 {
     InnerContext.Value = context;
 }
示例#7
0
文件: Current.cs 项目: repos-css/More
        public Context Merge(Context other)
        {
            if (this.Options != other.Options ||
              this.WriterMode != other.WriterMode)
            {
                throw new InvalidOperationException();
            }

            var errors = this.Errors.ToDictionary(d => d.Key, d => d.Value.ToList());
            foreach (var k in other.Errors.Keys)
            {
                if (errors.ContainsKey(k))
                {
                    errors[k].AddRange(other.Errors[k]);
                }
                else
                {
                    errors[k] = other.Errors[k].ToList();
                }
            }

            var warnings = this.Warnings.ToDictionary(d => d.Key, d => d.Value.ToList());
            foreach (var k in other.Warnings.Keys)
            {
                if (warnings.ContainsKey(k))
                {
                    warnings[k].AddRange(other.Warnings[k]);
                }
                else
                {
                    warnings[k] = other.Warnings[k].ToList();
                }
            }

            var infos = this.GetInfoMessages().ToList();
            infos.AddRange(other.GetInfoMessages());

            // Dupes should be removed here, thus Union()
            var sprites = this.GetSpriteFiles().Union(other.GetSpriteFiles()).ToList();

            var ret = new Context(this.FileCache);
            ret.Errors = errors;
            ret.Warnings = warnings;
            ret.InfoMessages = infos;
            ret.SpriteFiles = sprites;
            ret.Options = this.Options;
            ret.WriterMode = this.WriterMode;

            return ret;
        }