redsnow 0.3.7 → 0.4.0

data/ext/drafter/ext/sos/Makefile

@@ -0,0 +1,57 @@
+# Default Shell
+SHELL = /bin/bash
+
+# Default build path
+BUILD_PATH = build
+
+# Flags
+CXXFLAGS = -g -O3 -fPIC -Wall -Werror -Wsign-compare
+LDFLAGS = -g -O3 -Wall -Werror
+
+# SOS source directory
+SRC_PATH = src
+
+# SOS test source directory
+TEST_SRC_PATH = test
+
+# SOS include paths
+INCLUDES = -I$(SRC_PATH)
+
+# Test include paths
+TEST_INCLUDES = $(INCLUDES) -I$(TEST_SRC_PATH) -Itest/ext/Catch/single_include
+
+# SOS objects
+LIB_SRC = $(SRC_PATH)/sos.cc
+LIB_OBJ = $(BUILD_PATH)/sos.o
+
+# SOS tests object
+TEST_SRC = $(TEST_SRC_PATH)/test-libsos.cc
+TEST_OBJ = $(BUILD_PATH)/test-libsos.o
+
+.PHONY: all
+all: libsos.a test-libsos
+
+libsos.a: $(LIB_OBJ)
+	$(AR) rcs $(BUILD_PATH)/libsos.a $^
+
+test-libsos: libsos.a $(TEST_OBJ)
+	$(CXX) $(TEST_OBJ) $(BUILD_PATH)/libsos.a $(LDFLAGS) -o $(BUILD_PATH)/$@
+
+.PHONY: test
+test: test-libsos
+	$(BUILD_PATH)/test-libsos
+
+.PHONY: clean
+clean:
+	$(RM) -r build
+
+$(BUILD_PATH)/%.o: $(SRC_PATH)/%.cc
+	$(CXX) $(CXXFLAGS) $(INCLUDES) -MP -MMD -c $< -o $@
+
+$(BUILD_PATH)/%.o: $(TEST_SRC_PATH)/%.cc
+	$(CXX) $(CXXFLAGS) $(TEST_INCLUDES) -MP -MMD -c $< -o $@	
+
+$(LIB_OBJ): | $(BUILD_PATH)
+
+$(BUILD_PATH):
+	mkdir -p $(BUILD_PATH)

data/ext/drafter/ext/sos/src/sos.cc

