lounge_lizard 0.1.0

data/ext/drafter/src/drafter.h

@@ -0,0 +1,102 @@
+//
+//  drafter.h
+//  drafter
+//
+//  Created by Jiri Kratochvil on 2016-06-27
+//  Copyright (c) 2016 Apiary Inc. All rights reserved.
+//
+
+#ifndef DRAFTER_H
+#define DRAFTER_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+//#if defined(BUILDING_DRAFTER)
+#if defined(BUILDING_SNOWCRASH)
+#   define DEPRECATED
+#endif
+
+#if defined(_MSC_VER)
+#   if !defined(DEPRECATED)
+#       define DEPRECATED __declspec(deprecated)
+#   endif
+#elif defined(__clang__) || defined(__GNUC__)
+#   if !defined(DEPRECATED)
+#       define DEPRECATED __attribute__((deprecated))
+#   endif
+#else
+#   if !defined(DEPRECATED)
+#       define DEPRECATED
+#   endif
+#endif
+
+#ifndef DRAFTER_API
+#  if defined _WIN32 || defined __CYGWIN__
+#     if defined(DRAFTER_BUILD_SHARED) /* build dll */
+#         define DRAFTER_API __declspec(dllexport)
+#     elif !defined(DRAFTER_BUILD_STATIC) /* use dll */
+#         define DRAFTER_API __declspec(dllimport)
+#     else /* static library */
+#         define DRAFTER_API /* nothing */
+#     endif
+#  else
+#     if __GNUC__ >= 4
+#         define DRAFTER_API __attribute__((visibility("default")))
+#     else
+#         define DRAFTER_API
+#     endif
+#  endif
+#endif
+
+
+#ifndef __cplusplus
+#include <stdbool.h>
+typedef struct drafter_result drafter_result;
+#else
+namespace refract {
+    struct IElement;
+}
+typedef refract::IElement drafter_result;
+#endif
+
+
+typedef enum {
+    DRAFTER_SERIALIZE_YAML = 0,
+    DRAFTER_SERIALIZE_JSON
+} drafter_format;
+
+typedef struct {
+    bool sourcemap;
+    drafter_format format;
+} drafter_options;
+
+/* Parse API Blueprint and serialize it to given format.*/
+DRAFTER_API int drafter_parse_blueprint_to(const char* source,
+                                           char** out,
+                                           const drafter_options options);
+
+/* Parse API Blueprint and return result, which is a opaque handle for
+ * later use*/
+DRAFTER_API int drafter_parse_blueprint(const char* source, drafter_result** out);
+
+/* Serialize result to given format*/
+DRAFTER_API char* drafter_serialize(drafter_result *res, const drafter_options options);
+
+/* Free memory alocated for result handler */
+DRAFTER_API void drafter_free_result(drafter_result* result);
+
+/* 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_API unsigned int drafter_version(void);
+
+DRAFTER_API const char* drafter_version_string(void);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // #ifndef DRAFTER_H

data/ext/drafter/src/drafter_private.cc

@@ -0,0 +1,85 @@
+//
+//  drafter_private.cc
+//  drafter
+//
+//  Created by Pavan Kumar Sunkara on 20/10/16.
+//  Copyright © 2016 Apiary. All rights reserved.
+//
+
+#include "drafter_private.h"
+
+#include "snowcrash.h"
+
+#include "refract/Element.h"
+#include "refract/FilterVisitor.h"
+#include "refract/Query.h"
+#include "refract/Iterate.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
+
+namespace sc = snowcrash;
+
+DRAFTER_API int drafter_parse_blueprint_with_options(const char* source,
+                                                     drafter_result** out,
+                                                     const drafter_parse_options options) {
+
+    if (!source || !out) {
+        return -1;
+    }
+
+    sc::BlueprintParserOptions scOptions = sc::ExportSourcemapOption;
+
+    if (options.requireBlueprintName) {
+        scOptions |= sc::RequireBlueprintNameOption;
+    }
+
+    sc::ParseResult<sc::Blueprint> blueprint;
+    sc::parse(source, scOptions, blueprint);
+
+    drafter::WrapperOptions wrapperOptions(drafter::RefractASTType);
+    drafter::ConversionContext context(wrapperOptions);
+    refract::IElement* result = WrapParseResultRefract(blueprint, context);
+
+    *out = result;
+
+    return blueprint.report.error.code;
+}
+
+DRAFTER_API drafter_result* drafter_check_blueprint_with_options(const char* source,
+                                                                 const drafter_parse_options options) {
+
+    if (!source) {
+        return nullptr;
+    }
+
+    drafter_result* result = nullptr;
+
+    drafter_parse_blueprint_with_options(source, &result, options);
+
+    if (!result) {
+        return nullptr;
+    }
+
+    drafter_result* out = nullptr;
+
+    refract::FilterVisitor filter(refract::query::Element("annotation"));
+    refract::Iterate<refract::Children> iterate(filter);
+    iterate(*result);
+
+    if (!filter.empty()) {
+        refract::ArrayElement::ValueType elements;
+
+        std::transform(filter.elements().begin(), filter.elements().end(),
+                       std::back_inserter(elements),
+                       std::bind(&refract::IElement::clone, std::placeholders::_1, refract::IElement::cAll));
+
+        out = new refract::ArrayElement(elements);
+        out->element(drafter::SerializeKey::ParseResult);
+    }
+
+    drafter_free_result(result);
+
+    return out;
+}

data/ext/drafter/src/drafter_private.h

@@ -0,0 +1,34 @@
+//
+//  drafter_private.h
+//  drafter
+//
+//  Created by Pavan Kumar Sunkara on 20/10/16.
+//  Copyright © 2016 Apiary. All rights reserved.
+//
+
+//TODO: This should be merged with drafter.h in next major release
+#ifndef DRAFTER_PRIVATE_H
+#define DRAFTER_PRIVATE_H
+
+#include "drafter.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct {
+    bool requireBlueprintName;
+} drafter_parse_options;
+
+DRAFTER_API int drafter_parse_blueprint_with_options(const char* source,
+                                                     drafter_result** out,
+                                                     const drafter_parse_options options);
+
+DRAFTER_API drafter_result* drafter_check_blueprint_with_options(const char* source,
+                                                                 const drafter_parse_options options);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // #ifndef DRAFTER_PRIVATE_H

data/ext/drafter/src/main.cc

@@ -0,0 +1,137 @@
+// 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 "drafter.h"
+
+#include "snowcrash.h"
+#include "SectionParserData.h"  // snowcrash::BlueprintParserOptions
+
+#include "sos.h"
+#include "sosJSON.h"
+#include "sosYAML.h"
+
+#include "SerializeResult.h"
+
+#include "reporting.h"
+#include "config.h"
+#include "stream.h"
+
+#include "ConversionContext.h"
+
+namespace sc = snowcrash;
+
+/**
+ *  \brief  return instance sos::Serializer based on \param `format`
+ *
+ *  \param format - output format for serialization
+ */
+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;
+}
+
+int ProcessAST(const Config& config, std::unique_ptr<std::istream>& in, std::unique_ptr<std::ostream>& out)
+{
+    std::stringstream inputStream;
+    inputStream << in->rdbuf();
+
+    sc::ParseResult<sc::Blueprint> blueprint;
+    sc::parse(inputStream.str(), snowcrash::ExportSourcemapOption, blueprint);
+
+    std::unique_ptr<sos::Serialize> serializer(CreateSerializer(config.format));
+
+    try {
+        sos::Object resultObject = drafter::WrapResult(blueprint, drafter::WrapperOptions(config.astType, config.sourceMap));
+
+        if (!config.validate) { // If not validate, we serialize
+            Serialization(out.get(), resultObject, serializer.get());
+        }
+    }
+    catch (snowcrash::Error& e) {
+        blueprint.report.error = e;
+    }
+    catch (std::exception& e) {
+        blueprint.report.error = snowcrash::Error(e.what(), snowcrash::ApplicationError);
+    }
+
+    PrintReport(blueprint.report, inputStream.str(), config.lineNumbers);
+
+    return blueprint.report.error.code;
+}
+
+int ProcessRefract(const Config& config, std::unique_ptr<std::istream>& in, std::unique_ptr<std::ostream>& out)
+{
+    std::stringstream inputStream;
+    inputStream << in->rdbuf();
+
+    drafter_options options;
+    options.sourcemap = config.sourceMap;
+    options.format = config.format == drafter::YAMLFormat
+       ? DRAFTER_SERIALIZE_YAML
+       : DRAFTER_SERIALIZE_JSON;
+
+    refract::IElement* result = nullptr;
+
+    int ret = drafter_parse_blueprint(inputStream.str().c_str(), &result);
+
+    if (!result) {
+        return -1;
+    }
+
+    if (!config.validate) { // If not validate, we serialize
+        char* output = drafter_serialize(result, options);
+
+        if (output) {
+            *out << output
+                 << "\n"
+                 << std::flush;
+
+            free(output);
+        }
+    }
+
+    PrintReport(result, inputStream.str(), config.lineNumbers, ret);
+
+    drafter_free_result(result);
+
+    return ret;
+}
+
+int main(int argc, const char *argv[])
+{
+    Config config;
+    ParseCommadLineOptions(argc, argv, config);
+
+    std::unique_ptr<std::istream> in(CreateStreamFromName<std::istream>(config.input));
+    std::unique_ptr<std::ostream> out(CreateStreamFromName<std::ostream>(config.output));
+
+    if (config.astType == drafter::RefractASTType) {
+        return ProcessRefract(config, in, out);
+    }
+    else if (config.astType == drafter::NormalASTType) {
+        return ProcessAST(config, in, out);
+    }
+
+
+}

