redsnow 0.3.7 → 0.4.0

data/ext/drafter/ext/snowcrash/src/HeadersParser.cc

@@ -0,0 +1,110 @@
+#include "HeadersParser.h"
+
+using namespace snowcrash;
+
+/** Finds a header in its containment group by its key (first) */
+static HeaderIterator findHeader(const Headers& headers,
+                                 const Header& header) {
+
+    return std::find_if(headers.begin(),
+        headers.end(),
+        std::bind2nd(MatchFirsts<Header, IEqual<Header::first_type> >(), header));
+}
+
+typedef std::vector<std::string> HeadersKeyCollection;
+
+/** Get collection of allowed keywords - workarround due to C++98 restriction - static initialization of vector */
+static const HeadersKeyCollection& getAllowedMultipleDefinitions() {
+
+    static std::string keys[] = {
+        HTTPHeaderName::SetCookie,
+        HTTPHeaderName::Link,
+    };
+
+    static const HeadersKeyCollection allowedMultipleDefinitions(keys, keys + (sizeof(keys)/sizeof(keys[0])));
+
+    return allowedMultipleDefinitions;
+}
+
+/** Check if Header name has allowed multiple definitions */
+static bool isAllowedMultipleDefinition(const Header& header) {
+
+    const HeadersKeyCollection& keys = getAllowedMultipleDefinitions();
+
+    return std::find_if(keys.begin(),
+        keys.end(),
+        std::bind1st(MatchFirstWith<Header, std::string, IEqual<std::string> >(), header)) != keys.end();
+}
+
+static bool isNotValidTokenChar(const std::string::value_type& c) {
+    static const std::string validChars("-#$%&'*+.^_`|~");
+
+    return !(std::isalnum(c) || (validChars.find(c) != std::string::npos));
+}
+
+static std::string::const_iterator findNonValidCharInHeaderName(const std::string& token) {
+
+    return std::find_if(token.begin(), token.end(), isNotValidTokenChar);
+}
+
+bool HeaderNameTokenChecker::operator()() const {
+
+  return findNonValidCharInHeaderName(headerName) == headerName.end();
+}
+
+std::string HeaderNameTokenChecker::getMessage() const {
+
+    std::stringstream ss;
+    ss << "HTTP header field name contain illegal character '"
+        << *findNonValidCharInHeaderName(headerName)
+        << "'";
+
+    return ss.str();
+}
+
+bool ColonPresentedChecker::operator()() const {
+
+    return captures[3].size() >= 1 && (captures[3].find(':') != std::string::npos);
+}
+
+std::string ColonPresentedChecker::getMessage() const {
+
+    return "missing colon after header name";
+}
+
+bool HeadersDuplicateChecker::operator()() const {
+
+    return findHeader(headers, header) == headers.end() ||
+        isAllowedMultipleDefinition(header);
+}
+
+std::string HeadersDuplicateChecker::getMessage() const {
+
+    std::stringstream ss;
+    ss << "duplicate definition of '" << header.first << "' header";
+
+    return ss.str();
+}
+
+bool HeaderValuePresentedChecker::operator()() const {
+
+    return !header.second.empty();
+}
+
+std::string HeaderValuePresentedChecker::getMessage() const {
+
+    return "HTTP header has no value";
+}
+
+bool HeaderParserValidator::operator()(const ValidateFunctorBase& rule) {
+    bool rc = rule();
+
+    if(!rc) {
+        out.report.warnings.push_back(Warning(rule.getMessage(),
+            HTTPWarning,
+            sourceMap));
+    }
+
+    return rc;
+}
+

data/ext/{snowcrash → drafter/ext/snowcrash}/src/HeadersParser.h

@@ -14,6 +14,7 @@
 #include "CodeBlockUtility.h"
 #include "StringUtility.h"
 #include "BlueprintUtility.h"
