lounge_lizard 0.1.0

data/ext/drafter/src/SerializeResult.h

@@ -0,0 +1,34 @@
+//
+//  SerializeResult.h
+//  drafter
+//
+//  Created by Jiri Kratochvil on 27-02-2015
+//  Copyright (c) 2015 Apiary Inc. All rights reserved.
+//
+
+#ifndef DRAFTER_SERIALIZERESULT_H
+#define DRAFTER_SERIALIZERESULT_H
+
+#include "Serialize.h"
+#include "SectionParserData.h"
+
+namespace snowcrash {
+    struct SourceAnnotation;
+}
+
+namespace refract {
+    struct IElement;
+}
+
+namespace drafter {
+
+    class ConversionContext;
+
+    sos::Object WrapAnnotation(const snowcrash::SourceAnnotation& annotation);
+    sos::Object WrapResult(snowcrash::ParseResult<snowcrash::Blueprint>& blueprint, const WrapperOptions& options);
+
+    refract::IElement* WrapParseResultRefract(snowcrash::ParseResult<snowcrash::Blueprint>& blueprint,
+                                              ConversionContext& context);
+}
+
+#endif // #ifndef DRAFTER_SERIALIZERESULT_H

data/ext/drafter/src/SerializeSourcemap.cc

@@ -0,0 +1,331 @@
+//
+//  SerializeSourcemap.cc
+//  drafter
+//
+//  Created by Pavan Kumar Sunkara on 18/01/15.
+//  Copyright (c) 2015 Apiary Inc. All rights reserved.
+//
+
+#include "SerializeSourcemap.h"
+#include "ConversionContext.h"
+
+using namespace drafter;
+
+using snowcrash::SourceMapBase;
+using snowcrash::SourceMap;
+using snowcrash::Collection;
+
+using snowcrash::DataStructure;
+using snowcrash::Asset;
+using snowcrash::Payload;
+using snowcrash::Header;
+using snowcrash::Parameter;
+using snowcrash::Value;
+using snowcrash::TransactionExample;
+using snowcrash::Request;
+using snowcrash::Response;
+using snowcrash::Action;
+using snowcrash::Resource;
+using snowcrash::Element;
+using snowcrash::Description;
+using snowcrash::Blueprint;
+using snowcrash::Metadata;
+
+sos::Array WrapSourcemap(const SourceMapBase& value)
+{
+    sos::Array sourceMap;
+
+    for (mdp::RangeSet<mdp::BytesRange>::const_iterator it = value.sourceMap.begin();
+         it != value.sourceMap.end();
+         ++it) {
+
+        sos::Array sourceMapRow;
+
+        sourceMapRow.push(sos::Number(it->location));
+        sourceMapRow.push(sos::Number(it->length));
+
+        sourceMap.push(sourceMapRow);
+    }
+
+    return sourceMap;
+}
+
+sos::Object WrapAssetSourcemap(const SourceMap<Asset>& asset)
+{
+    sos::Object assetObject;
+
+    // Content
+    assetObject.set(SerializeKey::Content, WrapSourcemap(asset));
+
+    return assetObject;
+}
+
+sos::Object WrapPayloadSourcemap(const SourceMap<Payload>& payload)
+{
+    sos::Object payloadObject;
+
+    // Reference
+    if (!payload.reference.sourceMap.empty()) {
+        payloadObject.set(SerializeKey::Reference, WrapSourcemap(payload.reference));
+    }
+
+    // Name
+    payloadObject.set(SerializeKey::Name, WrapSourcemap(payload.name));
+
+    // Description
+    payloadObject.set(SerializeKey::Description, WrapSourcemap(payload.description));
+
+    // Headers
+    payloadObject.set(SerializeKey::Headers,
+                      WrapCollection<Header>()(payload.headers.collection, WrapSourcemap));
+
+    // Body
+    payloadObject.set(SerializeKey::Body, WrapSourcemap(payload.body));
+
+    // Schema
+    payloadObject.set(SerializeKey::Schema, WrapSourcemap(payload.schema));
+
+    // Content
+    sos::Array content;
+
+    /// Asset 'bodyExample'
+    if (!payload.body.sourceMap.empty()) {
+        content.push(WrapAssetSourcemap(payload.body));
+    }
+
+    /// Asset 'bodySchema'
+    if (!payload.schema.sourceMap.empty()) {
+        content.push(WrapAssetSourcemap(payload.schema));
+    }
+
+    payloadObject.set(SerializeKey::Content, content);
+
+    return payloadObject;
+}
+
+sos::Object WrapParameterValueSourceMap(const SourceMap<Value>& value)
+{
+    sos::Object object;
+    object.set(SerializeKey::Value, WrapSourcemap(value));
+    return object;
+}
+
+sos::Object WrapParameterSourcemap(const SourceMap<Parameter>& parameter)
+{
+    sos::Object object;
+
+    // Name
+    object.set(SerializeKey::Name, WrapSourcemap(parameter.name));
+
+    // Description
+    object.set(SerializeKey::Description, WrapSourcemap(parameter.description));
+
+    // Type
+    object.set(SerializeKey::Type, WrapSourcemap(parameter.type));
+
+    // Use
+    object.set(SerializeKey::Required, WrapSourcemap(parameter.use));
+
+    // Example Value
+    object.set(SerializeKey::Example, WrapSourcemap(parameter.exampleValue));
+
+    // Default Value
+    object.set(SerializeKey::Default, WrapSourcemap(parameter.defaultValue));
+
+    // Values
+    object.set(SerializeKey::Values,
+               WrapCollection<Value>()(parameter.values.collection, WrapParameterValueSourceMap));
+
+    return object;
+}
+
+sos::Object WrapTransactionExampleSourcemap(const SourceMap<TransactionExample>& example)
+{
+    sos::Object exampleObject;
+
+    // Name
+    exampleObject.set(SerializeKey::Name, WrapSourcemap(example.name));
+
+    // Description
+    exampleObject.set(SerializeKey::Description, WrapSourcemap(example.description));
+
+    // Requests
+    exampleObject.set(SerializeKey::Requests,
+                      WrapCollection<Request>()(example.requests.collection, WrapPayloadSourcemap));
+
+    // Responses
+    exampleObject.set(SerializeKey::Responses,
+                      WrapCollection<Response>()(example.responses.collection, WrapPayloadSourcemap));
+
+    return exampleObject;
+}
+
+sos::Object WrapActionSourcemap(const SourceMap<Action>& action)
+{
+    sos::Object actionObject;
+
+    // Name
+    actionObject.set(SerializeKey::Name, WrapSourcemap(action.name));
+
+    // Description
+    actionObject.set(SerializeKey::Description, WrapSourcemap(action.description));
+
+    // HTTP Method
+    actionObject.set(SerializeKey::Method, WrapSourcemap(action.method));
+
+    // Parameters
+    actionObject.set(SerializeKey::Parameters,
+                     WrapCollection<Parameter>()(action.parameters.collection, WrapParameterSourcemap));
+
+    // Transaction Examples
+    actionObject.set(SerializeKey::Examples,
+                     WrapCollection<TransactionExample>()(action.examples.collection, WrapTransactionExampleSourcemap));
+
+    // Attributes
+    sos::Object attributes;
+
+    /// Relation
+    attributes.set(SerializeKey::Relation, WrapSourcemap(action.relation));
+
+    /// URI Template
+    attributes.set(SerializeKey::URITemplate, WrapSourcemap(action.uriTemplate));
+
+    actionObject.set(SerializeKey::Attributes, attributes);
+
+    // Content
+    sos::Array content;
+
+    actionObject.set(SerializeKey::Content, content);
+
+    return actionObject;
+}
+
+sos::Object WrapResourceSourcemap(const SourceMap<Resource>& resource)
+{
+    sos::Object resourceObject;
+
+    // Name
+    resourceObject.set(SerializeKey::Name, WrapSourcemap(resource.name));
+
+    // Description
+    resourceObject.set(SerializeKey::Description, WrapSourcemap(resource.description));
+
+    // URI Template
+    resourceObject.set(SerializeKey::URITemplate, WrapSourcemap(resource.uriTemplate));
+
+    // Model
+    sos::Object model = (resource.model.name.sourceMap.empty() ? sos::Object() : WrapPayloadSourcemap(resource.model));
+    resourceObject.set(SerializeKey::Model, model);
+
+    // Parameters
+    resourceObject.set(SerializeKey::Parameters,
+                       WrapCollection<Parameter>()(resource.parameters.collection, WrapParameterSourcemap));
+
+    // Actions
+    resourceObject.set(SerializeKey::Actions,
+                       WrapCollection<Action>()(resource.actions.collection, WrapActionSourcemap));
+
+    // Content
+    sos::Array content;
+
+    resourceObject.set(SerializeKey::Content, content);
+
+    return resourceObject;
+}
+
+sos::Object WrapResourceGroupSourcemap(const SourceMap<Element>& resourceGroup)
+{
+    sos::Object resourceGroupObject;
+
+    // Name
+    resourceGroupObject.set(SerializeKey::Name, WrapSourcemap(resourceGroup.attributes.name));
+
+    // Description & Resources
+    SourceMap<Description> description;
+    sos::Array resources;
+
+    for (Collection<SourceMap<Element> >::const_iterator it = resourceGroup.content.elements().collection.begin();
+         it != resourceGroup.content.elements().collection.end();
+         ++it) {
+
+        if (it->element == Element::ResourceElement) {
+            resources.push(WrapResourceSourcemap(it->content.resource));
+        }
+        else if (it->element == Element::CopyElement) {
+            description.sourceMap.append(it->content.copy.sourceMap);
+        }
+    }
+
+    resourceGroupObject.set(SerializeKey::Description, WrapSourcemap(description));
+    resourceGroupObject.set(SerializeKey::Resources, resources);
+
+    return resourceGroupObject;
+}
+
+sos::Object WrapElementSourcemap(const SourceMap<Element>& element)
+{
+    sos::Object elementObject;
+
+    if (!element.attributes.name.sourceMap.empty()) {
+
+        sos::Object attributes;
+
+        attributes.set(SerializeKey::Name, WrapSourcemap(element.attributes.name));
+        elementObject.set(SerializeKey::Attributes, attributes);
+    }
+
+    switch (element.element) {
+        case Element::CopyElement:
+        {
+            elementObject.set(SerializeKey::Content, WrapSourcemap(element.content.copy));
+            break;
+        }
+
+        case Element::ResourceElement:
+        {
+            return WrapResourceSourcemap(element.content.resource);
+        }
+
+        case Element::CategoryElement:
+        {
+            elementObject.set(SerializeKey::Content,
+                              WrapCollection<Element>()(element.content.elements().collection, WrapElementSourcemap));
+            break;
+        }
+
+        default:
+            break;
+    }
+
+    return elementObject;
+}
+
+bool IsElementResourceGroup(const SourceMap<Element>& element)
+{
+    return element.element == Element::CategoryElement && element.category == Element::ResourceGroupCategory;
+}
+
+sos::Object drafter::WrapBlueprintSourcemap(const SourceMap<Blueprint>& blueprint, ConversionContext& context)
+{
+    sos::Object blueprintObject;
+
+    // Metadata
+    blueprintObject.set(SerializeKey::Metadata,
+                        WrapCollection<Metadata>()(blueprint.metadata.collection, WrapSourcemap));
+
+    // Name
+    blueprintObject.set(SerializeKey::Name, WrapSourcemap(blueprint.name));
+
+    // Description
+    blueprintObject.set(SerializeKey::Description, WrapSourcemap(blueprint.description));
+
+    // Resource Groups
+    blueprintObject.set(SerializeKey::ResourceGroups,
+                        WrapCollectionIf<Element>()(blueprint.content.elements().collection, WrapResourceGroupSourcemap, IsElementResourceGroup));
+
+    // Content
+    blueprintObject.set(SerializeKey::Content,
+                        WrapCollectionIf<Element>()(blueprint.content.elements().collection, WrapElementSourcemap, IsElementResourceGroup));
+
+    return blueprintObject;
+}