@@ -0,0 +1,200 @@
+//
+//  sos.cc
+//  sos
+//
+//  Created by Pavan Kumar Sunkara on 20/01/15.
+//  Copyright (c) 2015 Apiary Inc. All rights reserved.
+//
+
+#include "sos.h"
+
+sos::Base::Base(Base::Type type_)
+: type(type_)
+{
+    m_object.reset(::new KeyValues);
+    m_array.reset(::new Bases);
+}
+
+sos::Base::Base(const sos::Base& rhs)
+{
+    this->type = rhs.type;
+    this->str = rhs.str;
+    this->number = rhs.number;
+    this->boolean = rhs.boolean;
+    this->keys = rhs.keys;
+
+    this->m_object.reset(::new KeyValues(*rhs.m_object.get()));
+    this->m_array.reset(::new Bases(*rhs.m_array.get()));
+}
+
+sos::Base& sos::Base::operator=(const sos::Base &rhs)
+{
+    this->type = rhs.type;
+    this->str = rhs.str;
+    this->number = rhs.number;
+    this->boolean = rhs.boolean;
+    this->keys = rhs.keys;
+
+    this->m_object.reset(::new KeyValues(*rhs.m_object.get()));
+    this->m_array.reset(::new Bases(*rhs.m_array.get()));
+
+    return *this;
+}
+
+sos::KeyValues& sos::Base::object()
+{
+    if (!m_object.get())
+        throw "no object key-values set";
+
+    return *m_object;
+}
+
+const sos::KeyValues& sos::Base::object() const
+{
+    if (!m_object.get())
+        throw "no object key-values set";
+
+    return *m_object;
+}
+
+sos::Bases& sos::Base::array()
+{
+    if (!m_array.get())
+        throw "no array values set";
+
+    return *m_array;
+}
+
+const sos::Bases& sos::Base::array() const
+{
+    if (!m_array.get())
+        throw "no array values set";
+
+    return *m_array;
+}
+
+sos::Null::Null()
+: Base(NullType)
+{}
+
+sos::String::String(std::string str_)
+{
+    type = StringType;
+    str = str_;
+}
+
+sos::Number::Number(double number_)
+{
+    type = NumberType;
+    number = number_;
+}
+
+sos::Boolean::Boolean(bool boolean_)
+{
+    type = BooleanType;
+    boolean = boolean_;
+}
+
+sos::Array::Array()
+: Base(ArrayType)
+{}
+
+void sos::Array::push(const sos::Base& value)
+{
+    array().push_back(value);
+}
+
+void sos::Array::set(const size_t index, const sos::Base& value)
+{
+    if (array().size() <= index)
+        throw "not enough array values set";
+
+    array().at(index) = value;
+}
+
+bool sos::Array::empty()
+{
+    return array().empty();
+}
+
+sos::Object::Object()
+: Base(ObjectType)
+{}
+
+void sos::Object::set(const std::string& key, const sos::Base& value)
+{
+    if (std::find(keys.begin(), keys.end(), key) != keys.end())
+        throw "key already present in the object";
+
+    keys.push_back(key);
+    object().operator[](key) = value;
+}
+
+bool sos::Object::empty()
+{
+    return keys.empty();
+}
+
+sos::Serialize::Serialize()
+{}
+
+void sos::Serialize::process(const Base& root, std::ostream& os, size_t level)
+{
+    sos::Base::Type type = root.type;
+
+    switch (type) {
+
+        case Base::NullType:
+            null(os);
+            break;
+
+        case Base::StringType:
+            string(root.str, os);
+            break;
+
+        case Base::NumberType:
+            number(root.number, os);
+            break;
+
+        case Base::BooleanType:
+            boolean(root.boolean, os);
+            break;
+
+        case Base::ArrayType:
+            array(root, os, level);
+            break;
+
+        case Base::ObjectType:
+            object(root, os, level);
+            break;
+            
+        default:
+            break;
+    }
+}
+
+std::string sos::escapeNewlines(const std::string &input)
+{
+    size_t pos = 0;
+    std::string target(input);
+
+    while ((pos = target.find("\n", pos)) != std::string::npos) {
+        target.replace(pos, 1, "\\n");
+        pos += 2;
+    }
+
+    return target;
+}
+
+std::string sos::escapeDoubleQuotes(const std::string &input)
+{
+    size_t pos = 0;
+    std::string target(input);
+
+    while ((pos = target.find("\"", pos)) != std::string::npos) {
+        target.replace(pos, 1, "\\\"");
+        pos += 2;
+    }
+
+    return target;
+}

data/ext/drafter/ext/sos/src/sos.h

@@ -0,0 +1,179 @@
+//
+//  sos.h
+//  sos
+//
+//  Created by Pavan Kumar Sunkara on 10/01/15.
+//  Copyright (c) 2015 Apiary Inc. All rights reserved.
+//
+
+#ifndef SOS_H
+#define SOS_H
+
+#include <string>
+#include <vector>
+#include <map>
+#include <ostream>
+#include <algorithm>
+#include <memory>
+
+namespace sos {
+
+    /** Forward Declaration */
+    class Base;
+
+    /** Key-value pairs (object) */
+    typedef std::map<std::string, Base> KeyValues;
+
+    /** List of keys for object (for deterministic output) */
+    typedef std::vector<std::string> Keys;
+
+    /** Array of values */
+    typedef std::vector<Base> Bases;
+
+    /** Base class for values */
+    class Base {
+    public:
+
+        /** Enum for Type of the value */
+        enum Type {
+            UndefinedType = 0,
+            NullType,     // Null
+            StringType,   // A string
+            NumberType,   // A number
+            BooleanType,  // A boolean value
+            ArrayType,    // An array
+            ObjectType    // An object
+        };
+
+        /** Type of the value */
+        Type type;
+
+        /** String value */
+        std::string str;
+
+        /** Number value */
+        double number;
+
+        /** Boolean value */
+        bool boolean;
+
+        /** Object value */
+        KeyValues& object();
+        const KeyValues& object() const;
+
+        Keys keys;
+
+        /** Array value */
+        Bases& array();
+        const Bases& array() const;
+
+        /** Constructor */
+        Base(Type type_ = UndefinedType);
+
+        /** Copy constructor */
+        Base(const Base& rhs);
+
+        /** Assignment operator */
+        Base& operator=(const Base& rhs);
+
+        /** Destructor */
+        ~Base() {};
+
+    private:
+        std::auto_ptr<KeyValues> m_object;
+        std::auto_ptr<Bases> m_array;
+    };
+
+    class Null : public Base {
+    public:
+
+        /** Constructor */
+        Null();
+    };
+
+    class String : public Base {
+    public:
+
+        /** Constructor */
+        String(std::string string_ = "");
+    };
+
+    class Number : public Base {
+    public:
+
+        /** Constructor */
+        Number(double number_ = 0);
+    };
+
+    class Boolean : public Base {
+    public:
+
+        /** Constructor */
+        Boolean(bool boolean_ = false);
+    };
+
+    class Array : public Base {
+    public:
+
+        /** Constructor */
+        Array();
+
+        void push(const Base& value);
+        void set(const size_t index, const Base& value);
+
+        /** Check if empty */
+        bool empty();
+    };
+
+    class Object : public Base {
+    public:
+
+        /** Constructor */
+        Object();
+
+        void set(const std::string& key, const Base& value);
+
+        /** Check if empty */
+        bool empty();
+    };
+
+    /** Base class for serializers */
+    struct Serialize {
+
+        /** Constructor */
+        Serialize();
+
+        /** Destructor */
+        virtual ~Serialize() {};
+
+        /** Process the given value with the serializer logic */
+        void process(const Base& value, std::ostream& os, size_t level = 0);
+
+        virtual void null(std::ostream& os) = 0;
+        virtual void string(const std::string& value, std::ostream& os) = 0;
+        virtual void number(double value, std::ostream& os) = 0;
+        virtual void boolean(bool value, std::ostream& os) = 0;
+        virtual void array(const Base& value, std::ostream& os, size_t level) = 0;
+        virtual void object(const Base& value, std::ostream& os, size_t level) = 0;
+
+        virtual void indent(size_t level, std::ostream& os) = 0;
+    };
+
+    /**
+     *  \brief  Escape every double quote in input string.
+     *  \param  input   A string to escape its double quotes.
+     *  \return A new string with double quotes escaped.
+     */
+    std::string escapeDoubleQuotes(const std::string& input);
+
+    /**
+     *  \brief  Escape new lines in input string.
+     *  \param  input   A string to escape its new lines.
+     *  \return A new string with lines escaped.
+     *
+     *  This function replaces all occurences of "\n" with "\\n".
+     */
+    std::string escapeNewlines(const std::string& input);
+}
+
+#endif