data/ext/drafter/src/refract/AppendDecorator.h

@@ -0,0 +1,58 @@
+//
+//  refract/AppendDecorator.h
+//  librefract
+//
+//  Created by Jiri Kratochvil on 17/06/15.
+//  Copyright (c) 2015 Apiary Inc. All rights reserved.
+//
+#ifndef REFRACT_APPENDDECORATOR_H
+#define REFRACT_APPENDDECORATOR_H
+
+#include <iterator>
+
+namespace refract
+{
+
+    // Forward declarations of Elements
+    struct IElement;
+
+    template <typename T, typename V = typename T::ValueType>
+    struct AppendDecorator {
+        typedef T ElementType;
+        typedef V ValueType;
+        ElementType*& element;
+        AppendDecorator(ElementType*& e) : element(e)
+        {
+        }
+
+        void operator()(const V& value)
+        {
+            // FIXME: snowcrash warn about "Primitive type can not have member"
+            // but in real it create "empty" member
+            //
+            // solution for now: set if element has no already value, otherwise silently ignore
+            if (element->empty()) {
+                element->set(value);
+            }
+        }
+    };
+
+    template <typename T>
+    struct AppendDecorator<T, std::vector<refract::IElement*> > {
+        typedef T ElementType;
+        typedef typename T::ValueType ValueType;
+        ElementType*& element;
+
+        AppendDecorator(ElementType*& e) : element(e)
+        {
+        }
+
+        void operator()(const ValueType& value)
+        {
+            std::transform(value.begin(), value.end(), std::back_inserter(element));
+        }
+    };
+
+}; // namespace refract
+
+#endif // #ifndef REFRACT_APPENDDECORATOR_H

