redsnow 0.3.7 → 0.4.0

data/ext/drafter/src/SerializeSourcemap.h

@@ -0,0 +1,19 @@
+//
+//  SerializeSourcemap.h
+//  drafter
+//
+//  Created by Pavan Kumar Sunkara on 18/01/15.
+//  Copyright (c) 2015 Apiary Inc. All rights reserved.
+//
+
+#ifndef DRAFTER_SERIALIZE_SOURCEMAP_H
+#define DRAFTER_SERIALIZE_SOURCEMAP_H
+
+#include "Serialize.h"
+
+namespace drafter {
+
+    sos::Object WrapBlueprintSourcemap(const snowcrash::SourceMap<snowcrash::Blueprint>& blueprint);
+}
+
+#endif

data/ext/drafter/src/Version.h

@@ -0,0 +1,38 @@
+//
+//  version.h
+//  drafter
+//
+//  Created by Jiri Kratochvil on 2015-02-13
+//  Attribution Notice:
+//  This work might use parts of Node.js `node_version.h`
+//  https://github.com/joyent/node
+//
+//  Copyright (c) 2014 Apiary Inc. All rights reserved.
+//
+
+#ifndef DRAFTER_VERSION_H
+#define DRAFTER_VERSION_H
+
+#define DRAFTER_MAJOR_VERSION 0
+#define DRAFTER_MINOR_VERSION 1
+#define DRAFTER_PATCH_VERSION 0
+
+#define DRAFTER_VERSION_IS_RELEASE 1
+
+#ifndef DRAFTER_STRINGIFY
+#   define DRAFTER_STRINGIFY(n) DRAFTER_STRINGIFY_HELPER(n)
+#   define DRAFTER_STRINGIFY_HELPER(n) #n
+#endif
+
+#define DRAFTER_VERSION_STRING_HELPER "v" \
+                                        DRAFTER_STRINGIFY(DRAFTER_MAJOR_VERSION) "." \
+                                        DRAFTER_STRINGIFY(DRAFTER_MINOR_VERSION) "." \
+                                        DRAFTER_STRINGIFY(DRAFTER_PATCH_VERSION)
+
+#if DRAFTER_VERSION_IS_RELEASE
+#   define DRAFTER_VERSION_STRING DRAFTER_VERSION_STRING_HELPER
+#else
+#   define DRAFTER_VERSION_STRING DRAFTER_VERSION_STRING_HELPER "-pre"
+#endif
+
+#endif

data/ext/drafter/src/cdrafter.cc

@@ -0,0 +1,44 @@
+#include "cdrafter.h"
+
+#include "snowcrash.h"
+#include "sosJSON.h"
+
+#include "SerializeAST.h"
+#include "SerializeSourcemap.h"
+#include "SerializeResult.h"
+
+#include <string.h>
+
+namespace sc = snowcrash;
+
+static char* ToString(const std::stringstream& stream) 
+{
+    size_t length = stream.str().length() + 1;
+    char* str = (char*)malloc(length);
+    memcpy(str, stream.str().c_str(), length);
+    return str;
+}
+
+SC_API int drafter_c_parse(const char* source, 
+                           sc_blueprint_parser_options options, 
+                           char** result) 
+{
+
+    std::stringstream inputStream;
+
+    inputStream << source;
+
+    sc::ParseResult<sc::Blueprint> blueprint;
+    sc::parse(inputStream.str(), options, blueprint);
+
+    sos::SerializeJSON serializer;
+
+    if (result) {
+        std::stringstream resultStream;
+        serializer.process(drafter::WrapResult(blueprint, options), resultStream);
+        resultStream << "\n";
+        *result = ToString(resultStream);
+    }
+
+    return blueprint.report.error.code;
+}

data/ext/drafter/src/cdrafter.h

