zuora_connect_ui 0.8.3 → 0.9.0

data/vendor/ruby/2.6.0/gems/sassc-2.2.1/ext/libsass/src/b64/cencode.h

@@ -0,0 +1,32 @@
+/*
+cencode.h - c header for a base64 encoding algorithm
+
+This is part of the libb64 project, and has been placed in the public domain.
+For details, see http://sourceforge.net/projects/libb64
+*/
+
+#ifndef BASE64_CENCODE_H
+#define BASE64_CENCODE_H
+
+typedef enum
+{
+  step_A, step_B, step_C
+} base64_encodestep;
+
+typedef struct
+{
+	base64_encodestep step;
+	char result;
+	int stepcount;
+} base64_encodestate;
+
+void base64_init_encodestate(base64_encodestate* state_in);
+
+char base64_encode_value(char value_in);
+
+int base64_encode_block(const char* plaintext_in, int length_in, char* code_out, base64_encodestate* state_in);
+
+int base64_encode_blockend(char* code_out, base64_encodestate* state_in);
+
+#endif /* BASE64_CENCODE_H */
+

data/vendor/ruby/2.6.0/gems/sassc-2.2.1/ext/libsass/src/b64/encode.h

@@ -0,0 +1,79 @@
+// :mode=c++:
+/*
+encode.h - c++ wrapper for a base64 encoding algorithm
+
+This is part of the libb64 project, and has been placed in the public domain.
+For details, see http://sourceforge.net/projects/libb64
+*/
+#ifndef BASE64_ENCODE_H
+#define BASE64_ENCODE_H
+
+#include <iostream>
+
+namespace base64
+{
+	extern "C"
+	{
+		#include "cencode.h"
+	}
+
+	struct encoder
+	{
+		base64_encodestate _state;
+		int _buffersize;
+
+		encoder(int buffersize_in = BUFFERSIZE)
+		: _buffersize(buffersize_in)
+		{
+			base64_init_encodestate(&_state);
+		}
+
+		int encode(char value_in)
+		{
+			return base64_encode_value(value_in);
+		}
+
+		int encode(const char* code_in, const int length_in, char* plaintext_out)
+		{
+			return base64_encode_block(code_in, length_in, plaintext_out, &_state);
+		}
+
+		int encode_end(char* plaintext_out)
+		{
+			return base64_encode_blockend(plaintext_out, &_state);
+		}
+
+		void encode(std::istream& istream_in, std::ostream& ostream_in)
+		{
+			base64_init_encodestate(&_state);
+			//
+			const int N = _buffersize;
+			char* plaintext = new char[N];
+			char* code = new char[2*N];
+			int plainlength;
+			int codelength;
+
+			do
+			{
+				istream_in.read(plaintext, N);
+				plainlength = static_cast<int>(istream_in.gcount());
+				//
+				codelength = encode(plaintext, plainlength, code);
+				ostream_in.write(code, codelength);
+			}
+			while (istream_in.good() && plainlength > 0);
+
+			codelength = encode_end(code);
+			ostream_in.write(code, codelength);
+			//
+			base64_init_encodestate(&_state);
+
+			delete [] code;
+			delete [] plaintext;
+		}
+	};
+
+} // namespace base64
+
+#endif // BASE64_ENCODE_H
+

data/vendor/ruby/2.6.0/gems/sassc-2.2.1/ext/libsass/src/backtrace.cpp

@@ -0,0 +1,50 @@
+#include "backtrace.hpp"
+
+namespace Sass {
+
+  const std::string traces_to_string(Backtraces traces, std::string indent) {
+
+    std::stringstream ss;
+    std::string cwd(File::get_cwd());
+
+    bool first = true;
+    size_t i_beg = traces.size() - 1;
+    size_t i_end = std::string::npos;
+    for (size_t i = i_beg; i != i_end; i --) {
+
+      const Backtrace& trace = traces[i];
+
+      // make path relative to the current directory
+      std::string rel_path(File::abs2rel(trace.pstate.path, cwd, cwd));
+
+      // skip functions on error cases (unsure why ruby sass does this)
+      // if (trace.caller.substr(0, 6) == ", in f") continue;
+
+      if (first) {
+        ss << indent;
+        ss << "on line ";
+        ss << trace.pstate.line + 1;
+        ss << ":";
+        ss << trace.pstate.column + 1;
+        ss << " of " << rel_path;
+        // ss << trace.caller;
+        first = false;
+      } else {
+        ss << trace.caller;
+        ss << std::endl;
+        ss << indent;
+        ss << "from line ";
+        ss << trace.pstate.line + 1;
+        ss << ":";
+        ss << trace.pstate.column + 1;
+        ss << " of " << rel_path;
+      }
+
+    }
+
+    ss << std::endl;
+    return ss.str();
+
+  }
+
+};

