redsnow 0.1.6 → 0.2.0

data/ext/snowcrash/src/Version.h

@@ -15,8 +15,8 @@
 #define SNOWCRASH_VERSION_H
 
 #define SNOWCRASH_MAJOR_VERSION 0
-#define SNOWCRASH_MINOR_VERSION 12
-#define SNOWCRASH_PATCH_VERSION 1
+#define SNOWCRASH_MINOR_VERSION 14
+#define SNOWCRASH_PATCH_VERSION 0
 
 #define SNOWCRASH_VERSION_IS_RELEASE 1
 

data/ext/snowcrash/src/csnowcrash.cc

@@ -5,19 +5,19 @@
 //  Created by Ali Khoramshahi on 13/6/14.
 //  Copyright (c) 2014 Apiary Inc. All rights reserved.
 //
+
 #include "csnowcrash.h"
 #include "snowcrash.h"
 
-
-int sc_c_parse(const char* source, sc_blueprint_parser_options option, sc_result_t** result, sc_blueprint_t** blueprint)
+int sc_c_parse(const char* source, sc_blueprint_parser_options option, sc_report_t** report, sc_blueprint_t** blueprint)
 {
-    snowcrash::Result* t_result = ::new snowcrash::Result;
+    snowcrash::Report* t_report = ::new snowcrash::Report;
     snowcrash::Blueprint* t_blueprint = ::new snowcrash::Blueprint;
 
-    int ret = snowcrash::parse(source, option, *t_result, *t_blueprint);
+    int ret = snowcrash::parse(source, option, *t_report, *t_blueprint);
 
     *blueprint = AS_TYPE(sc_blueprint_t, t_blueprint);
-    *result = AS_TYPE(sc_result_t, t_result);
+    *report = AS_TYPE(sc_report_t, t_report);
 
     return ret;
 }

data/ext/snowcrash/src/csnowcrash.h

@@ -22,14 +22,14 @@ extern "C" {
      *
      *  \param source        A textual source data to be parsed.
      *  \param options       Parser options. Use 0 for no addtional options.
-     *  \param result        returns the pointer to result report.
+     *  \param report        returns the pointer to report.
      *  \param blueprint     returns the pointer to blueprint AST.
      *
      *  \return Error status code. Zero represents success, non-zero a failure.
      *
-     *  \this function will allocate `result` and `bluepring`, for deallocation `sc_blueprint_free` and `sc_result_free` should be called.
+     *  \this function will allocate `report` and `blueprint`, for deallocation `sc_blueprint_free` and `sc_report_free` should be called.
      */
-    SC_API int sc_c_parse(const char* source, sc_blueprint_parser_options option, sc_result_t** result, sc_blueprint_t** blueprint);
+    SC_API int sc_c_parse(const char* source, sc_blueprint_parser_options option, sc_report_t** report, sc_blueprint_t** blueprint);
 
 #ifdef __cplusplus
 }

data/ext/snowcrash/src/snowcrash.cc

@@ -7,12 +7,82 @@
 //
 
 #include "snowcrash.h"
+#include "MarkdownParser.h"
+#include "BlueprintParser.h"
+
+const int snowcrash::SourceAnnotation::OK = 0;
 
 using namespace snowcrash;
 