@@ -0,0 +1,55 @@
+//
+//  cdrafter.h
+//  drafter
+//  C Implementation of drafter lib for binding purposes
+//
+//  Created by Jiri Kratochvil on 27-02-2015
+//  Copyright (c) 2015 Apiary Inc. All rights reserved.
+//
+
+#ifndef SC_C_DRAFTER_H
+#define SC_C_DRAFTER_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "Platform.h" // use Platform.h from snowcrash - we should probably move it to drafter
+
+/**
+ *  \This is C interface for drafter parser.
+ *
+ *  \param source        A textual source data to be parsed.
+ *  \param options       Parser options. Use 0 for no addtional options.
+ *  \param result        parse result with ast, source map and annotations
+ *
+ *  for more info about Result format JSON \see https://github.com/apiaryio/api-blueprint-ast/blob/master/Parse%20Result.md
+ *
+ *  \return Error status code. Zero represents success, non-zero a failure.
+ *
+ *  This function will allocate memory and returns pointer to 
+ *  resul. Free allocated memory is responsibility of calling function.
+ *  You have to release it by calling standard free() function
+ *
+ *  if `result` input is NULL output is not created for param and parsed `source` is just validated
+ */
+
+typedef unsigned int sc_blueprint_parser_options;
+
+/** brief Blueprint Parser Options Enums */
+enum sc_blueprint_parser_option {
+    SC_RENDER_DESCRIPTIONS_OPTION = (1 << 0),       /// < Render Markdown in description.
+    SC_REQUIRE_BLUEPRINT_NAME_OPTION = (1 << 1),    /// < Treat missing blueprint name as error
+    SC_EXPORT_SORUCEMAP_OPTION = (1 << 2)           /// < Export source maps AST
+};
+
+SC_API int drafter_c_parse(const char* source, 
+                           sc_blueprint_parser_options option, 
+                           char** result);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+

data/ext/drafter/src/config.cc

@@ -0,0 +1,80 @@
+// 
+// vi:cin:et:sw=4 ts=4
+//
+//  config.cc - part of drafter
+//
+//  Created by Jiri Kratochvil on 2015-02-13
+//  Copyright (c) 2015 Apiary Inc. All rights reserved.
+//
+
+#include "config.h"
+#include "cmdline.h"
+
+#include "Version.h"
+
+namespace config {
+    static const std::string Program        = "drafter";
+
+    static const std::string Output         = "output";
+    static const std::string Format         = "format";
+    static const std::string Render         = "render";
+    static const std::string Sourcemap      = "sourcemap";
+    static const std::string Validate       = "validate";
+    static const std::string Version        = "version";
+    static const std::string UseLineNumbers = "use-line-num";
+};
+
+void PrepareCommanLineParser(cmdline::parser& parser)
+{
+    parser.set_program_name(config::Program);
+
+    parser.add<std::string>(config::Output,    'o', "save output AST into file", false);
+    parser.add<std::string>(config::Format,    'f', "output AST format", false, "yaml", cmdline::oneof<std::string>("yaml", "json"));
+    parser.add<std::string>(config::Sourcemap, 's', "export sourcemap AST into file", false);
+    parser.add("help",                         'h', "display this help message");
+    parser.add(config::Version ,               'v', "print Drafter version");
+    parser.add(config::Validate,               'l', "validate input only, do not print AST");
+    parser.add(config::UseLineNumbers ,        'u', "use line and row number instead of character index when printing annotation");
+
+    std::stringstream ss;
+
+    ss << "<input file>\n\n";
+    ss << "API Blueprint Parser\n";
+    ss << "If called without <input file>, 'drafter' will listen on stdin.\n";
+
+    parser.footer(ss.str());
+}
+
+void ValidateParsedCommandLine(const cmdline::parser& parser)
+{
+    if (parser.rest().size() > 1) {
+        std::cerr << "one input file expected, got " << parser.rest().size() << std::endl;
+        exit(EXIT_FAILURE);
+    }
+
+    if (parser.exist(config::Version)) {
+        std::cout << DRAFTER_VERSION_STRING << std::endl;
+        exit(EXIT_SUCCESS);
+    }
+
+}
+
+void ParseCommadLineOptions(int argc, const char *argv[], /* out */Config& conf)
+{
+    cmdline::parser parser;
+    PrepareCommanLineParser(parser);
+
+    parser.parse_check(argc, argv);
+
+    ValidateParsedCommandLine(parser);
+
+    if (!parser.rest().empty()) {
+        conf.input = parser.rest().front();
+    }
+
+    conf.lineNumbers = parser.exist(config::UseLineNumbers);
+    conf.validate    = parser.exist(config::Validate);
+    conf.format      = parser.get<std::string>(config::Format);
+    conf.output      = parser.get<std::string>(config::Output);
+    conf.sourceMap   = parser.get<std::string>(config::Sourcemap);
+}