data/vendor/ruby/2.6.0/gems/sassc-2.2.1/ext/libsass/src/backtrace.hpp

@@ -0,0 +1,29 @@
+#ifndef SASS_BACKTRACE_H
+#define SASS_BACKTRACE_H
+
+#include <vector>
+#include <sstream>
+#include "file.hpp"
+#include "position.hpp"
+
+namespace Sass {
+
+  struct Backtrace {
+
+    ParserState pstate;
+    std::string caller;
+
+    Backtrace(ParserState pstate, std::string c = "")
+    : pstate(pstate),
+      caller(c)
+    { }
+
+  };
+
+  typedef std::vector<Backtrace> Backtraces;
+
+  const std::string traces_to_string(Backtraces traces, std::string indent = "\t");
+
+}
+
+#endif

data/vendor/ruby/2.6.0/gems/sassc-2.2.1/ext/libsass/src/base64vlq.cpp

@@ -0,0 +1,47 @@
+// sass.hpp must go before all system headers to get the
+// __EXTENSIONS__ fix on Solaris.
+#include "sass.hpp"
+
+#include "base64vlq.hpp"
+
+namespace Sass {
+
+  std::string Base64VLQ::encode(const int number) const
+  {
+    std::string encoded = "";
+
+    int vlq = to_vlq_signed(number);
+
+    do {
+      int digit = vlq & VLQ_BASE_MASK;
+      vlq >>= VLQ_BASE_SHIFT;
+      if (vlq > 0) {
+        digit |= VLQ_CONTINUATION_BIT;
+      }
+      encoded += base64_encode(digit);
+    } while (vlq > 0);
+
+    return encoded;
+  }
+
+  char Base64VLQ::base64_encode(const int number) const
+  {
+    int index = number;
+    if (index < 0) index = 0;
+    if (index > 63) index = 63;
+    return CHARACTERS[index];
+  }
+
+  int Base64VLQ::to_vlq_signed(const int number) const
+  {
+    return (number < 0) ? ((-number) << 1) + 1 : (number << 1) + 0;
+  }
+
+  const char* Base64VLQ::CHARACTERS = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+
+  const int Base64VLQ::VLQ_BASE_SHIFT = 5;
+  const int Base64VLQ::VLQ_BASE = 1 << VLQ_BASE_SHIFT;
+  const int Base64VLQ::VLQ_BASE_MASK = VLQ_BASE - 1;
+  const int Base64VLQ::VLQ_CONTINUATION_BIT = VLQ_BASE;
+
+}

data/vendor/ruby/2.6.0/gems/sassc-2.2.1/ext/libsass/src/base64vlq.hpp

@@ -0,0 +1,30 @@
+#ifndef SASS_BASE64VLQ_H
+#define SASS_BASE64VLQ_H
+
+#include <string>
+
+namespace Sass {
+
+  class Base64VLQ {
+
+  public:
+
+    std::string encode(const int number) const;
+
+  private:
+
+    char base64_encode(const int number) const;
+
+    int to_vlq_signed(const int number) const;
+
+    static const char* CHARACTERS;
+
+    static const int VLQ_BASE_SHIFT;
+    static const int VLQ_BASE;
+    static const int VLQ_BASE_MASK;
+    static const int VLQ_CONTINUATION_BIT;
+  };
+
+}
+
+#endif

data/vendor/ruby/2.6.0/gems/sassc-2.2.1/ext/libsass/src/bind.cpp

