redsnow 0.0.8

data/ext/snowcrash/src/SerializeJSON.h

@@ -0,0 +1,21 @@
+//
+//  SerializeJSON.h
+//  snowcrash
+//
+//  Created by Zdenek Nemec on 4/27/13.
+//  Copyright (c) 2013 Apiary Inc. All rights reserved.
+//
+
+#ifndef SNOWCRASH_SERIALIZE_JSON_H
+#define SNOWCRASH_SERIALIZE_JSON_H
+
+#include <ostream>
+#include "Blueprint.h"
+
+namespace snowcrash {
+
+    // Naive JSON serialization to ostream
+    void SerializeJSON(const snowcrash::Blueprint& blueprint, std::ostream &os);
+}
+
+#endif 

data/ext/snowcrash/src/SerializeYAML.cc

@@ -0,0 +1,336 @@
+//
+//  SerializeYAML.cc
+//  snowcrash
+//
+//  Created by Zdenek Nemec on 5/3/13.
+//  Copyright (c) 2013 Apiary Inc. All rights reserved.
+//
+
+#include "Serialize.h"
+#include "SerializeYAML.h"
+
+using namespace snowcrash;
+
+static std::string ReservedCharacters = "#-[]:|>!*&%@`,{}?\'";
+
+/** Normalizes string value for use in YAML and checks whether quotation is need */
+static std::string NormalizeStringValue(const std::string& value, bool& needsQuotation)
+{
+    std::string normalizedValue = value;
+    if (normalizedValue.find("\"") != std::string::npos)
+        normalizedValue = EscapeDoubleQuotes(normalizedValue);
+    
+    if (value.find("\n") != std::string::npos)
+        normalizedValue = EscapeNewlines(normalizedValue);
+    
+    needsQuotation = (normalizedValue != value);
+    if (!needsQuotation) {
+        for (std::string::const_iterator it = value.begin() ; it < value.end() ; ++it){
+            needsQuotation = ReservedCharacters.find(*it) != std::string::npos;
+            if (needsQuotation)
+                break;
+        }
+    }
+    
+    return normalizedValue;
+}
+
+
+/** Insert array item mark */
+static void ArrayItemLeadIn(size_t level, std::ostream &os)
+{
+    if (level < 1)
+        return;
+    
+    for (size_t i = 0; i < level - 1; ++i)
+        os << "  ";
+
+    os << "- ";
+}
+
+/** Serialize key value pair */
+static void serialize(const std::string& key, const std::string& value, size_t level, std::ostream &os, bool implicitQuotation = true)
+{
+    if (key.empty())
+        return;
+    
+    for (size_t i = 0; i < level; ++i)
+        os << "  ";
+    
+    if (!value.empty()) {
+        
+        os << key << ": ";
+
+        bool needsQuotation = false;
+        std::string normalizedValue = NormalizeStringValue(value, needsQuotation);
+        
+        if (implicitQuotation) {
+            // Always use quotation
+            os << "\"" << normalizedValue << "\"";
+        }
+        else {
+            if (needsQuotation)
+                os << "\"" << normalizedValue << "\"";
+            else
+                os << value;
+        }
+        
+        os << std::endl;
+    }
+    else
+        os << key << ":\n";
+}
+
+/** Serializes key value collection */
+static void serializeKeyValueCollection(const Collection<KeyValuePair>::type& collection, size_t level, std::ostream &os)
+{
+    for (Collection<KeyValuePair>::const_iterator it = collection.begin(); it != collection.end(); ++it) {
+
+        // Array item
+        ArrayItemLeadIn(level + 1, os);
+
+        // Name
+        serialize(SerializeKey::Name, it->first, 0, os);
+
+        // Value
+        serialize(SerializeKey::Value, it->second, level + 1, os);
+    }
+}
+
+/** Serialize Metadata */
+static void serialize(const Collection<Metadata>::type& metadata, std::ostream &os)
+{
+    serialize(SerializeKey::Metadata, std::string(), 0, os);
+    
+    if (metadata.empty())
+        return;
+
+    serializeKeyValueCollection(metadata, 0, os);
+}
+
+/** Serialize Headers */
+static void serialize(const Collection<Header>::type& headers, size_t level, std::ostream &os)
+{
+    serializeKeyValueCollection(headers, level, os);
+}
+
+/** Serialize Parameters */
+static void serialize(const Collection<Parameter>::type& parameters, size_t level, std::ostream &os)
+{
+    for (Collection<Parameter>::const_iterator it = parameters.begin(); it != parameters.end(); ++it) {
+
+        // Array item
+        ArrayItemLeadIn(level + 1, os);
+
+        // Key / name
+        serialize(SerializeKey::Name, it->name, 0, os);
+
+        // Description
+        serialize(SerializeKey::Description, it->description, level + 1, os);
+        
+        // Type
+        serialize(SerializeKey::Type, it->type, level + 1, os);
+        
+        // Required
+        serialize(SerializeKey::Required, (it->use == OptionalParameterUse) ? "false" : "true", level + 1, os, false);
+        
+        // Default
+        serialize(SerializeKey::Default, it->defaultValue, level + 1, os);
+        
+        // Example
+        serialize(SerializeKey::Example, it->exampleValue, level + 1, os);
+        
+        // Values
+        serialize(SerializeKey::Values, std::string(), level + 1, os);
+        
+        if (!it->values.empty()) {
+            for (Collection<Value>::const_iterator val_it = it->values.begin();
+                 val_it != it->values.end();
+                 ++val_it) {
+
+                ArrayItemLeadIn(level + 2, os);
+                
+                serialize(SerializeKey::Value, *val_it, 0, os);
+            }
+        }
+    }
+}
+
+/** Serialize Payload */
+static void serialize(const Payload& payload, size_t level, bool array, std::ostream &os)
+{
+    for (size_t i = 0; i < level - 1; i++) {
+        os << "  ";
+    }
+    
+    if (array)
+        os << "- ";
+    else
+        os << "  ";
+    
+    // Name
+    serialize(SerializeKey::Name, payload.name, 0, os);
+    
+    // Description
+    serialize(SerializeKey::Description, payload.description, level, os);
+    
+    // Headers
+    serialize(SerializeKey::Headers, std::string(), level, os);
+    if (!payload.headers.empty()) {
+        serialize(payload.headers, level, os);
+    }
+    
+    // Body
+    serialize(SerializeKey::Body, payload.body, level, os);
+    
+    // Schema
+    serialize(SerializeKey::Schema, payload.schema, level, os);
+
+}
+
+// Serialize Transaction Example
+static void serialize(const TransactionExample& example, std::ostream &os)
+{
+    os << "      - ";   // indent 4
+    // Name
+    serialize(SerializeKey::Name, example.name, 0, os);
+    
+    // Description
+    serialize(SerializeKey::Description, example.description, 4, os);
+    
+    // Requests
+    serialize(SerializeKey::Requests, std::string(), 4, os);
+    if (!example.requests.empty()) {
+        for (Collection<Request>::const_iterator it = example.requests.begin(); it != example.requests.end(); ++it) {
+            serialize(*it, 5, true, os);
+        }
+    }
+    
+    // Responses
+    serialize(SerializeKey::Responses, std::string(), 4, os);
+    if (!example.responses.empty()) {
+        for (Collection<Response>::const_iterator it = example.responses.begin(); it != example.responses.end(); ++it) {
+            serialize(*it, 5, true, os);
+        }
+    }
+}
+
+/** Serialize Action */
+static void serialize(const Action& action, std::ostream &os)
+{
+    os << "    - ";   // indent 3
+    
+    // Name
+    serialize(SerializeKey::Name, action.name, 0, os);
+    
+    // Description
+    serialize(SerializeKey::Description, action.description, 3, os);
+
+    // HTTP method
+    serialize(SerializeKey::Method, action.method, 3, os);
+    
+    // Parameters
+    serialize(SerializeKey::Parameters, std::string(), 3, os);
+    if (!action.parameters.empty())
+        serialize(action.parameters, 3, os);
+    
+    // Examples
+    serialize(SerializeKey::Examples, std::string(), 3, os);
+    if (!action.examples.empty()) {
+        for (Collection<TransactionExample>::const_iterator it = action.examples.begin();
+             it != action.examples.end();
+             ++it) {
+            serialize(*it, os);
+        }
+    }
+}
+
+/** Serialize Resource */
+static void serialize(const Resource& resource, std::ostream &os)
+{
+    os << "  - ";   // indent 2
+    
+    // Name
+    serialize(SerializeKey::Name, resource.name, 0, os);
+    
+    // Description
+    serialize(SerializeKey::Description, resource.description, 2, os);
+    
+    // URI Template
+    serialize(SerializeKey::URITemplate, resource.uriTemplate, 2, os);
+    
+    // Model
+    serialize(SerializeKey::Model, std::string(), 2, os);
+    if (!resource.model.name.empty())
+        serialize(resource.model, 3, false, os);
+    
+    // Parameters
+    serialize(SerializeKey::Parameters, std::string(), 2, os);
+    if (!resource.parameters.empty())
+        serialize(resource.parameters, 2, os);
+    
+    // Actions
+    serialize(SerializeKey::Actions, std::string(), 2, os);
+    
+    if (resource.actions.empty())
+        return;
+    
+    for (Collection<Action>::const_iterator it = resource.actions.begin(); it != resource.actions.end(); ++it) {
+        serialize(*it, os);
+    }
+}
+
+/** Serialize Resource Group */
+static void serialize(const ResourceGroup& group, std::ostream &os)
+{
+    os << "- ";   // indent 1
+
+    // Name
+    serialize(SerializeKey::Name, group.name, 0, os);
+    
+    // Description
+    serialize(SerializeKey::Description, group.description, 1, os);
+
+    // Resources
+    serialize(SerializeKey::Resources, std::string(), 1, os);
+    
+    if (group.resources.empty())
+        return;
+
+    for (Collection<Resource>::const_iterator it = group.resources.begin(); it != group.resources.end(); ++it) {
+        serialize(*it, os);
+    }
+}
+
+/** Serialize Blueprint */
+static void serialize(const Blueprint& blueprint, std::ostream &os)
+{
+    // AST Version
+    serialize(SerializeKey::ASTVersion, AST_SERIALIZATION_VERSION, 0, os, false);
+    
+    // Metadata
+    serialize(blueprint.metadata, os);
+    
+    // API Name
+    serialize(SerializeKey::Name, blueprint.name, 0, os);
+    
+    // API Description
+    serialize(SerializeKey::Description, blueprint.description, 0, os);
+    
+    // Resource Groups
+    serialize(SerializeKey::ResourceGroups, std::string(), 0, os);
+    if (blueprint.resourceGroups.empty())
+        return;
+
+    for (Collection<ResourceGroup>::type::const_iterator it = blueprint.resourceGroups.begin();
+         it != blueprint.resourceGroups.end();
+         ++it) {
+        
+        serialize(*it, os);
+    }
+}
+
+void snowcrash::SerializeYAML(const snowcrash::Blueprint& blueprint, std::ostream &os)
+{
+    serialize(blueprint, os);
+}

