Parses HTML, repairing and scrubbing against various whitelist filters.
Note: this class is thread-safe (all external changes are locked first)
Example #1
0
        /// <summary>
        /// Compiles the provided input
        /// </summary>
        /// <param name="input"></param>
        /// <param name="filename"></param>
        /// <param name="compilationErrors"></param>
        /// <param name="compactionErrors"></param>
        /// <returns></returns>
        public IOptimizedResult Compile(TextReader input, string filename, List<ParseException> compilationErrors, List<ParseException> compactionErrors)
        {
            if (input == null)
            {
                throw new ArgumentNullException("input");
            }

            // verify, compact and write out results
            // parse JBST markup
            JbstWriter writer = new JbstWriter(filename);

            StringWriter sw = new StringWriter();

            string source = input.ReadToEnd();
            try
            {
                HtmlDistiller parser = new HtmlDistiller();
                parser.EncodeNonAscii = false;
                parser.BalanceTags = false;
                parser.NormalizeWhitespace = false;
                parser.HtmlWriter = writer;
                parser.HtmlFilter = new NullHtmlFilter();
                parser.Parse(source);

                // render the pretty-printed version
                writer.Render(sw);
            }
            catch (ParseException ex)
            {
                compilationErrors.Add(ex);
            }
            catch (Exception ex)
            {
                compilationErrors.Add(new ParseError(ex.Message, filename, 0, 0, ex));
            }

            SimpleJbstBuildResult result = new SimpleJbstBuildResult(writer.JbstName, writer.AutoMarkup);

            result.Source = source;
            result.PrettyPrinted = sw.GetStringBuilder().ToString();
            result.Compacted = this.Compact(result.PrettyPrinted, filename, compactionErrors);
            result.ContentType = "text/javascript";
            result.FileExtension = ".jbst.js";
            result.Hash = this.ComputeHash(result.Source);

            // return any errors
            return result;
        }
Example #2
0
    public static List<ParseException> Compile(
        string inputFile,
        string inputSource,
        TextWriter output,
        string copyright,
        string timeStamp,
        bool prettyPrint)
    {
        if (output == null)
        {
            throw new NullReferenceException("Output TextWriter was null.");
        }

        if (String.IsNullOrEmpty(inputSource))
        {
            if (String.IsNullOrEmpty(inputFile))
            {
                throw new NullReferenceException("Input file path was empty.");
            }

            inputSource = File.ReadAllText(inputFile);
        }

        // write out header with copyright and timestamp
        WriteHeader(output, copyright, timeStamp);

        // verify, compact and write out results
        // parse JBST markup
        JbstWriter writer = new JbstWriter(inputFile);

        List<ParseException> errors = new List<ParseException>();
        try
        {
            HtmlDistiller parser = new HtmlDistiller();
            parser.EncodeNonAscii = false;
            parser.BalanceTags = false;
            parser.NormalizeWhitespace = false;
            parser.HtmlWriter = writer;
            parser.HtmlFilter = new NullHtmlFilter();
            parser.Parse(inputSource);
        }
        catch (ParseException ex)
        {
            errors.Add(ex);
        }
        catch (Exception ex)
        {
            errors.Add(new ParseError(ex.Message, inputFile, 0, 0, ex));
        }

        // render the pretty-printed version
        writer.Render(output);

        // return any errors
        return errors;
    }
        /// <summary>
        /// Quick conversion to plain text.
        /// </summary>
        /// <param name="html">the source text</param>
        /// <param name="maxLength">the maximum text length</param>
        /// <returns>plain text</returns>
        public static string PlainText(string html, int maxLength)
        {
            StringWriter writer = new StringWriter();

            HtmlDistiller parser = new HtmlDistiller(maxLength, new StripHtmlFilter());
            parser.HtmlWriter = new HtmlWriter(writer);
            parser.EncodeNonAscii = false;
            parser.Parse(html);

            return writer.ToString();
        }
        protected override void ProcessResource(
            IResourceBuildHelper helper,
            string virtualPath,
            string sourceText,
            out string resource,
            out string compacted,
            List<ParseException> errors)
        {
            // parse JBST markup
            this.jbstWriter = new JbstWriter(virtualPath);

            try
            {
                HtmlDistiller parser = new HtmlDistiller();
                parser.EncodeNonAscii = false;
                parser.BalanceTags = false;
                parser.NormalizeWhitespace = false;
                parser.HtmlWriter = this.jbstWriter;
                parser.HtmlFilter = new NullHtmlFilter();
                parser.Parse(sourceText);

                // determine which globalization keys were used
                JbstCodeProvider.ExtractGlobalizationKeys(this.jbstWriter.JbstParseTree, this.GlobalizationKeys);
            }
            catch (ParseException ex)
            {
                errors.Add(ex);
            }
            catch (Exception ex)
            {
                errors.Add(new ParseError(ex.Message, virtualPath, 0, 0, ex));
            }

            string renderedTemplate;
            using (StringWriter sw = new StringWriter())
            {
                // render the pretty-printed version
                this.jbstWriter.Render(sw);
                sw.Flush();
                renderedTemplate = sw.ToString();

                resource = ScriptResourceCodeProvider.FirewallScript(virtualPath, renderedTemplate, false);
            }

            // min the output for better compaction
            compacted = ScriptCompactionAdapter.Compact(virtualPath, renderedTemplate, errors);
            compacted = ScriptResourceCodeProvider.FirewallScript(virtualPath, compacted, true);
        }
        /// <summary>
        /// Quick parsing utility for common usage.
        /// </summary>
        /// <param name="html">the source text</param>
        /// <param name="filter">a custom HtmlFilter</param>
        /// <param name="maxLength">the maximum text length</param>
        /// <returns>the filtered markup</returns>
        public static string Parse(string html, IHtmlFilter filter, int maxLength)
        {
            StringWriter writer = new StringWriter();

            HtmlDistiller parser = new HtmlDistiller(maxLength, filter);
            parser.HtmlWriter = new HtmlWriter(writer);
            parser.Parse(html);

            return writer.ToString();
        }