redsnow 0.2.1 → 0.3.0

data/ext/snowcrash/src/BlueprintParser.h

@@ -32,14 +32,15 @@ namespace snowcrash {
                                                      const MarkdownNodes& siblings,
                                                      SectionParserData& pd,
                                                      SectionLayout& layout,
-                                                     ParseResult<Blueprint>& out) {
+                                                     const ParseResultRef<Blueprint>& out) {
 
             MarkdownNodeIterator cur = node;
 
             while (cur != siblings.end() &&
                    cur->type == mdp::ParagraphMarkdownNodeType) {
 
-                ParseResult<MetadataCollection> metadata(out.report);
+                IntermediateParseResult<MetadataCollection> metadata(out.report);
+
                 parseMetadata(cur, pd, metadata);
 
                 // First block is paragraph and is not metadata (no API name)
@@ -57,7 +58,7 @@ namespace snowcrash {
 
                 cur++;
             }
-            
+
             // Ideally this parsing metadata should be handled by separate parser
             // that way the following check would be covered in SectionParser::parse()
             if (cur == siblings.end())
@@ -91,12 +92,13 @@ namespace snowcrash {
         static MarkdownNodeIterator processNestedSection(const MarkdownNodeIterator& node,
                                                          const MarkdownNodes& siblings,
                                                          SectionParserData& pd,
-                                                         ParseResult<Blueprint>& out) {
+                                                         const ParseResultRef<Blueprint>& out) {
 
             if (pd.sectionContext() == ResourceGroupSectionType ||
                 pd.sectionContext() == ResourceSectionType) {
 
-                ParseResult<ResourceGroup> resourceGroup(out.report);
+                IntermediateParseResult<ResourceGroup> resourceGroup(out.report);
+
                 MarkdownNodeIterator cur = ResourceGroupParser::parse(node, siblings, pd, resourceGroup);
 
                 ResourceGroupIterator duplicate = findResourceGroup(out.node.resourceGroups, resourceGroup.node);
@@ -171,8 +173,10 @@ namespace snowcrash {
 
         static void finalize(const MarkdownNodeIterator& node,
                              SectionParserData& pd,
-                             ParseResult<Blueprint>& out) {
-            
+                             const ParseResultRef<Blueprint>& out) {
+     
+            checkLazyReferencing(pd, out);
+
             if (!out.node.name.empty())
                 return;
 
@@ -183,7 +187,7 @@ namespace snowcrash {
                 out.report.error = Error(ExpectedAPINameMessage,
                                          BusinessError,
                                          sourceMap);
-                
+
             }
             else if (!out.node.description.empty()) {
                 mdp::CharactersRangeSet sourceMap = mdp::BytesRangeSetToCharactersRangeSet(node->sourceMap, pd.sourceData);
@@ -195,7 +199,7 @@ namespace snowcrash {
 
         static bool isUnexpectedNode(const MarkdownNodeIterator& node,
                                      SectionType sectionType) {
-            
+
             // Since Blueprint is currently top-level node any unprocessed node should be reported
             return true;
         }
@@ -203,7 +207,7 @@ namespace snowcrash {
 
         static void parseMetadata(const MarkdownNodeIterator& node,
                                   SectionParserData& pd,
-                                  ParseResult<MetadataCollection>& out) {
+                                  const ParseResultRef<MetadataCollection>& out) {
 
             mdp::ByteBuffer content = node->text;
             TrimStringEnd(content);
@@ -278,6 +282,211 @@ namespace snowcrash {
                                 resourceGroups.end(),
                                 std::bind2nd(MatchName<ResourceGroup>(), resourceGroup));
         }
+
+        /**
+         *  \brief  Checks both blueprint and source map AST to resolve references with `Pending` state (Lazy referencing)
+         *  \param  pd       Section parser state
+         *  \param  out      Processed output
+         */
+        static void checkLazyReferencing(SectionParserData& pd,
+                                         const ParseResultRef<Blueprint>& out) {
+
+            Collection<SourceMap<ResourceGroup> >::iterator resourceGroupSourceMapIt;
+
+            if (pd.exportSourceMap()) {
+                resourceGroupSourceMapIt = out.sourceMap.resourceGroups.collection.begin();
+            }
+
+            for (ResourceGroups::iterator resourceGroupIt = out.node.resourceGroups.begin();
+                 resourceGroupIt != out.node.resourceGroups.end();
+                 ++resourceGroupIt) {
+
+                checkResourceLazyReferencing(*resourceGroupIt, resourceGroupSourceMapIt, pd, out);
+
+                if (pd.exportSourceMap()) {
+                    resourceGroupSourceMapIt++;
+                }
+            }
+        }
+
+        /** Traverses Resource Collection to resolve references with `Pending` state (Lazy referencing) */
+        static void checkResourceLazyReferencing(ResourceGroup& resourceGroup,
+                                                 Collection<SourceMap<ResourceGroup> >::iterator resourceGroupSourceMapIt,
+                                                 SectionParserData& pd,
+                                                 const ParseResultRef<Blueprint>& out) {
+
+            Collection<SourceMap<Resource> >::iterator resourceSourceMapIt;
+
+            if (pd.exportSourceMap()) {
+                resourceSourceMapIt = resourceGroupSourceMapIt->resources.collection.begin();
+            }
+
+            for (Resources::iterator resourceIt = resourceGroup.resources.begin();
+                 resourceIt != resourceGroup.resources.end();
+                 ++resourceIt) {
+
+                checkActionLazyReferencing(*resourceIt, resourceSourceMapIt, pd, out);
+
+                if (pd.exportSourceMap()) {
+                    resourceSourceMapIt++;
+                }
+            }
+        }
+
+        /** Traverses Action Collection to resolve references with `Pending` state (Lazy referencing) */
+        static void checkActionLazyReferencing(Resource& resource,
+                                               Collection<SourceMap<Resource> >::iterator resourceSourceMapIt,
+                                               SectionParserData& pd,
+                                               const ParseResultRef<Blueprint>& out) {
+
+            Collection<SourceMap<Action> >::iterator actionSourceMapIt;
+
+            if (pd.exportSourceMap()) {
+                actionSourceMapIt = resourceSourceMapIt->actions.collection.begin();
+            }
+
+            for (Actions::iterator actionIt = resource.actions.begin();
+                 actionIt != resource.actions.end();
+                 ++actionIt) {
+
+                checkExampleLazyReferencing(*actionIt, actionSourceMapIt, pd, out);
+
+                if (pd.exportSourceMap()) {
+                    actionSourceMapIt++;
+                }
+            }
+        }
+
+        /** Traverses Transaction Example Collection AST to resolve references with `Pending` state (Lazy referencing) */
+        static void checkExampleLazyReferencing(Action& action,
+                                                Collection<SourceMap<Action> >::iterator actionSourceMapIt,
+                                                SectionParserData& pd,
+                                                const ParseResultRef<Blueprint>& out) {
+
+            Collection<SourceMap<TransactionExample> >::iterator exampleSourceMapIt;
+
+            if (pd.exportSourceMap()) {
+                exampleSourceMapIt = actionSourceMapIt->examples.collection.begin();
+            }
+
+            for (TransactionExamples::iterator transactionExampleIt = action.examples.begin();
+                 transactionExampleIt != action.examples.end();
+                 ++transactionExampleIt) {
+
+                checkRequestLazyReferencing(*transactionExampleIt, exampleSourceMapIt, pd, out);
+                checkResponseLazyReferencing(*transactionExampleIt, exampleSourceMapIt, pd, out);
+
+                if (pd.exportSourceMap()) {
+                    exampleSourceMapIt++;
+                }
+            }
+        }
+
+        /** Traverses Request Collection to resolve references with `Pending` state (Lazy referencing) */
+        static void checkRequestLazyReferencing(TransactionExample& transactionExample,
+                                                Collection<SourceMap<TransactionExample> >::iterator transactionExampleSourceMapIt,
+                                                SectionParserData& pd,
+                                                const ParseResultRef<Blueprint>& out) {
+
+            Collection<SourceMap<Request> >::iterator requestSourceMapIt;
+
+            if (pd.exportSourceMap()) {
+                requestSourceMapIt = transactionExampleSourceMapIt->requests.collection.begin();
+            }
+
+            for (Requests::iterator requestIt = transactionExample.requests.begin();
+                 requestIt != transactionExample.requests.end();
+                 ++requestIt) {
+
+                if (!requestIt->reference.id.empty() &&
+                    requestIt->reference.meta.state == Reference::StatePending) {
+
+                    if (pd.exportSourceMap()) {
+
+                        ParseResultRef<Payload> payload(out.report, *requestIt, *requestSourceMapIt);
+                        resolvePendingSymbols(pd, payload);
+                        SectionProcessor<Payload>::checkRequest(requestIt->reference.meta.node, pd, payload);
+                    }
+                    else {
+
+                        SourceMap<Payload> tempSourceMap;
+                        ParseResultRef<Payload> payload(out.report, *requestIt, tempSourceMap);
+                        resolvePendingSymbols(pd, payload);
+                        SectionProcessor<Payload>::checkRequest(requestIt->reference.meta.node, pd, payload);
+                    }
+                }
+
+                if (pd.exportSourceMap()) {
+                    requestSourceMapIt++;
+                }
+            }
+        }
+
+        /** Traverses Response Collection to resolve references with `Pending` state (Lazy referencing) */
+        static void checkResponseLazyReferencing(TransactionExample& transactionExample,
+                                                 Collection<SourceMap<TransactionExample> >::iterator transactionExampleSourceMapIt,
+                                                 SectionParserData& pd,
+                                                 const ParseResultRef<Blueprint>& out) {
+
+            Collection<SourceMap<Response> >::iterator responseSourceMapIt;
+
+            if (pd.exportSourceMap()) {
+                responseSourceMapIt = transactionExampleSourceMapIt->responses.collection.begin();
+            }
+
+            for (Responses::iterator responseIt = transactionExample.responses.begin();
+                 responseIt != transactionExample.responses.end();
+                 ++responseIt) {
+
+                if (!responseIt->reference.id.empty() &&
+                    responseIt->reference.meta.state == Reference::StatePending) {
+
+                    if (pd.exportSourceMap()) {
+
+                        ParseResultRef<Payload> payload(out.report, *responseIt, *responseSourceMapIt);
+                        resolvePendingSymbols(pd, payload);
+                        SectionProcessor<Payload>::checkResponse(responseIt->reference.meta.node, pd, payload);
+                    }
+                    else {
+
+                        SourceMap<Payload> tempSourceMap;
+                        ParseResultRef<Payload> payload(out.report, *responseIt, tempSourceMap);
+                        resolvePendingSymbols(pd, payload);
+                        SectionProcessor<Payload>::checkResponse(responseIt->reference.meta.node, pd, payload);
+                    }
+                }
+
+                if (pd.exportSourceMap()) {
+                    responseSourceMapIt++;
+                }
+            }
+        }
+
+        /**
+         *  \brief  Resolve pending references
+         *  \param  pd       Section parser state
+         *  \param  out      Processed output
+         */
+        static void resolvePendingSymbols(SectionParserData& pd,
+                                          const ParseResultRef<Payload>& out) {
+
+            if (pd.symbolTable.resourceModels.find(out.node.reference.id) == pd.symbolTable.resourceModels.end()) {
+
+                // ERR: Undefined symbol
+                std::stringstream ss;
+                ss << "Undefined symbol " << out.node.reference.id;
+
+                mdp::CharactersRangeSet sourceMap = mdp::BytesRangeSetToCharactersRangeSet(out.node.reference.meta.node->sourceMap, pd.sourceData);
+                out.report.error = Error(ss.str(), SymbolError, sourceMap);
+
+                out.node.reference.meta.state = Reference::StateUnresolved;
+            }
+            else {
+
+                out.node.reference.meta.state = Reference::StateResolved;
+                SectionProcessor<Payload>::assingReferredPayload(pd, out);
+            }
+        }
     };
 
     /** Blueprint Parser */

data/ext/snowcrash/src/BlueprintSourcemap.h

@@ -97,7 +97,7 @@ namespace snowcrash {
         SourceMap<Asset> schema;
 
         /** Source Map of Symbol */
-        SourceMap<SymbolName> symbol;
+        SourceMap<Reference> reference;
     };
 
     /** Source Map of Collection of Requests */

data/ext/snowcrash/src/BlueprintUtility.h

@@ -15,29 +15,29 @@
 #include "HTTP.h"
 
 namespace snowcrash {
-    
+
     /**
      *  \brief Pair firsts matching predicate.
      *
      *  Two pairs are a match if their %first matches.
      */
-    template <class T>
+    template <class T, class Predicate = std::equal_to<typename T::first_type> >
     struct MatchFirsts : std::binary_function<T, T, bool> {
         bool operator()(const T& left, const T& right) const {
-            return left.first == right.first;
+            return Predicate()(left.first, right.first);
         }
     };
-    
+
     /**
      *  \brief Matches a pair's first against a value.
      */
-    template <class T, class R>
+    template <class T, class R = typename T::first_type, class Predicate = std::equal_to<R> >
     struct MatchFirstWith : std::binary_function<T, R, bool> {
         bool operator()(const T& left, const R& right) const {
-            return left.first == right;
+            return Predicate()(left.first, right);
         }
     };
-    
+
     /**  A name matching predicate. */
     template <class T>
     struct MatchName : std::binary_function<T, T, bool> {
@@ -45,7 +45,7 @@ namespace snowcrash {
             return first.name == second.name;
         }
     };
-    
+
     /**
      *  \brief  Payload matching predicate.
      *
@@ -53,11 +53,11 @@ namespace snowcrash {
      */
     struct MatchPayload : std::binary_function<Payload, Payload, bool> {
         bool operator()(const first_argument_type& left, const second_argument_type& right) const {
-            
+
 
             if (left.name != right.name)
                 return false;
-            
+
             // Resolve left content type
             Collection<Header>::const_iterator header;
 
@@ -70,7 +70,7 @@ namespace snowcrash {
 
             if (header != left.headers.end())
                 leftContentType = header->second;
-            
+
             // Resolve right content type
             header = std::find_if(right.headers.begin(),
                                   right.headers.end(),
@@ -81,18 +81,18 @@ namespace snowcrash {
 
             if (header != right.headers.end())
                 rightContentType = header->second;
-            
+
             return leftContentType == rightContentType;
         }
     };
-    
+
     /** URI matching predicate. */
     struct MatchResource : std::binary_function<Resource, Resource, bool> {
         bool operator()(const first_argument_type& first, const second_argument_type& second) const {
             return first.uriTemplate == second.uriTemplate;
         }
     };
-    
+
     /**  Action matching predicate. */
     template <class T>
     struct MatchAction : std::binary_function<T, T, bool> {

data/ext/snowcrash/src/CBlueprint.cc

@@ -252,16 +252,6 @@ SC_API const char* sc_payload_name(const sc_payload_t* handle)
     return p->name.c_str();
 }
 
-/** TODO: Need to change this to use the "Reference" data structure */
-SC_API const char* sc_payload_symbol(const sc_payload_t* handle)
-{
-    const snowcrash::Payload* p = AS_CTYPE(snowcrash::Payload, handle);
-    if (!p)
-        return "";
-
-    return p->symbol.c_str();
-}
-
 SC_API const char* sc_payload_description(const sc_payload_t* handle)
 {
     const snowcrash::Payload* p = AS_CTYPE(snowcrash::Payload, handle);
@@ -291,6 +281,35 @@ SC_API const char* sc_payload_schema(const sc_payload_t* handle)
 
 /*----------------------------------------------------------------------*/
 
+SC_API const sc_reference_t* sc_reference_handle_payload(const sc_payload_t* handle)
+{
+    const snowcrash::Payload* p = AS_CTYPE(snowcrash::Payload, handle);
+    if(!p)
+        return NULL;
+
+    return AS_CTYPE(sc_reference_t, &p->reference);
+}
+
+SC_API const char* sc_reference_id(const sc_reference_t* handle)
+{
+    const snowcrash::Reference* p = AS_CTYPE(snowcrash::Reference, handle);
+    if (!p)
+        return "";
+
+    return p->id.c_str();
+}
+
+SC_API sc_reference_type_t sc_reference_type(const sc_reference_t* handle)
+{
+    const snowcrash::Reference* p = AS_CTYPE(snowcrash::Reference, handle);
+    if (!p)
+        return (sc_reference_type_t)0;
+
+    return (sc_reference_type_t)p->type;
+}
+
+/*----------------------------------------------------------------------*/
+
 SC_API const sc_parameter_collection_t* sc_parameter_collection_handle_payload(const sc_payload_t* handle)
 {
     const snowcrash::Payload* p = AS_CTYPE(snowcrash::Payload, handle);

data/ext/snowcrash/src/CBlueprint.h

@@ -34,6 +34,10 @@ extern "C" {
         SC_REQUIRED_PARAMETER_USE
     } sc_parameter_use;
 
+    typedef enum sc_reference_type_t {
+        SC_TYPE_SYMBOL_REFERENCE
+    } sc_reference_type_t;
+
     /** Class Blueprint wrapper */
     struct sc_blueprint_s;
     typedef struct sc_blueprint_s sc_blueprint_t;
@@ -70,6 +74,10 @@ extern "C" {
     struct sc_payload_collection_s;
     typedef struct sc_payload_collection_s sc_payload_collection_t;
 
+    /** Class Reference wrapper */
+    struct sc_reference_s;
+    typedef struct sc_reference_s sc_reference_t;
+
     /** Class Payload wrapper */
     struct sc_payload_s;
     typedef struct sc_payload_s sc_payload_t;
@@ -210,9 +218,6 @@ extern "C" {
     /** \returns Payload name */
     SC_API const char* sc_payload_name(const sc_payload_t* handle);
 
-    /** \returns Payload symbol name */
-    SC_API const char* sc_payload_symbol(const sc_payload_t* handle);
-
     /** \returns Payload description */
     SC_API const char* sc_payload_description(const sc_payload_t* handle);
 
@@ -224,6 +229,17 @@ extern "C" {
 
     /*----------------------------------------------------------------------*/
 
+    /** \returns Reference handle from payload */
+    SC_API const sc_reference_t* sc_reference_handle_payload(const sc_payload_t* handle);
+
+    /** \returns Reference identifier */
+    SC_API const char* sc_reference_id(const sc_reference_t* handle);
+
+    /** \returns Reference identifier */
+    SC_API sc_reference_type_t sc_reference_type(const sc_reference_t* handle);
+
+    /*----------------------------------------------------------------------*/
+
     /** \returns Parameter Collection handle from Payload */
     SC_API const sc_parameter_collection_t* sc_parameter_collection_handle_payload(const sc_payload_t* handle);