-int snowcrash::parse(const SourceData& source, BlueprintParserOptions options, Result& result, Blueprint& blueprint)
+/** 
+ *  \brief  Check source for unsupported character \t & \r
+ *  \return True if passed (not found), false otherwise
+ */
+static bool CheckSource(const mdp::ByteBuffer& source, Report& report)
 {
-    Parser p;
-    p.parse(source, options, result, blueprint);
-    return result.error.code;
+    std::string::size_type pos = source.find("\t");
+
+    if (pos != std::string::npos) {
+        
+        mdp::BytesRangeSet rangeSet;
+        rangeSet.push_back(mdp::BytesRange(pos, 1));
+        report.error = Error("the use of tab(s) '\\t' in source data isn't currently supported, please contact makers",
+                             BusinessError,
+                             mdp::BytesRangeSetToCharactersRangeSet(rangeSet, source));
+        return false;
+    }
+    
+    pos = source.find("\r");
+
+    if (pos != std::string::npos) {
+
+        mdp::BytesRangeSet rangeSet;
+        rangeSet.push_back(mdp::BytesRange(pos, 1));
+        report.error = Error("the use of carriage return(s) '\\r' in source data isn't currently supported, please contact makers",
+                             BusinessError,
+                             mdp::BytesRangeSetToCharactersRangeSet(rangeSet, source));
+        return false;
+    }
+    
+    return true;
+}
+
+int snowcrash::parse(const mdp::ByteBuffer& source,
+                     BlueprintParserOptions options,
+                     Report& report,
+                     Blueprint& blueprint)
+{
+    try {
+        
+        // Sanity Check
+        if (!CheckSource(source, report))
+            return report.error.code;
+        
+        // Do nothing if blueprint is empty
+        if (source.empty())
+            return report.error.code;
+
+        // Parse Markdown
+        mdp::MarkdownParser markdownParser;
+        mdp::MarkdownNode markdownAST;
+        markdownParser.parse(source, markdownAST);
+
+        // Build SectionParserData
+        SectionParserData pd(options, source, blueprint);
+
+        // Parse Blueprint
+        BlueprintParser::parse(markdownAST.children().begin(), markdownAST.children(), pd, report, blueprint);
+    }
+    catch (const std::exception& e) {
+        
+        std::stringstream ss;
+        ss << "parser exception: '" << e.what() << "'";
+        report.error = Error(ss.str(), 1);
+    }
+    catch (...) {
+        
+        report.error = Error("parser exception has occured", 1);
+    }
+
+    return report.error.code;
 }

data/ext/snowcrash/src/snowcrash.h

@@ -9,7 +9,9 @@
 #ifndef SNOWCRASH_H
 #define SNOWCRASH_H
 
-#include "Parser.h"
+#include "Blueprint.h"
+#include "SourceAnnotation.h"
+#include "SectionParser.h"
 
 /**
  *  API Blueprint Parser Interface
@@ -30,12 +32,15 @@ namespace snowcrash {
      *  \brief Parse the source data into a blueprint abstract source tree (AST).
      *
      *  \param source        A textual source data to be parsed.
-     *  \param options       Parser options. Use 0 for no addtional options.
-     *  \param result        Parsing result report.
+     *  \param options       Parser options. Use 0 for no additional options.
+     *  \param report        Parsing report.
      *  \param blueprint     Parsed blueprint AST.
      *  \return Error status code. Zero represents success, non-zero a failure.
      */
-    int parse(const SourceData& source, BlueprintParserOptions options, Result& result, Blueprint& blueprint);
+    int parse(const mdp::ByteBuffer& source,
+              BlueprintParserOptions options,
+              Report& report,
+              Blueprint& blueprint);
 }
 
 #endif

data/ext/snowcrash/src/snowcrash/snowcrash.cc