@@ -0,0 +1,312 @@
+#include "sass.hpp"
+#include "bind.hpp"
+#include "ast.hpp"
+#include "backtrace.hpp"
+#include "context.hpp"
+#include "expand.hpp"
+#include "eval.hpp"
+#include <map>
+#include <iostream>
+#include <sstream>
+
+namespace Sass {
+
+  void bind(std::string type, std::string name, Parameters_Obj ps, Arguments_Obj as, Env* env, Eval* eval, Backtraces& traces)
+  {
+    std::string callee(type + " " + name);
+
+    std::map<std::string, Parameter_Obj> param_map;
+    List_Obj varargs = SASS_MEMORY_NEW(List, as->pstate());
+    varargs->is_arglist(true); // enable keyword size handling
+
+    for (size_t i = 0, L = as->length(); i < L; ++i) {
+      if (auto str = Cast<String_Quoted>((*as)[i]->value())) {
+        // force optional quotes (only if needed)
+        if (str->quote_mark()) {
+          str->quote_mark('*');
+        }
+      }
+    }
+
+    // Set up a map to ensure named arguments refer to actual parameters. Also
+    // eval each default value left-to-right, wrt env, populating env as we go.
+    for (size_t i = 0, L = ps->length(); i < L; ++i) {
+      Parameter_Obj  p = ps->at(i);
+      param_map[p->name()] = p;
+      // if (p->default_value()) {
+      //   env->local_frame()[p->name()] = p->default_value()->perform(eval->with(env));
+      // }
+    }
+
+    // plug in all args; if we have leftover params, deal with it later
+    size_t ip = 0, LP = ps->length();
+    size_t ia = 0, LA = as->length();
+    while (ia < LA) {
+      Argument_Obj a = as->at(ia);
+      if (ip >= LP) {
+        // skip empty rest arguments
+        if (a->is_rest_argument()) {
+          if (List_Obj l = Cast<List>(a->value())) {
+            if (l->length() == 0) {
+              ++ ia; continue;
+            }
+          }
+        }
+        std::stringstream msg;
+        msg << "wrong number of arguments (" << LA << " for " << LP << ")";
+        msg << " for `" << name << "'";
+        return error(msg.str(), as->pstate(), traces);
+      }
+      Parameter_Obj p = ps->at(ip);
+
+      // If the current parameter is the rest parameter, process and break the loop
+      if (p->is_rest_parameter()) {
+        // The next argument by coincidence provides a rest argument
+        if (a->is_rest_argument()) {
+
+          // We should always get a list for rest arguments
+          if (List_Obj rest = Cast<List>(a->value())) {
+              // create a new list object for wrapped items
+              List* arglist = SASS_MEMORY_NEW(List,
+                                              p->pstate(),
+                                              0,
+                                              rest->separator(),
+                                              true);
+              // wrap each item from list as an argument
+              for (Expression_Obj item : rest->elements()) {
+                if (Argument_Obj arg = Cast<Argument>(item)) {
+                  arglist->append(SASS_MEMORY_COPY(arg)); // copy
+                } else {
+                  arglist->append(SASS_MEMORY_NEW(Argument,
+                                                  item->pstate(),
+                                                  item,
+                                                  "",
+                                                  false,
+                                                  false));
+                }
+              }
+              // assign new arglist to environment
+              env->local_frame()[p->name()] = arglist;
+            }
+          // invalid state
+          else {
+            throw std::runtime_error("invalid state");
+          }
+        } else if (a->is_keyword_argument()) {
+
+          // expand keyword arguments into their parameters
+          List* arglist = SASS_MEMORY_NEW(List, p->pstate(), 0, SASS_COMMA, true);
+          env->local_frame()[p->name()] = arglist;
+          Map_Obj argmap = Cast<Map>(a->value());
+          for (auto key : argmap->keys()) {
+            if (String_Constant_Obj str = Cast<String_Constant>(key)) {
+              std::string param = unquote(str->value());
+              arglist->append(SASS_MEMORY_NEW(Argument,
+                                              key->pstate(),
+                                              argmap->at(key),
+                                              "$" + param,
+                                              false,
+                                              false));
+            } else {
+              traces.push_back(Backtrace(key->pstate()));
+              throw Exception::InvalidVarKwdType(key->pstate(), traces, key->inspect(), a);
+            }
+          }
+
+        } else {
+
+          // create a new list object for wrapped items
+          List_Obj arglist = SASS_MEMORY_NEW(List,
+                                          p->pstate(),
+                                          0,
+                                          SASS_COMMA,
+                                          true);
+          // consume the next args
+          while (ia < LA) {
+            // get and post inc
+            a = (*as)[ia++];
+            // maybe we have another list as argument
+            List_Obj ls = Cast<List>(a->value());
+            // skip any list completely if empty
+            if (ls && ls->empty() && a->is_rest_argument()) continue;
+
+            Expression_Obj value = a->value();
+            if (Argument_Obj arg = Cast<Argument>(value)) {
+              arglist->append(arg);
+            }
+            // check if we have rest argument
+            else if (a->is_rest_argument()) {
+              // preserve the list separator from rest args
+              if (List_Obj rest = Cast<List>(a->value())) {
+                arglist->separator(rest->separator());
+
+                for (size_t i = 0, L = rest->length(); i < L; ++i) {
+                  Expression_Obj obj = rest->value_at_index(i);
+                  arglist->append(SASS_MEMORY_NEW(Argument,
+                                                obj->pstate(),
+                                                obj,
+                                                "",
+                                                false,
+                                                false));
+                }
+              }
+              // no more arguments
+              break;
+            }
+            // wrap all other value types into Argument
+            else {
+              arglist->append(SASS_MEMORY_NEW(Argument,
+                                            a->pstate(),
+                                            a->value(),
+                                            a->name(),
+                                            false,
+                                            false));
+            }
+          }
+          // assign new arglist to environment
+          env->local_frame()[p->name()] = arglist;
+        }
+        // consumed parameter
+        ++ip;
+        // no more paramaters
+        break;
+      }
+
+      // If the current argument is the rest argument, extract a value for processing
+      else if (a->is_rest_argument()) {
+        // normal param and rest arg
+        List_Obj arglist = Cast<List>(a->value());
+        if (!arglist) {
+          if (Expression_Obj arg = Cast<Expression>(a->value())) {
+            arglist = SASS_MEMORY_NEW(List, a->pstate(), 1);
+            arglist->append(arg);
+          }
+        }
+
+        // empty rest arg - treat all args as default values
+        if (!arglist || !arglist->length()) {
+          break;
+        } else {
+          if (arglist->length() > LP - ip && !ps->has_rest_parameter()) {
+            size_t arg_count = (arglist->length() + LA - 1);
+            std::stringstream msg;
+            msg << callee << " takes " << LP;
+            msg << (LP == 1 ? " argument" : " arguments");
+            msg << " but " << arg_count;
+            msg << (arg_count == 1 ? " was passed" : " were passed.");
+            deprecated_bind(msg.str(), as->pstate());
+
+            while (arglist->length() > LP - ip) {
+              arglist->elements().erase(arglist->elements().end() - 1);
+            }
+          }
+        }
+        // otherwise move one of the rest args into the param, converting to argument if necessary
+        Expression_Obj obj = arglist->at(0);
+        if (!(a = Cast<Argument>(obj))) {
+          Expression* a_to_convert = obj;
+          a = SASS_MEMORY_NEW(Argument,
+                              a_to_convert->pstate(),
+                              a_to_convert,
+                              "",
+                              false,
+                              false);
+        }
+        arglist->elements().erase(arglist->elements().begin());
+        if (!arglist->length() || (!arglist->is_arglist() && ip + 1 == LP)) {
+          ++ia;
+        }
+
+      } else if (a->is_keyword_argument()) {
+        Map_Obj argmap = Cast<Map>(a->value());
+
+        for (auto key : argmap->keys()) {
+          String_Constant* val = Cast<String_Constant>(key);
+          if (val == NULL) {
+            traces.push_back(Backtrace(key->pstate()));
+            throw Exception::InvalidVarKwdType(key->pstate(), traces, key->inspect(), a);
+          }
+          std::string param = "$" + unquote(val->value());
+
+          if (!param_map.count(param)) {
+            std::stringstream msg;
+            msg << callee << " has no parameter named " << param;
+            error(msg.str(), a->pstate(), traces);
+          }
+          env->local_frame()[param] = argmap->at(key);
+        }
+        ++ia;
+        continue;
+      } else {
+        ++ia;
+      }
+
+      if (a->name().empty()) {
+        if (env->has_local(p->name())) {
+          std::stringstream msg;
+          msg << "parameter " << p->name()
+          << " provided more than once in call to " << callee;
+          error(msg.str(), a->pstate(), traces);
+        }
+        // ordinal arg -- bind it to the next param
+        env->local_frame()[p->name()] = a->value();
+        ++ip;
+      }
+      else {
+        // named arg -- bind it to the appropriately named param
+        if (!param_map.count(a->name())) {
+          if (ps->has_rest_parameter()) {
+            varargs->append(a);
+          } else {
+            std::stringstream msg;
+            msg << callee << " has no parameter named " << a->name();
+            error(msg.str(), a->pstate(), traces);
+          }
+        }
+        if (param_map[a->name()]) {
+          if (param_map[a->name()]->is_rest_parameter()) {
+            std::stringstream msg;
+            msg << "argument " << a->name() << " of " << callee
+                << "cannot be used as named argument";
+            error(msg.str(), a->pstate(), traces);
+          }
+        }
+        if (env->has_local(a->name())) {
+          std::stringstream msg;
+          msg << "parameter " << p->name()
+              << "provided more than once in call to " << callee;
+          error(msg.str(), a->pstate(), traces);
+        }
+        env->local_frame()[a->name()] = a->value();
+      }
+    }
+    // EO while ia
+
+    // If we make it here, we're out of args but may have leftover params.
+    // That's only okay if they have default values, or were already bound by
+    // named arguments, or if it's a single rest-param.
+    for (size_t i = ip; i < LP; ++i) {
+      Parameter_Obj leftover = ps->at(i);
+      // cerr << "env for default params:" << endl;
+      // env->print();
+      // cerr << "********" << endl;
+      if (!env->has_local(leftover->name())) {
+        if (leftover->is_rest_parameter()) {
+          env->local_frame()[leftover->name()] = varargs;
+        }
+        else if (leftover->default_value()) {
+          Expression* dv = leftover->default_value()->perform(eval);
+          env->local_frame()[leftover->name()] = dv;
+        }
+        else {
+          // param is unbound and has no default value -- error
+          throw Exception::MissingArgument(as->pstate(), traces, name, leftover->name(), type);
+        }
+      }
+    }
+
+    return;
+  }
+
+
+}