data/ext/drafter/src/config.h

@@ -0,0 +1,35 @@
+//
+// vi:cin:et:sw=4 ts=4
+//
+//  config.h - part of drafter
+//
+//  Created by Jiri Kratochvil on 2015-02-13
+//  Copyright (c) 2015 Apiary Inc. All rights reserved.
+//
+#ifndef DRAFTER_CONFIG_H
+#define DRAFTER_CONFIG_H
+
+#include <string>
+
+struct Config {
+    std::string input;
+    bool lineNumbers;
+    bool validate;
+    std::string format;
+    std::string sourceMap;
+    std::string output;
+};
+
+/**
+ *  \brief parse commandline params
+ *
+ *  \param argc argc as received to main()
+ *  \param argv argv as received to main()
+ *  \param conf output - parsed parameters
+ *
+ *  side effect - can call exit() if wrong params are sent to program
+ */
+void ParseCommadLineOptions(int argc, const char *argv[], /** out */Config& conf);
+
+
+#endif /* end of include guard: DRAFTER_CONFIG_H */

data/ext/drafter/src/drafter.cc

@@ -0,0 +1,22 @@
+//
+//  drafter.cc
+//
+//  drafter
+//
+//  Created by Jiri Kratochvil on 2015-03-05
+//  Copyright (c) 2015 Apiary Inc. All rights reserved.
+//
+#include "drafter.h"
+
+namespace drafter {
+
+    /**
+     * For now just redirect to snowcrash::parse()
+     */
+    int ParseBlueprint(const mdp::ByteBuffer& source,
+              snowcrash::BlueprintParserOptions options,
+              const snowcrash::ParseResultRef<snowcrash::Blueprint>& out)
+    {
+        return snowcrash::parse(source, options, out);
+    }
+}

data/ext/drafter/src/drafter.h

@@ -0,0 +1,38 @@
+//
+//  drafter.h
+//
+//  drafter
+//
+//  Created by Jiri Kratochvil on 2015-03-05
+//  Copyright (c) 2015 Apiary Inc. All rights reserved.
+//
+
+#ifndef DRAFTER_H
+#define DRAFTER_H
+
+#include "snowcrash.h"
+
+
+/**
+ *  API Blueprint Parser Interface
+ *  ------------------------------
+ *
+ *  This is the parser's entry point.
+ */
+
+namespace drafter {
+
+    /**
+     *  \brief Parse the source data into a blueprint abstract source tree (AST).
+     *
+     *  \param source       A textual source data to be parsed.
+     *  \param options      Parser options. Use 0 for no additional options.
+     *  \param out          Output buffer to store parsing result into.
+     *  \return Error status code. Zero represents success, non-zero a failure.
+     */
+    int ParseBlueprint(const mdp::ByteBuffer& source,
+              snowcrash::BlueprintParserOptions options,
+              const snowcrash::ParseResultRef<snowcrash::Blueprint>& out);
+}
+
+#endif // #ifndef DRAFTER_H

data/ext/drafter/src/main.cc