data/ext/drafter/src/SerializeSourcemap.h

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

data/ext/drafter/src/Version.h

@@ -0,0 +1,40 @@
+//
+//  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) 2015 Apiary Inc. All rights reserved.
+//
+
+#ifndef DRAFTER_VERSION_H
+#define DRAFTER_VERSION_H
+
+#define DRAFTER_MAJOR_VERSION 3
+#define DRAFTER_MINOR_VERSION 2
+#define DRAFTER_PATCH_VERSION 2
+
+#define DRAFTER_VERSION_IS_RELEASE 1
+#define DRAFTER_PRE_RELEASE_VERSION 0
+
+#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." \
+                                                                    DRAFTER_STRINGIFY(DRAFTER_PRE_RELEASE_VERSION)
+#endif
+
+#endif

data/ext/drafter/src/config.cc

@@ -0,0 +1,91 @@
+//
+//
+// 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 Type             = "type";
+    static const std::string Render           = "render";
+    static const std::string Sourcemap        = "sourcemap";
+    static const std::string Help             = "help";
+    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 Parse Result into file", false);
+    parser.add<std::string>(config::Format,    'f', "output format of the Parse Result (yaml|json)", false, "yaml", cmdline::oneof<std::string>("yaml", "json"));
+    parser.add<std::string>(config::Type,      't', "type of the Parse Result (refract|ast)", false, "refract", cmdline::oneof<std::string>("refract", "ast"));
+    parser.add(config::Sourcemap,              's', "export sourcemap in the Parse Result");
+    parser.add(config::Help,                   'h', "display this help message");
+    parser.add(config::Version ,               'v', "print Drafter version");
+    parser.add(config::Validate,               'l', "validate input only, do not output Parse Result");
+    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, const Config& config)
+{
+    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);
+    }
+
+    if (config.validate) {
+        if (parser.exist(config::Output)) {
+            std::cerr << "WARN: While validation is enabled, output file will not be created" << std::endl;
+        }
+    }
+
+}
+
+void ParseCommadLineOptions(int argc, const char *argv[], /* out */Config& conf)
+{
+    cmdline::parser parser;
+    PrepareCommanLineParser(parser);
+
+    parser.parse_check(argc, argv);
+
+    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) == "json" ? drafter::JSONFormat : drafter::YAMLFormat;
+    conf.astType          = parser.get<std::string>(config::Type) == "ast" ? drafter::NormalASTType : drafter::RefractASTType;
+    conf.output           = parser.get<std::string>(config::Output);
+    conf.sourceMap        = parser.exist(config::Sourcemap);
+
+    ValidateParsedCommandLine(parser, conf);
+}