data/ext/drafter/ext/sos/src/sosJSON.h

@@ -0,0 +1,105 @@
+//
+//  sosJSON.h
+//  sos
+//
+//  Created by Pavan Kumar Sunkara on 11/01/15.
+//  Copyright (c) 2015 Apiary Inc. All rights reserved.
+//
+
+#ifndef SOS_JSON_H
+#define SOS_JSON_H
+
+#include "sos.h"
+
+namespace sos {
+
+    struct SerializeJSON : public Serialize {
+
+        virtual void indent(size_t level, std::ostream& os) {
+
+            for (size_t i = 0; i < level; ++i) {
+                os << "  ";
+            }
+        }
+
+        virtual void null(std::ostream& os) {
+
+            os << "null";
+        }
+
+        virtual void string(const std::string& value, std::ostream& os) {
+
+            std::string normalized = escapeDoubleQuotes(value);
+            normalized = escapeNewlines(normalized);
+
+            os << "\"" << normalized << "\"";
+        }
+
+        virtual void number(double value, std::ostream& os) {
+
+            os << value;
+        }
+
+        virtual void boolean(bool value, std::ostream& os) {
+
+            os << (value ? "true" : "false");
+        }
+
+        virtual void array(const Base& value, std::ostream& os, size_t level) {
+
+            os << "[";
+
+            if (!value.array().empty()) {
+
+                os << "\n";
+                size_t i = 0;
+
+                for (Bases::const_iterator it = value.array().begin(); it != value.array().end(); ++i, ++it) {
+
+                    if (i > 0 && i < value.array().size()) {
+                        os << ",\n";
+                    }
+
+                    indent(level + 1, os);
+                    process(*it, os, level + 1);
+                }
+
+                os << "\n";
+                indent(level, os);
+            }
+
+            os << "]";
+        }
+
+        virtual void object(const Base& value, std::ostream& os, size_t level) {
+
+            os << "{";
+
+            if (!value.keys.empty()) {
+
+                os << "\n";
+                size_t i = 0;
+
+                for (Keys::const_iterator it = value.keys.begin(); it != value.keys.end(); ++i, ++it) {
+
+                    if (i > 0 && i < value.keys.size()) {
+                        os << ",\n";
+                    }
+
+                    indent(level + 1, os);
+                    string(*it, os);
+
+                    os << ": ";
+                    process(value.object().at(*it), os, level + 1);
+                }
+
+                os << "\n";
+                indent(level, os);
+            }
+
+            os << "}";
+        }
+    };
+}
+
+#endif