@@ -0,0 +1,91 @@
+// vi:cin:et:sw=4 ts=4
+//
+//  drafter.cc
+//
+//  Created by Jiri Kratochvil on 2015-02-11
+//  Copyright (c) 2015 Apiary Inc. All rights reserved.
+//
+
+
+#include "snowcrash.h"
+#include "SectionParserData.h"  // snowcrash::BlueprintParserOptions
+
+#include "sos.h"
+#include "sosJSON.h"
+#include "sosYAML.h"
+
+#include "SerializeAST.h"
+#include "SerializeSourcemap.h"
+
+#include "reporting.h"
+#include "config.h"
+#include "stream.h"
+
+namespace sc = snowcrash;
+
+/**
+ *  \brief  return instance sos::Serializer based on \param `format`
+ *
+ *  \param format - output format for serialization
+ */
+sos::Serialize* CreateSerializer(const std::string& format)
+{
+    if (format == "json") {
+        return new sos::SerializeJSON;
+    } else if (format == "yaml") {
+        return new sos::SerializeYAML;
+    }
+
+    std::cerr << "fatal: unknow serialization format: '" << format << "'\n";
+    exit(EXIT_FAILURE);
+}
+
+/**
+ * \brief Serialize sos::Object into stream
+ */
+void Serialization(std::ostream *stream,
+                   const sos::Object& object,
+                   sos::Serialize* serializer)
+{
+    serializer->process(object, *stream);
+    *stream << "\n";
+    *stream << std::flush;
+}
+
+int main(int argc, const char *argv[])
+{
+    Config config; 
+    ParseCommadLineOptions(argc, argv, config);
+
+    sc::BlueprintParserOptions options = 0;  // Or snowcrash::RequireBlueprintNameOption
+    if (!config.sourceMap.empty()) {
+        options |= snowcrash::ExportSourcemapOption;
+    }
+
+    std::stringstream inputStream;
+    std::auto_ptr<std::istream> in(CreateStreamFromName<std::istream>(config.input));
+    inputStream << in->rdbuf();
+
+    sc::ParseResult<sc::Blueprint> blueprint;
+    sc::parse(inputStream.str(), options, blueprint);
+
+    if (!config.validate) {  // not just validate -> we will serialize
+        sos::Serialize* serializer = CreateSerializer(config.format);
+
+        Serialization(CreateStreamFromName<std::ostream>(config.output),
+                      drafter::WrapBlueprint(blueprint.node), 
+                      serializer);
+
+        if (options & snowcrash::ExportSourcemapOption) {
+            Serialization(CreateStreamFromName<std::ostream>(config.sourceMap),
+                          drafter::WrapBlueprintSourcemap(blueprint.sourceMap),
+                          serializer);
+        }
+
+        delete serializer;
+    }
+
+    PrintReport(blueprint.report, inputStream.str(), config.lineNumbers);
+
+    return blueprint.report.error.code;
+}

data/ext/drafter/src/reporting.cc

