zuora_connect_ui 0.8.2 → 0.8.3

data/vendor/ruby/2.6.0/gems/sassc-2.2.0/ext/libsass/src/environment.hpp

@@ -0,0 +1,119 @@
+#ifndef SASS_ENVIRONMENT_H
+#define SASS_ENVIRONMENT_H
+
+#include <string>
+#include "ast_fwd_decl.hpp"
+#include "ast_def_macros.hpp"
+
+namespace Sass {
+
+  // this defeats the whole purpose of environment being templatable!!
+  typedef environment_map<std::string, AST_Node_Obj>::iterator EnvIter;
+
+  class EnvResult {
+    public:
+      EnvIter it;
+      bool found;
+    public:
+      EnvResult(EnvIter it, bool found)
+      : it(it), found(found) {}
+  };
+
+  template <typename T>
+  class Environment {
+    // TODO: test with map
+    environment_map<std::string, T> local_frame_;
+    ADD_PROPERTY(Environment*, parent)
+    ADD_PROPERTY(bool, is_shadow)
+
+  public:
+    Environment(bool is_shadow = false);
+    Environment(Environment* env, bool is_shadow = false);
+    Environment(Environment& env, bool is_shadow = false);
+
+    // link parent to create a stack
+    void link(Environment& env);
+    void link(Environment* env);
+
+    // this is used to find the global frame
+    // which is the second last on the stack
+    bool is_lexical() const;
+
+    // only match the real root scope
+    // there is still a parent around
+    // not sure what it is actually use for
+    // I guess we store functions etc. there
+    bool is_global() const;
+
+    // scope operates on the current frame
+
+    environment_map<std::string, T>& local_frame();
+
+    bool has_local(const std::string& key) const;
+
+    EnvResult find_local(const std::string& key);
+
+    T& get_local(const std::string& key);
+
+    // set variable on the current frame
+    void set_local(const std::string& key, const T& val);
+    void set_local(const std::string& key, T&& val);
+
+    void del_local(const std::string& key);
+
+    // global operates on the global frame
+    // which is the second last on the stack
+    Environment* global_env();
+    // get the env where the variable already exists
+    // if it does not yet exist, we return current env
+    Environment* lexical_env(const std::string& key);
+
+    bool has_global(const std::string& key);
+
+    T& get_global(const std::string& key);
+
+    // set a variable on the global frame
+    void set_global(const std::string& key, const T& val);
+    void set_global(const std::string& key, T&& val);
+
+    void del_global(const std::string& key);
+
+    // see if we have a lexical variable
+    // move down the stack but stop before we
+    // reach the global frame (is not included)
+    bool has_lexical(const std::string& key) const;
+
+    // see if we have a lexical we could update
+    // either update already existing lexical value
+    // or we create a new one on the current frame
+    void set_lexical(const std::string& key, T&& val);
+    void set_lexical(const std::string& key, const T& val);
+
+    // look on the full stack for key
+    // include all scopes available
+    bool has(const std::string& key) const;
+
+    // look on the full stack for key
+    // include all scopes available
+    T& get(const std::string& key);
+
+    // look on the full stack for key
+    // include all scopes available
+    EnvResult find(const std::string& key);
+
+    // use array access for getter and setter functions
+    T& operator[](const std::string& key);
+
+    #ifdef DEBUG
+    size_t print(std::string prefix = "");
+    #endif
+
+  };
+
+  // define typedef for our use case
+  typedef Environment<AST_Node_Obj> Env;
+  typedef std::vector<Env*> EnvStack;
+
+}
+
+#endif

data/vendor/ruby/2.6.0/gems/sassc-2.2.0/ext/libsass/src/error_handling.cpp