data/ext/snowcrash/src/SerializeYAML.h

@@ -0,0 +1,21 @@
+//
+//  SerializeYAML.h
+//  snowcrash
+//
+//  Created by Zdenek Nemec on 5/3/13.
+//  Copyright (c) 2013 Apiary Inc. All rights reserved.
+//
+
+#ifndef SNOWCRASH_SERIALIZE_YAML_H
+#define SNOWCRASH_SERIALIZE_YAML_H
+
+#include <ostream>
+#include "Blueprint.h"
+
+namespace snowcrash {
+    
+    // Naive YAML serialization to ostream
+    void SerializeYAML(const snowcrash::Blueprint& blueprint, std::ostream &os);
+}
+
+#endif

data/ext/snowcrash/src/SourceAnnotation.h

@@ -0,0 +1,177 @@
+//
+//  SourceAnnotation.h
+//  snowcrash
+//
+//  Created by Zdenek Nemec on 7/12/13.
+//  Copyright (c) 2013 Apiary Inc. All rights reserved.
+//
+
+#ifndef SNOWCRASH_SOURCEANNOTATION_H
+#define SNOWCRASH_SOURCEANNOTATION_H
+
+#include <string>
+#include <vector>
+
+namespace snowcrash {
+    
+    /**
+     *  \brief  A character range within the source code string.
+     */
+    struct SourceCharactersRange {
+        size_t location;
+        size_t length;
+    };
+    
+    /**
+     *  \brief  A block (set of ranges) of source code characters. A character map.
+     *
+     *  NOTE: The block does not have to be continuous.
+     */
+    typedef std::vector<SourceCharactersRange> SourceCharactersBlock;
+    
+    /**
+     *  \brief  A source data annotation.
+     *
+     *  Annotation bound to a source data block. Includes an
+     *  annotation code and an optional message.
+     */
+    struct SourceAnnotation {
+        
+        /**
+         *  \brief Default annotation code representing success.
+         */
+        static const int OK;
+        
+        /**
+         *  \brief  %SourceAnnotation default constructor.
+         *
+         *  Creates an empty annotation with the default annotation code.
+         */
+        SourceAnnotation() : code(OK) {}
+        
+        /**
+         *  \brief  %SourceAnnotation copy constructor.
+         *  \param  rhs  An annotation to be copied.
+         */
+        SourceAnnotation(const SourceAnnotation& rhs) {
+            
+            this->message = rhs.message;
+            this->code = rhs.code;
+            this->location = rhs.location;
+        }
+        
+        /**
+         *  \brief  %SourceAnnotation constructor.
+         *  \param  message     An annotation message.
+         *  \param  code        Annotation code.
+         *  \param  location    A location of the annotation.
+         */
+        SourceAnnotation(const std::string& message,
+                         int code = OK,
+                         const SourceCharactersBlock& location = SourceCharactersBlock()) {
+            
+            this->message = message;
+            this->code = code;
+            
+            this->location.clear();
+            if (!location.empty())
+                this->location.assign(location.begin(), location.end());
+        }
+        
+        /** \brief  %SourceAnnotation destructor. */
+        ~SourceAnnotation() {}
+        
+        /**
+         *  \brief  %SourceAnnotation assignment operator
+         *  \param  rhs  An annotation to be assigned to this annotation.
+         */
+        SourceAnnotation& operator=(const SourceAnnotation& rhs) {
+            this->message = rhs.message;
+            this->code = rhs.code;
+            this->location = rhs.location;
+            return *this;
+        }
+        
+        /** The location of this annotation within the source data buffer. */
+        SourceCharactersBlock location;
+        
+        /** An annotation code. */
+        int code;
+        
+        /** A annotation message. */
+        std::string message;
+    };
+    
+    /**
+     *  Error source annotation.
+     */
+    typedef SourceAnnotation Error;
+    
+    /**
+     *  Error codes
+     */
+    enum ErrorCode {
+        NoError = 0,
+        ApplicationError = 1,
+        BusinessError = 2,
+        SymbolError = 3
+    };
+    
+    /**
+     *  Warning source annotation.
+     */
+    typedef SourceAnnotation Warning;
+    
+    /**
+     *  Warning codes
+     */
+    enum WarningCode {
+        NoWarning = 0,
+        APINameWarning = 1,
+        DuplicateWarning = 2,
+        FormattingWarning = 3,
+        RedefinitionWarning = 4,
+        IgnoringWarning = 5,
+        EmptyDefinitionWarning = 6,
+        NotEmptyDefinitionWarning = 7,
+        LogicalErrorWarning = 8,
+        DeprecatedWarning = 9,
+        IndentationWarning = 10,
+        AmbiguityWarning = 11,
+        URIWarning = 12
+    };
+    
+    /**
+     *  A set of warning source annotations.
+     */
+    typedef std::vector<Warning> Warnings;
+    
+    /**
+     *  \brief A parsing result Report.
+     *
+     *  Result of a source data parsing operation.
+     *  Composed of ONE error source annotation
+     *  and a set of warning source annotations.
+     */
+    struct Result {
+        
+        /**
+         *  \brief Append a result to this one, replacing the error source annotation.
+         *
+         *  NOTE: A binding does not need to wrap this action.
+         */
+        Result& operator+=(const Result& rhs) {
+            error = rhs.error;
+            warnings.insert(warnings.end(), rhs.warnings.begin(), rhs.warnings.end());
+            return *this;
+        }
+        
+        /** Result error source annotation */
+        Error error;
+        
+        /** Result warning source annotations */
+        Warnings warnings;
+    };
+}
+
+#endif