@@ -46,7 +46,7 @@ void PrintAnnotation(const std::string& prefix, const snowcrash::SourceAnnotatio
     }
     
     if (!annotation.location.empty()) {
-        for (snowcrash::SourceCharactersBlock::const_iterator it = annotation.location.begin();
+        for (mdp::CharactersRangeSet::const_iterator it = annotation.location.begin();
              it != annotation.location.end();
              ++it) {
             std::cerr << ((it == annotation.location.begin()) ? " :" : ";");
@@ -57,20 +57,20 @@ void PrintAnnotation(const std::string& prefix, const snowcrash::SourceAnnotatio
     std::cerr << std::endl;
 }
 
-/// \brief Print parser result to stderr.
-/// \param result A parser result to print
-void PrintResult(const snowcrash::Result& result)
+/// \brief Print parser report to stderr.
+/// \param report A parser report to print
+void PrintReport(const snowcrash::Report& report)
 {
     std::cerr << std::endl;
-    
-    if (result.error.code == Error::OK) {
+
+    if (report.error.code == Error::OK) {
         std::cerr << "OK.\n";
     }
     else {
-        PrintAnnotation("error:", result.error);
+        PrintAnnotation("error:", report.error);
     }
-    
-    for (snowcrash::Warnings::const_iterator it = result.warnings.begin(); it != result.warnings.end(); ++it) {
+
+    for (snowcrash::Warnings::const_iterator it = report.warnings.begin(); it != report.warnings.end(); ++it) {
         PrintAnnotation("warning:", *it);
     }
 }
@@ -129,10 +129,10 @@ int main(int argc, const char *argv[])
 
     // Parse
     snowcrash::BlueprintParserOptions options = 0;  // Or snowcrash::RequireBlueprintNameOption
-    snowcrash::Result result;
+    snowcrash::Report report;
     snowcrash::Blueprint blueprint;
-    snowcrash::parse(inputStream.str(), options, result, blueprint);
-    
+    snowcrash::parse(inputStream.str(), options, report, blueprint);
+
     // Output
     if (!argumentParser.exist(ValidateArgument)) {
         
@@ -163,8 +163,8 @@ int main(int argc, const char *argv[])
             std::cout << outputStream.rdbuf();
         }
     }
-    
-    // Result
-    PrintResult(result);
-    return result.error.code;
+
+    // report
+    PrintReport(report);
+    return report.error.code;
 }

data/ext/snowcrash/tools/homebrew/snowcrash.rb

@@ -2,10 +2,11 @@ require 'formula'
 
 class Snowcrash < Formula
   homepage 'http://apiblueprint.org'
-  head 'https://github.com/apiaryio/snowcrash.git', :tag => 'v0.12.1'
+  head 'https://github.com/apiaryio/snowcrash.git', :tag => 'v0.14.0'
 
   def install
     system "./configure"
-    system "make", "install"
+    system "make", "snowcrash"
+    bin.install Dir["bin/snowcrash"]
   end
 end

data/ext/snowcrash/vcbuild.bat

@@ -36,6 +36,7 @@ if /i "%1"=="noprojgen"     set noprojgen=1&goto arg-ok
 if /i "%1"=="nobuild"       set nobuild=1&goto arg-ok
 if /i "%1"=="test"          set test=test&goto arg-ok
 if /i "%1"=="inttest"       set inttest=1&goto arg-ok
+if /i "%1"=="MSVC2013"      set GYP_MSVS_VERSION=2013&goto arg-ok
 if /i "%1"=="MSVC2012"      set GYP_MSVS_VERSION=2012&goto arg-ok
 if /i "%1"=="MSVC2010"      set GYP_MSVS_VERSION=2010&goto arg-ok
 if /i "%1"=="MSVC2008"      set GYP_MSVS_VERSION=2008&goto arg-ok
@@ -56,7 +57,7 @@ if "%GYP_MSVS_VERSION%"=="" set GYP_MSVS_VERSION=2012
 
 @rem Generate the VS project.
 SETLOCAL
-  if defined VS100COMNTOOLS call "%VS100COMNTOOLS%\VCVarsQueryRegistry.bat"
+  if defined VS120COMNTOOLS call "%VS120COMNTOOLS%\VCVarsQueryRegistry.bat"
   if defined inttest python configure %debug_arg% --dest-cpu=%target_arch% --include-integration-tests
   if not defined inttest python configure %debug_arg% --dest-cpu=%target_arch%
   if errorlevel 1 goto create-msvs-files-failed
@@ -70,10 +71,18 @@ ENDLOCAL
 :msbuild
 @rem Skip project generation if requested.
 if defined nobuild goto exit
+if "%GYP_MSVS_VERSION%"=="2012" goto vc-set-2012
 if "%GYP_MSVS_VERSION%"=="2010" goto vc-set-2010
 if "%GYP_MSVS_VERSION%"=="2008" goto vc-set-2008
 
-@rem Look for Visual Studio 2012
+@rem Look for Visual Studio 2013
+if not defined VS120COMNTOOLS goto vc-set-2012
+if not exist "%VS120COMNTOOLS%\..\..\vc\vcvarsall.bat" goto vc-set-2012
+call "%VS120COMNTOOLS%\..\..\vc\vcvarsall.bat"
+if not defined VCINSTALLDIR goto msbuild-not-found
+goto msbuild-found
+
+:vc-set-2012
 if not defined VS110COMNTOOLS goto vc-set-2010
 if not exist "%VS110COMNTOOLS%\..\..\vc\vcvarsall.bat" goto vc-set-2010
 call "%VS110COMNTOOLS%\..\..\vc\vcvarsall.bat"
@@ -170,14 +179,14 @@ echo Failed to create vc project files.
 goto exit
 
 :help
-echo vcbuild.bat [debug/release] [test] [clean] [noprojgen] [nobuild] [x86/x64] [inttest] [MSVC2008/MSVC2010/MSVC2012]
+echo vcbuild.bat [debug/release] [test] [clean] [noprojgen] [nobuild] [x86/x64] [inttest] [MSVC2012/MSVC2013]
 echo Examples:
 echo   vcbuild.bat                : builds release build
 echo   vcbuild.bat nobuild        : generate MSVS project files only
 echo   vcbuild.bat debug          : builds debug build
 echo   vcbuild.bat test           : builds debug build and runs tests
 echo   vcbuild.bat inttest        : include integration tests
-echo   vcbuild.bat MSVC2012       : indicate target solution's version, could also define as MSVC2008 , MSVC2010 , MSVC2012
+echo   vcbuild.bat MSVC2013       : indicate target solution's version, could also define as MSVC2012, MSVC2013
 goto exit
 
 :exit

data/lib/redsnow.rb

@@ -14,18 +14,18 @@ module RedSnow
   # @return [ParseResult]
   def self.parse(rawBlueprint, options = 0)
     blueprint = FFI::MemoryPointer.new :pointer
-    result = FFI::MemoryPointer.new :pointer
-    ret = RedSnow::Binding.sc_c_parse(rawBlueprint, options, result, blueprint)
+    report = FFI::MemoryPointer.new :pointer
+    ret = RedSnow::Binding.sc_c_parse(rawBlueprint, options, report, blueprint)
 
     blueprint = blueprint.get_pointer(0)
-    result = result.get_pointer(0)
+    report = report.get_pointer(0)
 
-    parseResult = ParseResult.new(blueprint, result)
+    parseResult = ParseResult.new(blueprint, report)
 
     return parseResult
   ensure
     RedSnow::Binding.sc_blueprint_free(blueprint)
-    RedSnow::Binding.sc_result_free(result)
+    RedSnow::Binding.sc_report_free(report)
   end
 
 end

data/lib/redsnow/binding.rb

@@ -107,7 +107,7 @@ module RedSnow
     attach_function("sc_transaction_example_name", "sc_transaction_example_name", [ :pointer ], :string)
     attach_function("sc_transaction_example_description", "sc_transaction_example_description", [ :pointer ], :string)
 
-    attach_function("sc_result_free", "sc_result_free", [ :pointer ], :void)
+    attach_function("sc_report_free", "sc_report_free", [ :pointer ], :void)
 
     attach_function("sc_location_handler", "sc_location_handler", [ :pointer ], :pointer)
     attach_function("sc_location_size", "sc_location_size", [ :pointer ], :int)

data/lib/redsnow/blueprint.rb

@@ -78,9 +78,11 @@ module RedSnow
     # @param sc_metadata_collection_handle [FFI::Pointer]
     def initialize(sc_metadata_collection_handle)
       sc_metadata_collection_size = RedSnow::Binding.sc_metadata_collection_size(sc_metadata_collection_handle)
+
       if sc_metadata_collection_size > 0
         metadata_size = sc_metadata_collection_size - 1
         @collection = Array.new
+
         for index in 0..metadata_size do
           sc_metadata_handle = RedSnow::Binding.sc_metadata_handle(sc_metadata_collection_handle, index)
           @collection << Hash[:name => RedSnow::Binding.sc_metadata_key(sc_metadata_handle), :value => RedSnow::Binding.sc_metadata_value(sc_metadata_handle)]
@@ -96,18 +98,20 @@ module RedSnow
     # HTTP 'Content-Type' header
     CONTENT_TYPE_HEADER_KEY = :'Content-Type'
 
-
     # @return [String] the value of 'Content-type' header if present or nil
     def content_type
       content_type_header = @collection.detect { |header| header.has_key?(CONTENT_TYPE_HEADER_KEY) }
       return (content_type_header.nil?) ? nil : content_type_header[CONTENT_TYPE_HEADER_KEY]
     end
+
     # @param sc_header_collection_handle_payload [FFI::Pointer]
     def initialize(sc_header_collection_handle_payload)
       sc_header_collection_size = RedSnow::Binding.sc_header_collection_size(sc_header_collection_handle_payload)
+
       if sc_header_collection_size > 0
         headers_size = sc_header_collection_size - 1
         @collection = Array.new
+
         for index in 0..headers_size do
           sc_header_handle = RedSnow::Binding.sc_header_handle(sc_header_collection_handle_payload, index)
           @collection << Hash[:name => RedSnow::Binding.sc_header_key(sc_header_handle), :value => RedSnow::Binding.sc_header_value(sc_header_handle)]
@@ -142,10 +146,13 @@ module RedSnow
       @default_value = RedSnow::Binding.sc_parameter_default_value(sc_parameter_handle)
       @example_value = RedSnow::Binding.sc_parameter_example_value(sc_parameter_handle)
       @values = Array.new
+
       sc_value_collection_handle = RedSnow::Binding.sc_value_collection_handle(sc_parameter_handle)
       sc_value_collection_size = RedSnow::Binding.sc_value_collection_size(sc_value_collection_handle)
+
       if sc_value_collection_size > 0
         values_size = sc_value_collection_size - 1
+
         for valueIndex in 0..values_size do
           sc_value_handle = RedSnow::Binding.sc_value_handle(sc_value_collection_handle, valueIndex)
           value = RedSnow::Binding.sc_value_string(sc_value_handle)
@@ -163,12 +170,15 @@ module RedSnow
   class Parameters < BlueprintNode
 
     attr_accessor :collection
+
     # @param sc_parameter_collection_handle [FFI::Pointer]
     def initialize(sc_parameter_collection_handle)
       sc_parameter_collection_size = RedSnow::Binding.sc_parameter_collection_size(sc_parameter_collection_handle)
       @collection = Array.new
+
       if sc_parameter_collection_size > 0
         parameters_size = sc_parameter_collection_size - 1
+
         for index in 0..parameters_size do
           sc_parameter_handle = RedSnow::Binding.sc_parameter_handle(sc_parameter_collection_handle, index)
           parameter = Parameter.new(sc_parameter_handle)
@@ -193,6 +203,7 @@ module RedSnow
     attr_accessor :headers
     attr_accessor :body
     attr_accessor :schema
+
     # @param sc_payload_handle_resource [FFI::Pointer]
     def initialize(sc_payload_handle_resource)
       @name = RedSnow::Binding.sc_payload_name(sc_payload_handle_resource)
@@ -214,6 +225,7 @@ module RedSnow
 
     attr_accessor :requests
     attr_accessor :responses
+
     # @param sc_transaction_example_handle [FFI::Pointer]
     def initialize(sc_transaction_example_handle)
       @name  = RedSnow::Binding.sc_transaction_example_name(sc_transaction_example_handle)
@@ -222,25 +234,29 @@ module RedSnow
       @requests = Array.new
       sc_payload_collection_handle_requests = RedSnow::Binding.sc_payload_collection_handle_requests(sc_transaction_example_handle)
       sc_payload_collection_size_requests = RedSnow::Binding.sc_payload_collection_size(sc_payload_collection_handle_requests)
+
       if sc_payload_collection_size_requests > 0
         requests_size = sc_payload_collection_size_requests - 1
+
         for index in 0..requests_size do
           request = Payload.new(RedSnow::Binding.sc_payload_handle(sc_payload_collection_handle_requests, index))
           @requests << request
         end
       end
+
       # BP Resource Actions Examples Responses
       @responses = Array.new
       sc_payload_collection_handle_responses = RedSnow::Binding.sc_payload_collection_handle_responses(sc_transaction_example_handle)
       sc_payload_collection_size_responses = RedSnow::Binding.sc_payload_collection_size(sc_payload_collection_handle_responses)
+
       if sc_payload_collection_size_responses > 0
         responses_size = sc_payload_collection_size_responses - 1
+
         for index in 0..responses_size do
           response = Payload.new(RedSnow::Binding.sc_payload_handle(sc_payload_collection_handle_responses, index))
           @responses << response
         end
       end
-
     end
 
   end
@@ -256,6 +272,7 @@ module RedSnow
     attr_accessor :method
     attr_accessor :parameters
     attr_accessor :examples
+
     # @param sc_action_handle [FFI::Pointer]
     def initialize(sc_action_handle)
       @name = RedSnow::Binding.sc_action_name(sc_action_handle)
@@ -268,8 +285,10 @@ module RedSnow
       @examples = Array.new
       sc_transaction_example_collection_handle = RedSnow::Binding.sc_transaction_example_collection_handle(sc_action_handle)
       sc_transaction_example_collection_size = RedSnow::Binding.sc_transaction_example_collection_size(sc_transaction_example_collection_handle)
+
       if sc_transaction_example_collection_size > 0
         examples_size = sc_transaction_example_collection_size - 1
+
         for index in 0..examples_size do
           example = TransactionExample.new(RedSnow::Binding.sc_transaction_example_handle(sc_transaction_example_collection_handle, index))
           @examples << example
@@ -292,6 +311,7 @@ module RedSnow
     attr_accessor :model
     attr_accessor :parameters
     attr_accessor :actions
+
     # @param sc_resource_handle [FFI::Pointer]
     def initialize(sc_resource_handle)
       @name = RedSnow::Binding.sc_resource_name(sc_resource_handle)
@@ -304,12 +324,15 @@ module RedSnow
       @actions = Array.new
       sc_action_collection_handle = RedSnow::Binding.sc_action_collection_handle(sc_resource_handle)
       sc_action_collection_size = RedSnow::Binding.sc_action_collection_size(sc_action_collection_handle)
+
       if sc_action_collection_size > 0
         action_size = sc_action_collection_size - 1
+
         for index in 0..action_size do
           @actions << Action.new(RedSnow::Binding.sc_action_handle(sc_action_collection_handle, index))
         end
       end
+
       @parameters = Parameters.new(RedSnow::Binding.sc_parameter_collection_handle_resource(sc_resource_handle))
     end
 
@@ -322,6 +345,7 @@ module RedSnow
   class ResourceGroup < NamedBlueprintNode
 
     attr_accessor :resources
+
     # @param sc_resource_groups_handle [FFI::Pointer]
     def initialize(sc_resource_groups_handle)
       @name = RedSnow::Binding.sc_resource_groups_name(sc_resource_groups_handle)
@@ -330,8 +354,10 @@ module RedSnow
       @resources = Array.new
       sc_resource_collection_handle = RedSnow::Binding.sc_resource_collection_handle(sc_resource_groups_handle)
       sc_resource_collection_size = RedSnow::Binding.sc_resource_collection_size(sc_resource_collection_handle)
+
       if sc_resource_collection_size > 0
         resource_size = sc_resource_collection_size - 1
+
         for index in 0..resource_size do
           sc_resource_handle = RedSnow::Binding.sc_resource_handle(sc_resource_collection_handle, index)
           @resources << Resource.new(sc_resource_handle)
@@ -351,10 +377,13 @@ module RedSnow
 
     attr_accessor :metadata
     attr_accessor :resource_groups
+
     # Version key
     VERSION_KEY = :_version
+
     # Supported version of Api Blueprint
     SUPPORTED_VERSIONS = ["2.0"]
+
     # @param handle [FFI:Pointer]
     def initialize(handle)
       # BP name, desc
@@ -369,8 +398,10 @@ module RedSnow
       sc_resource_groups_collection_handle = RedSnow::Binding.sc_resource_groups_collection_handle(handle)
       sc_resource_groups_collection_size = RedSnow::Binding.sc_resource_groups_collection_size(sc_resource_groups_collection_handle)
       @resource_groups = Array.new
+
       if sc_resource_groups_collection_size > 0
         group_size = sc_resource_groups_collection_size - 1
+
         for index in 0..group_size do
           sc_resource_groups_handle = RedSnow::Binding.sc_resource_groups_handle(sc_resource_groups_collection_handle, index)
           @resource_groups << ResourceGroup.new(sc_resource_groups_handle)