data/ext/drafter/src/config.h

@@ -0,0 +1,38 @@
+//
+// 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>
+
+#include "Serialize.h"
+
+struct Config {
+    std::string input;
+    bool lineNumbers;
+    bool validate;
+    drafter::SerializeFormat format;
+    drafter::ASTType astType;
+    bool 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,137 @@
+//
+//  drafter.cc
+//  drafter
+//
+//  Created by Jiri Kratochvil on 2016-06-27
+//  Copyright (c) 2016 Apiary Inc. All rights reserved.
+//
+#include "drafter_private.h"
+
+#include "snowcrash.h"
+
+#include "SerializeResult.h" // FIXME: remove - actualy required by WrapParseResultRefract()
+#include "Serialize.h" // FIXME: remove - actualy required by WrapperOptions
+#include "ConversionContext.h" // FIXME: remove - required by ConversionContext
+#include "RefractDataStructure.h" // FIXME: remove - required by SerializeRefract()
+
+#include "sos.h" // FIXME: remove sos dependency
+#include "sosJSON.h"
+#include "sosYAML.h"
+
+#include "Version.h"
+
+#include <string.h>
+
+DRAFTER_API int drafter_parse_blueprint_to(const char* source,
+                                           char ** out,
+                                           const drafter_options options) {
+
+    if (!source || !out) {
+        return -1;
+    }
+
+    drafter_result* result = nullptr;
+    *out = nullptr;
+
+    int ret = drafter_parse_blueprint(source, &result);
+
+    if (!result) {
+        return -1;
+    }
+
+    *out = drafter_serialize(result, options);
+
+    drafter_free_result(result);
+
+    return ret;
+}
+
+namespace sc = snowcrash;
+
+/* Parse API Bleuprint and return result, which is a opaque handle for
+ * later use*/
+DRAFTER_API int drafter_parse_blueprint(const char* source, drafter_result** out) {
+
+    drafter_parse_options options = {false};
+
+    return drafter_parse_blueprint_with_options(source, out, options);
+}
+
+namespace { // FIXME: cut'n'paste from main.cc - duplicity
+
+    sos::Serialize* CreateSerializer(const drafter::SerializeFormat& format)
+    {
+        if (format == drafter::JSONFormat) {
+            return new sos::SerializeJSON;
+        }
+
+        return new sos::SerializeYAML;
+    }
+
+    /**
+     * \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;
+    }
+
+}
+
+/* Serialize result to given format*/
+DRAFTER_API char* drafter_serialize(drafter_result *res, const drafter_options options) {
+
+    if (!res) {
+        return nullptr;
+    }
+
+    drafter::WrapperOptions woptions(drafter::RefractASTType, options.sourcemap);
+    drafter::ConversionContext context(woptions);
+
+    sos::Object result = drafter::SerializeRefract(res, context);
+
+    std::unique_ptr<sos::Serialize> serializer(CreateSerializer(options.format == DRAFTER_SERIALIZE_JSON ? drafter::JSONFormat : drafter::YAMLFormat));
+
+    std::ostringstream out;
+
+    Serialization(&out, result, serializer.get());
+
+    return strdup(out.str().c_str());
+}
+
+/* Parse API Blueprint and return only annotations, if NULL than
+ * document is error and warning free.*/
+DRAFTER_API drafter_result* drafter_check_blueprint(const char* source) {
+
+    drafter_parse_options options = {false};
+
+    return drafter_check_blueprint_with_options(source, options);
+}
+
+DRAFTER_API void drafter_free_result(drafter_result* result) {
+    delete result;
+}
+
+#define VERSION_SHIFT_STEP 8
+
+DRAFTER_API unsigned int drafter_version(void) {
+    unsigned int version = 0;
+
+    version |= DRAFTER_MAJOR_VERSION;
+    version <<= VERSION_SHIFT_STEP;
+    version |= DRAFTER_MINOR_VERSION;
+    version <<= VERSION_SHIFT_STEP;
+    version |= DRAFTER_PATCH_VERSION;
+
+    return version;
+}
+
+#undef VERSION_SHIFT_STEP
+
+DRAFTER_API const char* drafter_version_string(void) {
+    return DRAFTER_VERSION_STRING;
+}