data/ext/drafter/src/refract/Build.h

@@ -0,0 +1,67 @@
+
+//
+//  refract/Build.h
+//  librefract
+//
+//  Created by Jiri Kratochvil on 03/01/16.
+//  Copyright (c) 2016 Apiary Inc. All rights reserved.
+//
+#ifndef REFRACT_BUILD_H
+#define REFRACT_BUILD_H
+
+namespace refract
+{
+    /**
+     * Simple concept based on operator() override. It 
+     * allows tricky creating of complex refract structures
+     * eg:
+     * ```
+        return Build(new ObjectElement)
+           ("m1", IElement::Create("Value"))
+           ("m2", Build(new ArrayElement)
+                     (IElement::Create("m2[0]"))
+           )
+           ("m3", Build(new ObjectElement)
+                     ("m3.1", IElement::Create("Str3.1"))
+                     ("m3.2", IElement::Create(3.2))
+                     ("m3.3", Build(new ObjectElement)
+                                 ("m3.3.1", IElement::Create("Str3/4/1"))
+                                 ("m3.3.2", IElement::Create(3.42))
+                                 ("m3.3.2", new NullElement)
+                     )
+           );
+     * ```
+     */
+    template <typename T>
+    struct ElementBuilder {
+        T* element;
+
+        ElementBuilder(T* element) : element(element) {}
+
+        operator T*() {
+            return element;
+        }
+
+        ElementBuilder<T>& operator()(IElement* member) {
+            element->push_back(member);
+            return *this;
+        }
+
+        ElementBuilder<T>& operator()(IElement* key, IElement* value) {
+            element->push_back(new MemberElement(key, value));
+            return *this;
+        }
+
+        ElementBuilder<T>& operator()(const std::string& key, IElement* value) {
+            element->push_back(new MemberElement(key, value));
+            return *this;
+        }
+    };
+
+    template <typename E>
+    ElementBuilder<E> Build(E* e) {
+        return ElementBuilder<E>(e);
+    }
+}; // namespace refract
+
+#endif // #ifndef REFRACT_BUILD_H