@@ -0,0 +1,212 @@
+// sass.hpp must go before all system headers to get the
+// __EXTENSIONS__ fix on Solaris.
+#include "sass.hpp"
+
+#include "ast.hpp"
+#include "prelexer.hpp"
+#include "backtrace.hpp"
+#include "error_handling.hpp"
+
+#include <iostream>
+
+namespace Sass {
+
+  namespace Exception {
+
+    Base::Base(ParserState pstate, std::string msg, Backtraces traces)
+    : std::runtime_error(msg), msg(msg),
+      prefix("Error"), pstate(pstate), traces(traces)
+    { }
+
+    InvalidSass::InvalidSass(ParserState pstate, Backtraces traces, std::string msg, char* owned_src)
+    : Base(pstate, msg, traces), owned_src(owned_src)
+    { }
+
+
+    InvalidParent::InvalidParent(Selector* parent, Backtraces traces, Selector* selector)
+    : Base(selector->pstate(), def_msg, traces), parent(parent), selector(selector)
+    {
+      msg = "Invalid parent selector for "
+        "\"" + selector->to_string(Sass_Inspect_Options()) + "\": "
+        "\"" + parent->to_string(Sass_Inspect_Options()) + "\"";
+    }
+
+    InvalidVarKwdType::InvalidVarKwdType(ParserState pstate, Backtraces traces, std::string name, const Argument* arg)
+    : Base(pstate, def_msg, traces), name(name), arg(arg)
+    {
+      msg = "Variable keyword argument map must have string keys.\n" +
+        name + " is not a string in " + arg->to_string() + ".";
+    }
+
+    InvalidArgumentType::InvalidArgumentType(ParserState pstate, Backtraces traces, std::string fn, std::string arg, std::string type, const Value* value)
+    : Base(pstate, def_msg, traces), fn(fn), arg(arg), type(type), value(value)
+    {
+      msg = arg + ": \"";
+      if (value) msg += value->to_string(Sass_Inspect_Options());
+      msg += "\" is not a " + type + " for `" + fn + "'";
+    }
+
+    MissingArgument::MissingArgument(ParserState pstate, Backtraces traces, std::string fn, std::string arg, std::string fntype)
+    : Base(pstate, def_msg, traces), fn(fn), arg(arg), fntype(fntype)
+    {
+      msg = fntype + " " + fn + " is missing argument " + arg + ".";
+    }
+
+    InvalidSyntax::InvalidSyntax(ParserState pstate, Backtraces traces, std::string msg)
+    : Base(pstate, msg, traces)
+    { }
+
+    NestingLimitError::NestingLimitError(ParserState pstate, Backtraces traces, std::string msg)
+    : Base(pstate, msg, traces)
+    { }
+
+    DuplicateKeyError::DuplicateKeyError(Backtraces traces, const Map& dup, const Expression& org)
+    : Base(org.pstate(), def_msg, traces), dup(dup), org(org)
+    {
+      msg = "Duplicate key " + dup.get_duplicate_key()->inspect() + " in map (" + org.inspect() + ").";
+    }
+
+    TypeMismatch::TypeMismatch(Backtraces traces, const Expression& var, const std::string type)
+    : Base(var.pstate(), def_msg, traces), var(var), type(type)
+    {
+      msg = var.to_string() + " is not an " + type + ".";
+    }
+
+    InvalidValue::InvalidValue(Backtraces traces, const Expression& val)
+    : Base(val.pstate(), def_msg, traces), val(val)
+    {
+      msg = val.to_string() + " isn't a valid CSS value.";
+    }
+
+    StackError::StackError(Backtraces traces, const AST_Node& node)
+    : Base(node.pstate(), def_msg, traces), node(node)
+    {
+      msg = "stack level too deep";
+    }
+
+    IncompatibleUnits::IncompatibleUnits(const Units& lhs, const Units& rhs)
+    {
+      msg = "Incompatible units: '" + rhs.unit() + "' and '" + lhs.unit() + "'.";
+    }
+
+    IncompatibleUnits::IncompatibleUnits(const UnitType lhs, const UnitType rhs)
+    {
+      msg = std::string("Incompatible units: '") + unit_to_string(rhs) + "' and '" + unit_to_string(lhs) + "'.";
+    }
+
+    AlphaChannelsNotEqual::AlphaChannelsNotEqual(const Expression* lhs, const Expression* rhs, enum Sass_OP op)
+    : OperationError(), lhs(lhs), rhs(rhs), op(op)
+    {
+      msg = "Alpha channels must be equal: " +
+        lhs->to_string({ NESTED, 5 }) +
+        " " + sass_op_to_name(op) + " " +
+        rhs->to_string({ NESTED, 5 }) + ".";
+    }
+
+    ZeroDivisionError::ZeroDivisionError(const Expression& lhs, const Expression& rhs)
+    : OperationError(), lhs(lhs), rhs(rhs)
+    {
+      msg = "divided by 0";
+    }
+
+    UndefinedOperation::UndefinedOperation(const Expression* lhs, const Expression* rhs, enum Sass_OP op)
+    : OperationError(), lhs(lhs), rhs(rhs), op(op)
+    {
+      msg = def_op_msg + ": \"" +
+        lhs->to_string({ NESTED, 5 }) +
+        " " + sass_op_to_name(op) + " " +
+        rhs->to_string({ TO_SASS, 5 }) +
+        "\".";
+    }
+
+    InvalidNullOperation::InvalidNullOperation(const Expression* lhs, const Expression* rhs, enum Sass_OP op)
+    : UndefinedOperation(lhs, rhs, op)
+    {
+      msg = def_op_null_msg + ": \"" + lhs->inspect() + " " + sass_op_to_name(op) + " " + rhs->inspect() + "\".";
+    }
+
+    SassValueError::SassValueError(Backtraces traces, ParserState pstate, OperationError& err)
+    : Base(pstate, err.what(), traces)
+    {
+      msg = err.what();
+      prefix = err.errtype();
+    }
+
+  }
+
+
+  void warn(std::string msg, ParserState pstate)
+  {
+    std::cerr << "Warning: " << msg << std::endl;
+  }
+
+  void warning(std::string msg, ParserState pstate)
+  {
+    std::string cwd(Sass::File::get_cwd());
+    std::string abs_path(Sass::File::rel2abs(pstate.path, cwd, cwd));
+    std::string rel_path(Sass::File::abs2rel(pstate.path, cwd, cwd));
+    std::string output_path(Sass::File::path_for_console(rel_path, abs_path, pstate.path));
+
+    std::cerr << "WARNING on line " << pstate.line+1 << ", column " << pstate.column+1 << " of " << output_path << ":" << std::endl;
+    std::cerr << msg << std::endl << std::endl;
+  }
+
+  void warn(std::string msg, ParserState pstate, Backtrace* bt)
+  {
+    warn(msg, pstate);
+  }
+
+  void deprecated_function(std::string msg, ParserState pstate)
+  {
+    std::string cwd(Sass::File::get_cwd());
+    std::string abs_path(Sass::File::rel2abs(pstate.path, cwd, cwd));
+    std::string rel_path(Sass::File::abs2rel(pstate.path, cwd, cwd));
+    std::string output_path(Sass::File::path_for_console(rel_path, abs_path, pstate.path));
+
+    std::cerr << "DEPRECATION WARNING: " << msg << std::endl;
+    std::cerr << "will be an error in future versions of Sass." << std::endl;
+    std::cerr << "        on line " << pstate.line+1 << " of " << output_path << std::endl;
+  }
+
+  void deprecated(std::string msg, std::string msg2, bool with_column, ParserState pstate)
+  {
+    std::string cwd(Sass::File::get_cwd());
+    std::string abs_path(Sass::File::rel2abs(pstate.path, cwd, cwd));
+    std::string rel_path(Sass::File::abs2rel(pstate.path, cwd, cwd));
+    std::string output_path(Sass::File::path_for_console(rel_path, pstate.path, pstate.path));
+
+    std::cerr << "DEPRECATION WARNING on line " << pstate.line + 1;
+    if (with_column) std::cerr << ", column " << pstate.column + pstate.offset.column + 1;
+    if (output_path.length()) std::cerr << " of " << output_path;
+    std::cerr << ":" << std::endl;
+    std::cerr << msg << std::endl;
+    if (msg2.length()) std::cerr << msg2 << std::endl;
+    std::cerr << std::endl;
+  }
+
+  void deprecated_bind(std::string msg, ParserState pstate)
+  {
+    std::string cwd(Sass::File::get_cwd());
+    std::string abs_path(Sass::File::rel2abs(pstate.path, cwd, cwd));
+    std::string rel_path(Sass::File::abs2rel(pstate.path, cwd, cwd));
+    std::string output_path(Sass::File::path_for_console(rel_path, abs_path, pstate.path));
+
+    std::cerr << "WARNING: " << msg << std::endl;
+    std::cerr << "        on line " << pstate.line+1 << " of " << output_path << std::endl;
+    std::cerr << "This will be an error in future versions of Sass." << std::endl;
+  }
+
+  // should be replaced with error with backtraces
+  void coreError(std::string msg, ParserState pstate)
+  {
+    Backtraces traces;
+    throw Exception::InvalidSyntax(pstate, traces, msg);
+  }
+
+  void error(std::string msg, ParserState pstate, Backtraces& traces)
+  {
+    traces.push_back(Backtrace(pstate));
+    throw Exception::InvalidSyntax(pstate, traces, msg);
+  }
+
+}