+#include "RegexMatch.h"
 
 namespace snowcrash {
 
@@ -23,6 +24,87 @@ namespace snowcrash {
     /** Header Iterator in its containment group */
     typedef Collection<Header>::const_iterator HeaderIterator;
 
+    /** Base class for functor to check validity of parsed header */
+    struct ValidateFunctorBase {
+
+        /** intended to generate warning mesage */
+        virtual std::string getMessage() const = 0;
+
+        /**
+         * intended to invoke validation
+         * \return true if validation is ok
+         *
+         * data for validation you can inject into functor via c-tor
+         */
+        virtual bool operator()() const = 0;
+
+    };
+
+    /** Functor implementation for check header name is valid token according to specification \see http://tools.ietf.org/html/rfc7230#section-3.2.6 */
+    struct HeaderNameTokenChecker : public ValidateFunctorBase {
+
+        const std::string& headerName;
+
+        explicit HeaderNameTokenChecker(const std::string& headerName) : headerName(headerName) {}
+
+        virtual bool operator()() const;
+        virtual std::string getMessage() const;
+    };
+
+    /** Functor implementation for check header contains colon character between name and value */
+    struct ColonPresentedChecker : public ValidateFunctorBase {
+
+        const CaptureGroups& captures;
+
+        explicit ColonPresentedChecker(const CaptureGroups& captures) : captures(captures) {}
+
+        virtual bool operator()() const;
+        virtual std::string getMessage() const;
+
+    };
+
+    /** Functor implementation to check Headers duplicity */
+    struct HeadersDuplicateChecker : public ValidateFunctorBase {
+
+        const Header& header;
+        const Headers& headers;
+
+        explicit HeadersDuplicateChecker(const Header& header,
+                                         const Headers& headers)
+            : header(header), headers(headers) {}
+
+        virtual bool operator()() const;
+        virtual std::string getMessage() const;
+
+    };
+
+    /** Functor implementation to check Headers duplicity */
+    struct HeaderValuePresentedChecker : public ValidateFunctorBase {
+
+        const Header& header;
+
+        explicit HeaderValuePresentedChecker(const Header& header)
+            : header(header) {}
+
+        virtual bool operator()() const;
+        virtual std::string getMessage() const;
+
+    };
+
+    /** Functor receive and invoke individual Validators and conditionaly push reports  */
+    struct HeaderParserValidator {
+
+        const ParseResultRef<Headers>& out;
+        mdp::CharactersRangeSet sourceMap;
+
+        HeaderParserValidator(const ParseResultRef<Headers>& out,
+                              mdp::CharactersRangeSet sourceMap)
+            : out(out), sourceMap(sourceMap) {}
+
+        bool operator()(const ValidateFunctorBase& rule);
+    };
+
+
     /**
      *  Headers Section Processor
      */
@@ -43,13 +125,7 @@ namespace snowcrash {
             return ++MarkdownNodeIterator(node);
         }
 
-        static MarkdownNodeIterator processDescription(const MarkdownNodeIterator& node,
-                                                       const MarkdownNodes& siblings,
-                                                       SectionParserData& pd,
-                                                       const ParseResultRef<Headers>& out) {
-
-            return node;
-        }
+        NO_SECTION_DESCRIPTION(Headers)
 
         static MarkdownNodeIterator processContent(const MarkdownNodeIterator& node,
                                                    const MarkdownNodes& siblings,
@@ -64,11 +140,6 @@ namespace snowcrash {
             return ++MarkdownNodeIterator(node);
         }
 
-        static bool isDescriptionNode(const MarkdownNodeIterator& node,
-                                      SectionType sectionType) {
-            return false;
-        }
-
         static bool isContentNode(const MarkdownNodeIterator& node,
                                   SectionType sectionType) {
 
@@ -108,10 +179,47 @@ namespace snowcrash {
             }
         }
 
+        /**
+         * Parse individual line of header
+         * \return true if valid header definition
+         *
+         * Header name is checked against token definition
+         *
+         * \param line - contains individual line with header definition
+         * \param header - is filled by name and value if definition is valid
+         * \param out - "report" member can receive warning while checking validity
+         * \param sourceMap - just contain source mapping for warning report
+         */
+        static bool parseHeaderLine(const mdp::ByteBuffer& line,
+                                    Header& header,
+                                    const ParseResultRef<Headers>& out,
+                                    const mdp::CharactersRangeSet sourceMap) {
+
+            std::string re = " *([^:[:blank:]]+)(( *:? *)(.*)?)$";
+
+            CaptureGroups parts;
+            bool matched = RegexCapture(line, re, parts, 5);
+
+            if (!matched)
+                return false;
+
+            header = std::make_pair(parts[1], parts[4]);
+            TrimString(header.second);
+
+            HeaderParserValidator validate(out, sourceMap);
+
+            validate(HeaderNameTokenChecker(header.first));
+            validate(ColonPresentedChecker(parts));
+            validate(HeadersDuplicateChecker(header, out.node));
+            validate(HeaderValuePresentedChecker(header));
+
+            return !header.first.empty();
+        }
+
         /** Retrieve headers from content */
         static void headersFromContent(const MarkdownNodeIterator& node,
                                        const mdp::ByteBuffer& content,
-                                       SectionParserData& pd,
+                                       const SectionParserData& pd,
                                        const ParseResultRef<Headers>& out) {
 
             std::vector<std::string> lines = Split(content, '\n');
@@ -125,20 +233,9 @@ namespace snowcrash {
                 }
 
                 Header header;
+                mdp::CharactersRangeSet sourceMap = mdp::BytesRangeSetToCharactersRangeSet(node->sourceMap, pd.sourceData);
 
-                if (CodeBlockUtility::keyValueFromLine(*line, header)) {
-                    if (findHeader(out.node, header) != out.node.end() && !isAllowedMultipleDefinition(header)) {
-                        // WARN: duplicate header on this level
-                        std::stringstream ss;
-
-                        ss << "duplicate definition of '" << header.first << "' header";
-
-                        mdp::CharactersRangeSet sourceMap = mdp::BytesRangeSetToCharactersRangeSet(node->sourceMap, pd.sourceData);
-                        out.report.warnings.push_back(Warning(ss.str(),
-                                                              DuplicateWarning,
-                                                              sourceMap));
-                    }
-
+                if (parseHeaderLine(*line, header, out, sourceMap)) {
                     out.node.push_back(header);
 
                     if (pd.exportSourceMap()) {
@@ -222,34 +319,6 @@ namespace snowcrash {
             }
         }
 
-        /** Finds a header in its containment group by its key (first) */
-        static HeaderIterator findHeader(const Headers& headers,
-                                         const Header& header) {
-
-            return std::find_if(headers.begin(),
-                                headers.end(),
-                                std::bind2nd(MatchFirsts<Header, IEqual<Header::first_type> >(), header));
-        }
-
-        typedef std::vector<std::string> HeadersKeyCollection;
-        /** Get collection of allowed keywords - workarround due to C++98 restriction - static initialization of vector */
-        static const HeadersKeyCollection& getAllowedMultipleDefinitions() {
-            static std::string keys[] = {
-                HTTPHeaderName::SetCookie,
-                HTTPHeaderName::Link,
-            };
-
-            static const HeadersKeyCollection allowedMultipleDefinitions(keys, keys + (sizeof(keys)/sizeof(keys[0])));
-            return allowedMultipleDefinitions;
-        }
-
-        /** Check if Header name has allowed multiple definitions */
-        static bool isAllowedMultipleDefinition(const Header& header) {
-              const HeadersKeyCollection& keys = getAllowedMultipleDefinitions();
-              return std::find_if(keys.begin(),
-                                  keys.end(),
-                                  std::bind1st(MatchFirstWith<Header, std::string, IEqual<std::string> >(), header)) != keys.end();
-        }
     };
 
     /** Headers Section Parser */

data/ext/drafter/ext/snowcrash/src/MSON.cc

@@ -0,0 +1,272 @@
+//
+//  MSON.cc
+//  snowcrash
+//
+//  Created by Pavan Kumar Sunkara on 11/4/14.
+//  Copyright (c) 2014 Apiary Inc. All rights reserved.
+//
+
+#include "MSON.h"
+
+using namespace mson;
+
+bool Value::empty() const
+{
+    return (this->literal.empty() && this->variable == false);
+}
+
+bool Symbol::empty() const
+{
+    return (this->literal.empty() && this->variable == false);
+}
+
+bool TypeName::empty() const
+{
+    return (this->base == UndefinedTypeName && this->symbol.empty());
+}
+
+bool TypeSpecification::empty() const
+{
+    return (this->nestedTypes.empty() && this->name.empty());
+}
+
+bool TypeDefinition::empty() const
+{
+    return (this->attributes == 0 && this->typeSpecification.empty());
+}
+
+bool ValueDefinition::empty() const
+{
+    return (this->values.empty() && this->typeDefinition.empty());
+}
+
+Elements& TypeSection::Content::elements()
+{
+    if (!m_elements.get())
+        throw ELEMENTS_NOT_SET_ERR;
+
+    return *m_elements;
+}
+
+const Elements& TypeSection::Content::elements() const
+{
+    if (!m_elements.get())
+        throw ELEMENTS_NOT_SET_ERR;
+
+    return *m_elements;
+}
+
+TypeSection::Content::Content(const Markdown& description_, const Literal& value_)
+: description(description_), value(value_)
+{
+    m_elements.reset(::new Elements);
+}
+
+TypeSection::Content::Content(const TypeSection::Content& rhs)
+{
+    this->description = rhs.description;
+    this->value = rhs.value;
+    m_elements.reset(::new Elements(*rhs.m_elements.get()));
+}
+
+TypeSection::Content& TypeSection::Content::operator=(const TypeSection::Content& rhs)
+{
+    this->description = rhs.description;
+    this->value = rhs.value;
+    m_elements.reset(::new Elements(*rhs.m_elements.get()));
+
+    return *this;
+}
+
+TypeSection::Content::~Content()
+{
+}
+
+bool TypeSection::empty() const
+{
+    return (this->klass == TypeSection::UndefinedClass &&
+            this->content.value.empty() &&
+            this->content.description.empty() &&
+            this->content.elements().empty());
+}
+
+bool NamedType::empty() const
+{
+    return (this->typeDefinition.empty() &&
+            this->name.empty() &&
+            this->sections.empty());
+}
+
+bool ValueMember::empty() const
+{
+    return (this->valueDefinition.empty() && this->sections.empty() &&
+            this->description.empty());
+}
+
+bool PropertyName::empty() const
+{
+    return (this->literal.empty() && this->variable.empty());
+}
+
+bool PropertyMember::empty() const
+{
+    return (this->name.empty() && this->description.empty() &&
+            this->sections.empty() && this->valueDefinition.empty());
+}
+
+OneOf& Element::Content::oneOf()
+{
+    if (!m_elements.get())
+        throw ELEMENTS_NOT_SET_ERR;
+
+    return *m_elements;
+}
+
+const OneOf& Element::Content::oneOf() const
+{
+    if (!m_elements.get())
+        throw ELEMENTS_NOT_SET_ERR;
+
+    return *m_elements;
+}
+
+Elements& Element::Content::elements()
+{
+    if (!m_elements.get())
+        throw ELEMENTS_NOT_SET_ERR;
+
+    return *m_elements;
+}
+
+const Elements& Element::Content::elements() const
+{
+    if (!m_elements.get())
+        throw ELEMENTS_NOT_SET_ERR;
+
+    return *m_elements;
+}
+
+Element::Content& Element::Content::operator=(const Elements& rhs)
+{
+    m_elements.reset(::new Elements(rhs));
+
+    return *this;
+}
+
+Element::Content::Content()
+{
+    m_elements.reset(::new Elements);
+}
+
+Element::Content::Content(const Element::Content& rhs)
+{
+    this->property = rhs.property;
+    this->value = rhs.value;
+    this->mixin = rhs.mixin;
+    m_elements.reset(::new Elements(*rhs.m_elements.get()));
+}
+
+Element::Content& Element::Content::operator=(const Element::Content& rhs)
+{
+    this->property = rhs.property;
+    this->value = rhs.value;
+    this->mixin = rhs.mixin;
+    m_elements.reset(::new Elements(*rhs.m_elements.get()));
+
+    return *this;
+}
+
+Element::Content::~Content()
+{
+}
+
+Element::Element(const Element::Class& klass_)
+: klass(klass_)
+{
+}
+
+Element::Element(const Element& rhs)
+{
+    this->klass = rhs.klass;
+    this->content = rhs.content;
+}
+
+Element& Element::operator=(const Element& rhs)
+{
+    this->klass = rhs.klass;
+    this->content = rhs.content;
+
+    return *this;
+}
+
+Element::~Element()
+{
+}
+
+/**
+ * \brief Build Element from property member
+ *
+ * \param propertyMember Property member which was given
+ */
+void Element::build(const PropertyMember& propertyMember)
+{
+    this->klass = Element::PropertyClass;
+    this->content.property = propertyMember;
+}
+
+/**
+ * \brief Build Element from value member
+ *
+ * \param valueMember Value member which was given
+ */
+void Element::build(const ValueMember& valueMember)
+{
+    this->klass = Element::ValueClass;
+    this->content.value = valueMember;
+}
+
+/**
+ * \brief Build Element from mixin type
+ *
+ * \param mixin Mixin which was given
+ */
+void Element::build(const Mixin& mixin)
+{
+    this->klass = Element::MixinClass;
+    this->content.mixin = mixin;
+}
+
+/**
+ * \brief Build Element from one of type
+ *
+ * \param oneOf One Of which was given
+ */
+void Element::build(const OneOf& oneOf)
+{
+    this->buildFromElements(oneOf);
+    this->klass = Element::OneOfClass;
+}
+
+/**
+ * \brief Build Element from a value
+ *
+ * \param value Value of the value member
+ */
+void Element::build(const Value& value)
+{
+    ValueMember valueMember;
+
+    valueMember.valueDefinition.values.push_back(value);
+    this->build(valueMember);
+}
+
+/**
+ * \brief Buile Element from group of elements
+ *
+ * \param elements Group of elements
+ */
+void Element::buildFromElements(const Elements &elements)
+{
+    this->klass = Element::GroupClass;
+    this->content = elements;
+}