lounge_lizard 0.1.0

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

@@ -0,0 +1,231 @@
+//
+//  refract/VisitorUtils.h
+//  librefract
+//
+//  Created by Vilibald Wanča on 09/11/15.
+//  Copyright (c) 2015 Apiary Inc. All rights reserved.
+//
+#ifndef REFRACT_VISITORUTILS_H
+#define REFRACT_VISITORUTILS_H
+
+#include "Element.h"
+#include "Visitor.h"
+
+#include "TypeQueryVisitor.h"
+#include "ComparableVisitor.h"
+
+// this will be removed, refract should not contain reference to other libraries
+#include "SourceAnnotation.h"
+
+namespace refract
+{
+    template<typename T>
+    bool IsTypeAttribute(const T& e, std::string typeAttribute) {
+        IElement::MemberElementCollection::const_iterator ta = e.attributes.find("typeAttributes");
+
+        if (ta == e.attributes.end()) {
+            return false;
+        }
+
+        ArrayElement* attrs = TypeQueryVisitor::as<ArrayElement>((*ta)->value.second);
+
+        if (!attrs) {
+            return false;
+        }
+
+        for (ArrayElement::ValueType::const_iterator it = attrs->value.begin() ; it != attrs->value.end() ; ++it ) {
+            StringElement* attr = TypeQueryVisitor::as<StringElement>(*it);
+            if (!attr) {
+                continue;
+            }
+            if (attr->value == typeAttribute) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    template<typename T>
+    bool IsVariableProperty(const T& e) {
+        IElement::MemberElementCollection::const_iterator i = e.attributes.find("variable");
+
+        if (i == e.attributes.end()) {
+            return false;
+        }
+
+        BooleanElement* b =  TypeQueryVisitor::as<BooleanElement>((*i)->value.second);
+        return b ? b->value : false;
+    }
+
+
+    template<typename T>
+    const T* GetDefault(const T& e) {
+        IElement::MemberElementCollection::const_iterator i = e.attributes.find("default");
+
+        if (i == e.attributes.end()) {
+            return NULL;
+        }
+
+        return TypeQueryVisitor::as<T>((*i)->value.second);
+    }
+
+    template<typename T>
+    const T* GetSample(const T& e) {
+        IElement::MemberElementCollection::const_iterator i = e.attributes.find("samples");
+
+        if (i == e.attributes.end()) {
+            return NULL;
+        }
+
+        ArrayElement* a = TypeQueryVisitor::as<ArrayElement>((*i)->value.second);
+
+        if (!a || a->value.empty()) {
+            return NULL;
+        }
+
+        return TypeQueryVisitor::as<T>(*(a->value.begin()));
+    }
+
+    template<typename T, typename R = typename T::ValueType>
+    struct GetValue {
+        const T& element;
+
+        GetValue(const T& e) : element(e) {}
+
+        operator const R*() {
+            // FIXME: if value is propageted as first
+            // following example will be rendered w/ empty members
+            // ```
+            // - o
+            //     - m1
+            //     - m2
+            //         - sample
+            //             - m1: a
+            //             - m2: b
+            // ```
+            // because `o` has members `m1` and  `m2` , but members has no sed value
+            if (!element.empty()) {
+                return &element.value;
+            }
+
+            if (const T* s = GetSample(element)) {
+                return &s->value;
+            }
+
+            if (const T* d = GetDefault(element)) {
+                return &d->value;
+            }
+
+            if (element.empty() && IsTypeAttribute(element, "nullable")) {
+                return NULL;
+            }
+
+            return &element.value;
+        }
+    };
+
+    struct GetEnumValue {
+        const EnumElement& element;
+
+        GetEnumValue(const EnumElement& e) : element(e) {}
+
+        operator const EnumElement::ValueType*() {
+            if (const EnumElement* s = GetSample(element)) {
+                return &s->value;
+            }
+
+            if (const EnumElement* d = GetDefault(element)) {
+                return &d->value;
+            }
+
+            if (!element.empty()) {
+                return &element.value;
+            }
+
+            if (element.empty() && IsTypeAttribute(element, "nullable")) {
+                return NULL;
+            }
+
+            return &element.value;
+        }
+    };
+
+    // will be moved into different header (as part of drafter instead of refract)
+    template <typename T>
+    void CheckMixinParent(refract::IElement* element)
+    {
+        const T* resolved = TypeQueryVisitor::as<T>(element);
+
+        if (!resolved) {
+            throw snowcrash::Error("mixin base type should be the same as parent base type. objects should contain object mixins. arrays should contain array mixins", snowcrash::MSONError);
+        }
+    }
+
+    // will be moved into different header (as part of drafter instead of refract)
+    template<typename T, typename Functor>
+    void HandleRefWhenFetchingMembers(const refract::IElement* e, typename T::ValueType& members, const Functor& functor)
+    {
+        IElement::MemberElementCollection::const_iterator found = e->attributes.find("resolved");
+
+        if (found == e->attributes.end()) {
+            return;
+        }
+
+        const ExtendElement* extended = TypeQueryVisitor::as<ExtendElement>((*found)->value.second);
+
+        if (!extended) {
+            CheckMixinParent<T>((*found)->value.second);
+            // We can safely cast it because we are already checking the type in the above line.
+            functor(static_cast<const T&>(*(*found)->value.second), members);
+            return;
+        }
+
+        for (RefractElements::const_iterator it = extended->value.begin();
+             it != extended->value.end();
+             ++it) {
+
+            CheckMixinParent<T>(*it);
+            // We can safely cast it because we are already checking the type in the above line.
+            functor(static_cast<const T&>(**it), members);
+        }
+    }
+
+    template <typename T>
+    MemberElement* FindMemberByKey(const T& e,
+                                   const std::string& name)
+    {
+        for (typename T::ValueType::const_iterator it = e.value.begin()
+                 ; it != e.value.end()
+                 ; ++it ) {
+
+            ComparableVisitor cmp(name, ComparableVisitor::key);
+            VisitBy(*(*it), cmp);
+
+            if (cmp.get()) { // key was recognized - it is save to cast to MemberElement
+                return static_cast<MemberElement*>(*it);
+            }
+        }
+
+        return NULL;
+    }
+
+    template <typename T>
+    T* FindCollectionMemberValue(const IElement::MemberElementCollection& collection, const std::string& key) {
+        IElement::MemberElementCollection::const_iterator i = collection.find(key);
+        if (i == collection.end()) {
+            return NULL;
+        }
+
+        return TypeQueryVisitor::as<T>((*i)->value.second);
+    }
+
+    std::string GetKeyAsString(const MemberElement& e);
+
+    StringElement* GetDescription(const IElement& e);
+
+    void SetRenderFlag(RefractElements& elements, const IElement::renderFlags flag);
+
+}
+
+#endif /* REFRACT_VISITORUTILS_H */

data/ext/drafter/src/reporting.cc

@@ -0,0 +1,263 @@
+//
+//  reporting.cc
+//  drafter
+//
+//  Created by Jiri Kratochvil on 2015-02-13
+//  Copyright (c) 2015 Apiary Inc. All rights reserved.
+//
+
+#include "reporting.h"
+
+#include <algorithm>
+#include <iostream>
+
+#include "refract/Element.h"
+#include "refract/FilterVisitor.h"
+#include "refract/Query.h"
+#include "refract/Iterate.h"
+#include "refract/TypeQueryVisitor.h"
+
+#include "refract/VisitorUtils.h"
+
+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);
+        }
+    }
+}
+
+void PrintAnnotation(const std::string& prefix,
+                     const snowcrash::SourceAnnotation& annotation,
+                     const std::string& source,
+                     const bool useLineNumbers)
+{
+
+    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 (useLineNumbers) {
+        GetLinesEndIndex(source, linesEndIndex);
+    }
+
+    if (!annotation.location.empty()) {
+
+        for (mdp::CharactersRangeSet::const_iterator it = annotation.location.begin();
+             it != annotation.location.end();
+             ++it) {
+
+            if (useLineNumbers) {
+
+                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);
+    }
+}
+
+struct AnnotationToString {
+
+    std::vector<size_t> linesEndIndex;
+    const bool useLineNumbers;
+
+    AnnotationToString(const std::string& source, const bool useLineNumbers) : useLineNumbers(useLineNumbers) {
+        if (useLineNumbers) {
+            GetLinesEndIndex(source, linesEndIndex);
+        }
+    }
+
+    const std::string location(const refract::IElement* sourceMap) {
+        std::stringstream output;
+        const refract::ArrayElement* map = refract::TypeQueryVisitor::as<refract::ArrayElement>(sourceMap);
+        if (map && map->value.size() == 2) {
+            refract::NumberElement* loc = refract::TypeQueryVisitor::as<refract::NumberElement>(map->value[0]);
+            refract::NumberElement* len = refract::TypeQueryVisitor::as<refract::NumberElement>(map->value[1]);
+            if (loc && len) {
+                if (useLineNumbers) {
+
+                    AnnotationPosition annotationPosition;
+                    mdp::Range pos(loc->value, len->value);
+                    GetLineFromMap(linesEndIndex, pos, annotationPosition);
+
+                    output << "; line " << annotationPosition.fromLine << ", column " << annotationPosition.fromColumn;
+                    output << " - line " << annotationPosition.toLine << ", column " << annotationPosition.toColumn;
+                }
+                else {
+                    output << loc->value << ":" << len->value;
+                }
+            }
+        }
+        return output.str();
+    }
+
+    const std::string operator()(const refract::IElement* annotation) {
+        std::stringstream output;
+
+        if (!annotation || annotation->element() != "annotation") {
+            return output.str();
+        }
+
+        if (const refract::ArrayElement* classes = refract::FindCollectionMemberValue<refract::ArrayElement>(annotation->meta, "classes")) {
+            if (classes->value.size() == 1) {
+                refract::StringElement* type = refract::TypeQueryVisitor::as<refract::StringElement>(classes->value.front());
+                if (type) {
+                    output << type->value << ": ";
+                }
+            }
+        };
+
+        if (const refract::NumberElement* code = refract::FindCollectionMemberValue<refract::NumberElement>(annotation->attributes, "code")) {
+            output << "(" <<code->value << ")  ";
+        }
+
+        if (const refract::StringElement* message = refract::TypeQueryVisitor::as<refract::StringElement>(annotation)) {
+            output << message->value;
+        }
+
+        if (refract::ArrayElement* sourceMap = refract::FindCollectionMemberValue<refract::ArrayElement>(annotation->attributes, "sourceMap")) {
+            if (sourceMap->value.size() == 1) {
+                sourceMap = refract::TypeQueryVisitor::as<refract::ArrayElement>(sourceMap->value.front());
+                if (sourceMap) {
+                    for (refract::IElement* array : sourceMap->value) {
+                        if (!useLineNumbers) {
+                            const char* prefix = array == (*sourceMap->value.begin()) ? " :" :";";
+                            output << prefix;
+                        }
+                        output << location(array);
+                    }
+                }
+            }
+        };
+
+        return output.str();
+    }
+};
+
+void PrintReport(const drafter_result* result,
+                 const std::string& source,
+                 const bool useLineNumbers,
+                 const int error)
+{
+    std::cerr << std::endl;
+
+    refract::FilterVisitor filter(refract::query::Element("annotation"));
+    refract::Iterate<refract::Children> iterate(filter);
+    iterate(*result);
+
+    refract::RefractElements elements;
+
+    if (error == sc::Error::OK) {
+        std::cerr << "OK.\n";
+    }
+
+    std::transform(filter.elements().begin(), filter.elements().end(),
+              std::ostream_iterator<std::string>(std::cerr, "\n"),
+              AnnotationToString(source, useLineNumbers));
+
+}

data/ext/drafter/src/reporting.h

@@ -0,0 +1,39 @@
+//
+//  reporting.h
+//  drafter
+//
+//  Created by Jiri Kratochvil on 2015-02-13
+//  Copyright (c) 2015 Apiary Inc. All rights reserved.
+//
+
+#ifndef DRAFTER_REPORTING_H
+#define DRAFTER_REPORTING_H
+
+#include "drafter.h"
+#include "SourceAnnotation.h"
+
+/**
+ *  \brief Print parser report to stderr.
+ *
+ *  \param report A parser report to print
+ *  \param source Source data
+ *  \param useLineNumbers 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 useLineNumbers);
+
+/**
+ *  \brief Print parser report to stderr.
+ *
+ *  \param report A parser report to print
+ *  \param source Source data
+ *  \param useLineNumbers True if the annotations needs to be printed by line and column number
+ *  \param error - code form parsing
+ */
+void PrintReport(const drafter_result*,
+                 const std::string& source,
+                 const bool useLineNumbers,
+                 const int error);
+
+#endif // #ifndef DRAFTER_REPORTING_H

data/ext/drafter/src/stream.h

@@ -0,0 +1,148 @@
+//
+//  stream.h
+//  drafter
+//
+//  Created by Jiri Kratochvil on 2015-03-03
+//  Copyright (c) 2015 Apiary Inc. All rights reserved.
+//
+
+#ifndef DRAFTER_STREAM_H
+#define DRAFTER_STREAM_H
+
+#include <memory>
+
+#include <string>
+
+#include <iostream>
+#include <sstream>
+#include <fstream>
+
+/**
+ *  \brief proxy redirect i/o operations to stdin/stdout
+ *  and avoid close stdin/stdout while delete
+ */
+template <typename T> struct std_io_proxy;
+
+template <> struct std_io_proxy<std::ostream> : public std::ostream {
+    //std::streambuf dummy;
+    std::stringbuf dummy;
+
+    std_io_proxy() : std::ostream(std::cout.rdbuf())
+    {
+        //rdbuf(std::cout.rdbuf());
+    }
+
+    virtual ~std_io_proxy()
+    {
+        rdbuf(&dummy);
+    }
+};
+
+template <> struct std_io_proxy<std::istream> : public std::istream {
+    //std::streambuf dummy;
+    std::stringbuf dummy;
+
+    std_io_proxy() : std::istream(std::cin.rdbuf())
+    {
+        //saved = rdbuf(std::cin.rdbuf());
+    }
+
+    virtual ~std_io_proxy()
+    {
+        rdbuf(&dummy);
+    }
+};
+
+/**
+ *  \brief functor returns cin/cout ptr in based on istream or ostream
+ */
+template<typename T> struct std_io {
+    T* operator()() const
+    {
+        return new std_io_proxy<T>();
+    }
+};
+
+/**
+ *  \brief functor returns appropriate cin/cout based on istream/ostream
+ */
+template<typename T> struct std_io_selector {
+    typedef T stream_type;
+    typedef stream_type* return_type;
+
+    return_type operator()() const
+    {
+        return return_type(std_io<T>()());
+    }
+};
+
+/**
+ *  \brief functor select fstream based on iostream
+ */
+template <typename T> struct to_fstream;
+
+template<>
+struct to_fstream<std::istream>{
+  typedef std::ifstream stream_type;
+  static std::ios_base::openmode open_flags() { return std::ios_base::in | std::ios_base::binary; }
+};
+
+template<>
+struct to_fstream<std::ostream>{
+  typedef std::ofstream stream_type;
+  static std::ios_base::openmode open_flags() { return std::ios_base::out | std::ios_base::binary; }
+};
+
+/**
+ *  \brief functor select return appropriate opened fstream based on type of stream
+ */
+template<typename T> struct fstream_io_selector{
+    typedef typename to_fstream<T>::stream_type stream_type;
+    typedef stream_type* return_type;
+
+    return_type operator()(const char* name) const
+    {
+        return return_type(new stream_type(name, to_fstream<T>::open_flags()));
+    }
+};
+
+/**
+ *  \brief return pointer to readable/writable stream or report error and exit()
+ *
+ *  free allocated memory must be released by calling `delete`
+ *  optionaly you can use std::unique_ptr<>
+ *
+ *  return is based on \template param T (must be std::ostream or std::istream)
+ *
+ *  For std::istream it return opened std::ifstream with filename as in \param `file`
+ *  if \param `file` is empty it will return std::cin
+ *
+ *  In similar way it work for std::ostream
+ *
+ *  \param template<T> type of returned stream
+ *  \param file - name of file to open for read/write if empty use standart input/output
+ *
+ */
+
+template<typename T>
+T* CreateStreamFromName(const std::string& file)
+{
+    if (file.empty()) {
+        return std_io_selector<T>()();
+    }
+
+    typedef typename fstream_io_selector<T>::return_type return_type;
+
+    return_type stream = fstream_io_selector<T>()(file.c_str());
+
+    if (!stream->is_open()) {
+      std::cerr << "fatal: unable to open file '" << file << "'\n";
+      delete stream;
+      exit(EXIT_FAILURE);
+    }
+
+    return stream;
+}
+
+
+#endif // #ifndef DRAFTER_STREAM_H

data/ext/drafter/tools/homebrew/drafter.rb

@@ -0,0 +1,18 @@
+require 'formula'
+
+class Drafter < Formula
+  homepage 'http://apiblueprint.org'
+  head 'https://github.com/apiaryio/drafter.git', :tag => 'v3.2.2'
+
+  def install
+    system "./configure", "--shared"
+    system "make", "drafter"
+    bin.install Dir["bin/drafter"]
+    (include + "drafter").install Dir["src/drafter.h"]
+    lib.install Dir["build/out/Release/libdrafter.dylib"]
+  end
+
+  test do
+    system bin/"drafter", "--help"
+  end
+end