data/vendor/ruby/2.6.0/gems/sassc-2.2.0/ext/libsass/src/error_handling.hpp

@@ -0,0 +1,229 @@
+#ifndef SASS_ERROR_HANDLING_H
+#define SASS_ERROR_HANDLING_H
+
+#include <string>
+#include <sstream>
+#include <stdexcept>
+#include "units.hpp"
+#include "position.hpp"
+#include "backtrace.hpp"
+#include "ast_fwd_decl.hpp"
+#include "sass/functions.h"
+
+namespace Sass {
+
+  struct Backtrace;
+
+  namespace Exception {
+
+    const std::string def_msg = "Invalid sass detected";
+    const std::string def_op_msg = "Undefined operation";
+    const std::string def_op_null_msg = "Invalid null operation";
+    const std::string def_nesting_limit = "Code too deeply neested";
+
+    class Base : public std::runtime_error {
+      protected:
+        std::string msg;
+        std::string prefix;
+      public:
+        ParserState pstate;
+        Backtraces traces;
+      public:
+        Base(ParserState pstate, std::string msg, Backtraces traces);
+        virtual const char* errtype() const { return prefix.c_str(); }
+        virtual const char* what() const throw() { return msg.c_str(); }
+        virtual ~Base() throw() {};
+    };
+
+    class InvalidSass : public Base {
+      public:
+        InvalidSass(InvalidSass& other) : Base(other), owned_src(other.owned_src) {
+          // Assumes that `this` will outlive `other`.
+          other.owned_src = nullptr;
+        }
+
+        // Required because the copy constructor's argument is not const.
+        // Can't use `std::move` here because we build on Visual Studio 2013.
+        InvalidSass(InvalidSass &&other) : Base(other), owned_src(other.owned_src) {
+          other.owned_src = nullptr;
+        }
+
+        InvalidSass(ParserState pstate, Backtraces traces, std::string msg, char* owned_src = nullptr);
+        virtual ~InvalidSass() throw() { sass_free_memory(owned_src); };
+        char *owned_src;
+    };
+
+    class InvalidParent : public Base {
+      protected:
+        Selector* parent;
+        Selector* selector;
+      public:
+        InvalidParent(Selector* parent, Backtraces traces, Selector* selector);
+        virtual ~InvalidParent() throw() {};
+    };
+
+    class MissingArgument : public Base {
+      protected:
+        std::string fn;
+        std::string arg;
+        std::string fntype;
+      public:
+        MissingArgument(ParserState pstate, Backtraces traces, std::string fn, std::string arg, std::string fntype);
+        virtual ~MissingArgument() throw() {};
+    };
+
+    class InvalidArgumentType : public Base {
+      protected:
+        std::string fn;
+        std::string arg;
+        std::string type;
+        const Value* value;
+      public:
+        InvalidArgumentType(ParserState pstate, Backtraces traces, std::string fn, std::string arg, std::string type, const Value* value = 0);
+        virtual ~InvalidArgumentType() throw() {};
+    };
+
+    class InvalidVarKwdType : public Base {
+      protected:
+        std::string name;
+        const Argument* arg;
+      public:
+        InvalidVarKwdType(ParserState pstate, Backtraces traces, std::string name, const Argument* arg = 0);
+        virtual ~InvalidVarKwdType() throw() {};
+    };
+
+    class InvalidSyntax : public Base {
+      public:
+        InvalidSyntax(ParserState pstate, Backtraces traces, std::string msg);
+        virtual ~InvalidSyntax() throw() {};
+    };
+
+    class NestingLimitError : public Base {
+      public:
+        NestingLimitError(ParserState pstate, Backtraces traces, std::string msg = def_nesting_limit);
+        virtual ~NestingLimitError() throw() {};
+    };
+
+    class DuplicateKeyError : public Base {
+      protected:
+        const Map& dup;
+        const Expression& org;
+      public:
+        DuplicateKeyError(Backtraces traces, const Map& dup, const Expression& org);
+        virtual const char* errtype() const { return "Error"; }
+        virtual ~DuplicateKeyError() throw() {};
+    };
+
+    class TypeMismatch : public Base {
+      protected:
+        const Expression& var;
+        const std::string type;
+      public:
+        TypeMismatch(Backtraces traces, const Expression& var, const std::string type);
+        virtual const char* errtype() const { return "Error"; }
+        virtual ~TypeMismatch() throw() {};
+    };
+
+    class InvalidValue : public Base {
+      protected:
+        const Expression& val;
+      public:
+        InvalidValue(Backtraces traces, const Expression& val);
+        virtual const char* errtype() const { return "Error"; }
+        virtual ~InvalidValue() throw() {};
+    };
+
+    class StackError : public Base {
+      protected:
+        const AST_Node& node;
+      public:
+        StackError(Backtraces traces, const AST_Node& node);
+        virtual const char* errtype() const { return "SystemStackError"; }
+        virtual ~StackError() throw() {};
+    };
+
+    /* common virtual base class (has no pstate or trace) */
+    class OperationError : public std::runtime_error {
+      protected:
+        std::string msg;
+      public:
+        OperationError(std::string msg = def_op_msg)
+        : std::runtime_error(msg), msg(msg)
+        {};
+      public:
+        virtual const char* errtype() const { return "Error"; }
+        virtual const char* what() const throw() { return msg.c_str(); }
+        virtual ~OperationError() throw() {};
+    };
+
+    class ZeroDivisionError : public OperationError {
+      protected:
+        const Expression& lhs;
+        const Expression& rhs;
+      public:
+        ZeroDivisionError(const Expression& lhs, const Expression& rhs);
+        virtual const char* errtype() const { return "ZeroDivisionError"; }
+        virtual ~ZeroDivisionError() throw() {};
+    };
+
+    class IncompatibleUnits : public OperationError {
+      protected:
+        // const Sass::UnitType lhs;
+        // const Sass::UnitType rhs;
+      public:
+        IncompatibleUnits(const Units& lhs, const Units& rhs);
+        IncompatibleUnits(const UnitType lhs, const UnitType rhs);
+        virtual ~IncompatibleUnits() throw() {};
+    };
+
+    class UndefinedOperation : public OperationError {
+      protected:
+        const Expression* lhs;
+        const Expression* rhs;
+        const Sass_OP op;
+      public:
+        UndefinedOperation(const Expression* lhs, const Expression* rhs, enum Sass_OP op);
+        // virtual const char* errtype() const { return "Error"; }
+        virtual ~UndefinedOperation() throw() {};
+    };
+
+    class InvalidNullOperation : public UndefinedOperation {
+      public:
+        InvalidNullOperation(const Expression* lhs, const Expression* rhs, enum Sass_OP op);
+        virtual ~InvalidNullOperation() throw() {};
+    };
+
+    class AlphaChannelsNotEqual : public OperationError {
+      protected:
+        const Expression* lhs;
+        const Expression* rhs;
+        const Sass_OP op;
+      public:
+        AlphaChannelsNotEqual(const Expression* lhs, const Expression* rhs, enum Sass_OP op);
+        // virtual const char* errtype() const { return "Error"; }
+        virtual ~AlphaChannelsNotEqual() throw() {};
+    };
+
+    class SassValueError : public Base {
+      public:
+        SassValueError(Backtraces traces, ParserState pstate, OperationError& err);
+        virtual ~SassValueError() throw() {};
+    };
+
+  }
+
+  void warn(std::string msg, ParserState pstate);
+  void warn(std::string msg, ParserState pstate, Backtrace* bt);
+  void warning(std::string msg, ParserState pstate);
+
+  void deprecated_function(std::string msg, ParserState pstate);
+  void deprecated(std::string msg, std::string msg2, bool with_column, ParserState pstate);
+  void deprecated_bind(std::string msg, ParserState pstate);
+  // void deprecated(std::string msg, ParserState pstate, Backtrace* bt);
+
+  void coreError(std::string msg, ParserState pstate);
+  void error(std::string msg, ParserState pstate, Backtraces& traces);
+
+}
+
+#endif