@@ -0,0 +1,162 @@
+//
+// vi:cin:et:sw=4 ts=4
+//
+//  reporting.cc - part of drafter
+//
+//  Created by Jiri Kratochvil on 2015-02-13
+//  Copyright (c) 2015 Apiary Inc. All rights reserved.
+//
+
+#include "reporting.h"
+
+#include <algorithm>
+#include <iostream>
+
+namespace sc = snowcrash;
+
+/** structure contains starting and ending position of a error/warning. */
+struct AnnotationPosition {
+    size_t fromLine;
+    size_t fromColumn;
+    size_t toLine;
+    size_t toColumn;
+};
+
+/**
+ *  \brief Convert character index mapping to line and column number
+ *  \param linesEndIndex Vector containing indexes of end line characters
+ *  \param range Character index mapping as input
+ *  \param out Position of the given range as output
+ */
+void GetLineFromMap(const std::vector<size_t>& linesEndIndex,
+                    const mdp::Range& range,
+                    AnnotationPosition& out)
+{
+
+    std::vector<size_t>::const_iterator annotationPositionIt;
+
+    out.fromLine = 0;
+    out.fromColumn = 0;
+    out.toLine = 0;
+    out.toColumn = 0;
+
+    // Finds starting line and column position
+    annotationPositionIt = std::upper_bound(linesEndIndex.begin(), linesEndIndex.end(), range.location) - 1;
+
+    if (annotationPositionIt != linesEndIndex.end()) {
+
+        out.fromLine = std::distance(linesEndIndex.begin(), annotationPositionIt) + 1;
+        out.fromColumn = range.location - *annotationPositionIt + 1;
+    }
+
+    // Finds ending line and column position
+    annotationPositionIt = std::lower_bound(linesEndIndex.begin(), linesEndIndex.end(), range.location + range.length) - 1;
+
+    if (annotationPositionIt != linesEndIndex.end()) {
+
+        out.toLine = std::distance(linesEndIndex.begin(), annotationPositionIt) + 1;
+        out.toColumn = (range.location + range.length) - *annotationPositionIt + 1;
+
+        if (*(annotationPositionIt + 1) == (range.location + range.length)) {
+            out.toColumn--;
+        }
+    }
+}
+
+/**
+ *  \brief Given the source returns the length of all the lines in source as a vector
+ *  \param source Source data
+ *  \param out Vector containing indexes of all end line character in source
+ */
+void GetLinesEndIndex(const std::string& source,
+                      std::vector<size_t>& out)
+{
+
+    out.push_back(0);
+
+    for (size_t i = 0; i < source.length(); i++) {
+
+        if (source[i] == '\n') {
+            out.push_back(i + 1);
+        }
+    }
+}
+
+/**
+ *  \brief Print Markdown source annotation.
+ *  \param prefix A string prefix for the annotation
+ *  \param annotation An annotation to print
+ *  \param source Source data
+ *  \param isUseLineNumbers True if the annotations needs to be printed by line and column number
+ */
+void PrintAnnotation(const std::string& prefix,
+                     const snowcrash::SourceAnnotation& annotation,
+                     const std::string& source,
+                     const bool isUseLineNumbers)
+{
+
+    std::cerr << prefix;
+
+    if (annotation.code != sc::SourceAnnotation::OK) {
+        std::cerr << " (" << annotation.code << ") ";
+    }
+
+    if (!annotation.message.empty()) {
+        std::cerr << " " << annotation.message;
+    }
+
+    std::vector<size_t> linesEndIndex;
+
+    if (isUseLineNumbers) {
+        GetLinesEndIndex(source, linesEndIndex);
+    }
+
+    if (!annotation.location.empty()) {
+
+        for (mdp::CharactersRangeSet::const_iterator it = annotation.location.begin();
+             it != annotation.location.end();
+             ++it) {
+
+            if (isUseLineNumbers) {
+
+                AnnotationPosition annotationPosition;
+                GetLineFromMap(linesEndIndex, *it, annotationPosition);
+
+                std::cerr << "; line " << annotationPosition.fromLine << ", column " << annotationPosition.fromColumn;
+                std::cerr << " - line " << annotationPosition.toLine << ", column " << annotationPosition.toColumn;
+            }
+            else {
+
+                std::cerr << ((it == annotation.location.begin()) ? " :" : ";");
+                std::cerr << it->location << ":" << it->length;
+            }
+        }
+    }
+
+    std::cerr << std::endl;
+}
+
+/**
+ *  \brief Print parser report to stderr.
+ *  \param report A parser report to print
+ *  \param source Source data
+ *  \param isUseLineNumbers True if the annotations needs to be printed by line and column number
+ */
+void PrintReport(const snowcrash::Report& report,
+                 const std::string& source,
+                 const bool isUseLineNumbers)
+{
+
+    std::cerr << std::endl;
+
+    if (report.error.code == sc::Error::OK) {
+        std::cerr << "OK.\n";
+    }
+    else {
+        PrintAnnotation("error:", report.error, source, isUseLineNumbers);
+    }
+
+    for (snowcrash::Warnings::const_iterator it = report.warnings.begin(); it != report.warnings.end(); ++it) {
+        PrintAnnotation("warning:", *it, source, isUseLineNumbers);
+    }
+}