data/ext/drafter/src/refract/ComparableVisitor.cc

@@ -0,0 +1,43 @@
+//
+//  refract/ComparableVisitor.cc
+//  librefract
+//
+//  Created by Jiri Kratochvil on 21/05/15.
+//  Copyright (c) 2015 Apiary Inc. All rights reserved.
+//
+#include "Element.h"
+#include "ComparableVisitor.h"
+
+namespace refract
+{
+
+    ComparableVisitor::ComparableVisitor(const std::string& str, const int compare) : compare_to(str), result(false), compare(compare)
+    {
+    }
+
+    void ComparableVisitor::operator()(const MemberElement& e)
+    {
+        ComparableVisitor v(compare_to);
+        Visitor visitor(v);
+
+        if (compare == key && e.value.first) {
+            e.value.first->content(visitor);
+        }
+        else if (e.value.second) {
+            e.value.second->content(visitor);
+        }
+
+        result = v.get();
+    }
+
+    void ComparableVisitor::operator()(const IElement& e)
+    {
+        throw LogicError("Fallback impl - behavioration for Base class IElement is not defined");
+    }
+
+    bool ComparableVisitor::get() const
+    {
+        return result;
+    }
+
+}; // namespace refract

data/ext/drafter/src/refract/ComparableVisitor.h

@@ -0,0 +1,62 @@
+//
+//  refract/ComparableVisitor.h
+//  librefract
+//
+//  Created by Jiri Kratochvil on 21/05/15.
+//  Copyright (c) 2015 Apiary Inc. All rights reserved.
+//
+#ifndef REFRACT_COMPARABLEVISITOR_H
+#define REFRACT_COMPARABLEVISITOR_H
+
+namespace refract
+{
+
+    // Forward declarations of Elements
+    struct IElement;
+    struct MemberElement;
+
+    class ComparableVisitor 
+    {
+        std::string compare_to;
+        bool result;
+        int compare;
+
+        template <typename T, typename U>
+        bool IsEqual(const T& first, const U& second)
+        {
+            return false;
+        }
+
+        template <typename T>
+        bool IsEqual(const T& first, const T& second)
+        {
+            return first == second;
+        }
+
+    public:
+
+        enum {
+            key,
+            value
+        };
+
+        ComparableVisitor(const std::string& str, const int compare = value);
+
+        template <typename E>
+        void operator()(const E& e)
+        {
+           if (compare == value) {
+               result = IsEqual(compare_to, e.value);
+           }
+        }
+
+        void operator()(const MemberElement& e);
+        void operator()(const IElement& e);
+
+        bool get() const;
+    };
+
+
+}; // namespace refract
+
+#endif // #ifndef REFRACT_COMPARABLEVISITOR_H