zuora_connect_ui 0.8.1 → 0.8.2

data/vendor/ruby/2.6.0/gems/sassc-2.1.0-x86_64-linux/ext/libsass/src/fn_strings.cpp

@@ -0,0 +1,254 @@
+// sass.hpp must go before all system headers to get the
+// __EXTENSIONS__ fix on Solaris.
+#include "sass.hpp"
+
+#include <cctype>
+#include "utf8.h"
+#include "ast.hpp"
+#include "fn_utils.hpp"
+#include "fn_strings.hpp"
+
+namespace Sass {
+
+  namespace Functions {
+
+    void handle_utf8_error (const ParserState& pstate, Backtraces traces)
+    {
+      try {
+       throw;
+      }
+      catch (utf8::invalid_code_point&) {
+        std::string msg("utf8::invalid_code_point");
+        error(msg, pstate, traces);
+      }
+      catch (utf8::not_enough_room&) {
+        std::string msg("utf8::not_enough_room");
+        error(msg, pstate, traces);
+      }
+      catch (utf8::invalid_utf8&) {
+        std::string msg("utf8::invalid_utf8");
+        error(msg, pstate, traces);
+      }
+      catch (...) { throw; }
+    }
+
+    ///////////////////
+    // STRING FUNCTIONS
+    ///////////////////
+
+    Signature unquote_sig = "unquote($string)";
+    BUILT_IN(sass_unquote)
+    {
+      AST_Node_Obj arg = env["$string"];
+      if (String_Quoted* string_quoted = Cast<String_Quoted>(arg)) {
+        String_Constant* result = SASS_MEMORY_NEW(String_Constant, pstate, string_quoted->value());
+        // remember if the string was quoted (color tokens)
+        result->is_delayed(true); // delay colors
+        return result;
+      }
+      else if (String_Constant* str = Cast<String_Constant>(arg)) {
+        return str;
+      }
+      else if (Value* ex = Cast<Value>(arg)) {
+        Sass_Output_Style oldstyle = ctx.c_options.output_style;
+        ctx.c_options.output_style = SASS_STYLE_NESTED;
+        std::string val(arg->to_string(ctx.c_options));
+        val = Cast<Null>(arg) ? "null" : val;
+        ctx.c_options.output_style = oldstyle;
+
+        deprecated_function("Passing " + val + ", a non-string value, to unquote()", pstate);
+        return ex;
+      }
+      throw std::runtime_error("Invalid Data Type for unquote");
+    }
+
+    Signature quote_sig = "quote($string)";
+    BUILT_IN(sass_quote)
+    {
+      const String_Constant* s = ARG("$string", String_Constant);
+      String_Quoted *result = SASS_MEMORY_NEW(
+          String_Quoted, pstate, s->value(),
+          /*q=*/'\0', /*keep_utf8_escapes=*/false, /*skip_unquoting=*/true);
+      result->quote_mark('*');
+      return result;
+    }
+
+    Signature str_length_sig = "str-length($string)";
+    BUILT_IN(str_length)
+    {
+      size_t len = std::string::npos;
+      try {
+        String_Constant* s = ARG("$string", String_Constant);
+        len = UTF_8::code_point_count(s->value(), 0, s->value().size());
+
+      }
+      // handle any invalid utf8 errors
+      // other errors will be re-thrown
+      catch (...) { handle_utf8_error(pstate, traces); }
+      // return something even if we had an error (-1)
+      return SASS_MEMORY_NEW(Number, pstate, (double)len);
+    }
+
+    Signature str_insert_sig = "str-insert($string, $insert, $index)";
+    BUILT_IN(str_insert)
+    {
+      std::string str;
+      try {
+        String_Constant* s = ARG("$string", String_Constant);
+        str = s->value();
+        String_Constant* i = ARG("$insert", String_Constant);
+        std::string ins = i->value();
+        double index = ARGVAL("$index");
+        size_t len = UTF_8::code_point_count(str, 0, str.size());
+
+        if (index > 0 && index <= len) {
+          // positive and within string length
+          str.insert(UTF_8::offset_at_position(str, static_cast<size_t>(index) - 1), ins);
+        }
+        else if (index > len) {
+          // positive and past string length
+          str += ins;
+        }
+        else if (index == 0) {
+          str = ins + str;
+        }
+        else if (std::abs(index) <= len) {
+          // negative and within string length
+          index += len + 1;
+          str.insert(UTF_8::offset_at_position(str, static_cast<size_t>(index)), ins);
+        }
+        else {
+          // negative and past string length
+          str = ins + str;
+        }
+
+        if (String_Quoted* ss = Cast<String_Quoted>(s)) {
+          if (ss->quote_mark()) str = quote(str);
+        }
+      }
+      // handle any invalid utf8 errors
+      // other errors will be re-thrown
+      catch (...) { handle_utf8_error(pstate, traces); }
+      return SASS_MEMORY_NEW(String_Quoted, pstate, str);
+    }
+
+    Signature str_index_sig = "str-index($string, $substring)";
+    BUILT_IN(str_index)
+    {
+      size_t index = std::string::npos;
+      try {
+        String_Constant* s = ARG("$string", String_Constant);
+        String_Constant* t = ARG("$substring", String_Constant);
+        std::string str = s->value();
+        std::string substr = t->value();
+
+        size_t c_index = str.find(substr);
+        if(c_index == std::string::npos) {
+          return SASS_MEMORY_NEW(Null, pstate);
+        }
+        index = UTF_8::code_point_count(str, 0, c_index) + 1;
+      }
+      // handle any invalid utf8 errors
+      // other errors will be re-thrown
+      catch (...) { handle_utf8_error(pstate, traces); }
+      // return something even if we had an error (-1)
+      return SASS_MEMORY_NEW(Number, pstate, (double)index);
+    }
+
+    Signature str_slice_sig = "str-slice($string, $start-at, $end-at:-1)";
+    BUILT_IN(str_slice)
+    {
+      std::string newstr;
+      try {
+        String_Constant* s = ARG("$string", String_Constant);
+        double start_at = ARGVAL("$start-at");
+        double end_at = ARGVAL("$end-at");
+        String_Quoted* ss = Cast<String_Quoted>(s);
+
+        std::string str(s->value());
+
+        size_t size = utf8::distance(str.begin(), str.end());
+
+        if (!Cast<Number>(env["$end-at"])) {
+          end_at = -1;
+        }
+
+        if (end_at == 0 || (end_at + size) < 0) {
+          if (ss && ss->quote_mark()) newstr = quote("");
+          return SASS_MEMORY_NEW(String_Quoted, pstate, newstr);
+        }
+
+        if (end_at < 0) {
+          end_at += size + 1;
+          if (end_at == 0) end_at = 1;
+        }
+        if (end_at > size) { end_at = (double)size; }
+        if (start_at < 0) {
+          start_at += size + 1;
+          if (start_at < 0)  start_at = 0;
+        }
+        else if (start_at == 0) { ++ start_at; }
+
+        if (start_at <= end_at)
+        {
+          std::string::iterator start = str.begin();
+          utf8::advance(start, start_at - 1, str.end());
+          std::string::iterator end = start;
+          utf8::advance(end, end_at - start_at + 1, str.end());
+          newstr = std::string(start, end);
+        }
+        if (ss) {
+          if(ss->quote_mark()) newstr = quote(newstr);
+        }
+      }
+      // handle any invalid utf8 errors
+      // other errors will be re-thrown
+      catch (...) { handle_utf8_error(pstate, traces); }
+      return SASS_MEMORY_NEW(String_Quoted, pstate, newstr);
+    }
+
+    Signature to_upper_case_sig = "to-upper-case($string)";
+    BUILT_IN(to_upper_case)
+    {
+      String_Constant* s = ARG("$string", String_Constant);
+      std::string str = s->value();
+
+      for (size_t i = 0, L = str.length(); i < L; ++i) {
+        if (Sass::Util::isAscii(str[i])) {
+          str[i] = std::toupper(str[i]);
+        }
+      }
+
+      if (String_Quoted* ss = Cast<String_Quoted>(s)) {
+        String_Quoted* cpy = SASS_MEMORY_COPY(ss);
+        cpy->value(str);
+        return cpy;
+      } else {
+        return SASS_MEMORY_NEW(String_Quoted, pstate, str);
+      }
+    }
+
+    Signature to_lower_case_sig = "to-lower-case($string)";
+    BUILT_IN(to_lower_case)
+    {
+      String_Constant* s = ARG("$string", String_Constant);
+      std::string str = s->value();
+
+      for (size_t i = 0, L = str.length(); i < L; ++i) {
+        if (Sass::Util::isAscii(str[i])) {
+          str[i] = std::tolower(str[i]);
+        }
+      }
+
+      if (String_Quoted* ss = Cast<String_Quoted>(s)) {
+        String_Quoted* cpy = SASS_MEMORY_COPY(ss);
+        cpy->value(str);
+        return cpy;
+      } else {
+        return SASS_MEMORY_NEW(String_Quoted, pstate, str);
+      }
+    }
+
+  }
+
+}

data/vendor/ruby/2.6.0/gems/sassc-2.1.0-x86_64-linux/ext/libsass/src/fn_strings.hpp

@@ -0,0 +1,34 @@
+#ifndef SASS_FN_STRINGS_H
+#define SASS_FN_STRINGS_H
+
+#include "fn_utils.hpp"
+
+namespace Sass {
+
+  namespace Functions {
+
+    extern Signature unquote_sig;
+    extern Signature quote_sig;
+    extern Signature str_length_sig;
+    extern Signature str_insert_sig;
+    extern Signature str_index_sig;
+    extern Signature str_slice_sig;
+    extern Signature to_upper_case_sig;
+    extern Signature to_lower_case_sig;
+    extern Signature length_sig;
+
+    BUILT_IN(sass_unquote);
+    BUILT_IN(sass_quote);
+    BUILT_IN(str_length);
+    BUILT_IN(str_insert);
+    BUILT_IN(str_index);
+    BUILT_IN(str_slice);
+    BUILT_IN(to_upper_case);
+    BUILT_IN(to_lower_case);
+    BUILT_IN(length);
+
+  }
+
+}
+
+#endif

data/vendor/ruby/2.6.0/gems/sassc-2.1.0-x86_64-linux/ext/libsass/src/fn_utils.cpp

@@ -0,0 +1,156 @@
+// sass.hpp must go before all system headers to get the
+// __EXTENSIONS__ fix on Solaris.
+#include "sass.hpp"
+
+#include "parser.hpp"
+#include "fn_utils.hpp"
+#include "util_string.hpp"
+
+namespace Sass {
+
+  Definition* make_native_function(Signature sig, Native_Function func, Context& ctx)
+  {
+    Parser sig_parser = Parser::from_c_str(sig, ctx, ctx.traces, ParserState("[built-in function]"));
+    sig_parser.lex<Prelexer::identifier>();
+    std::string name(Util::normalize_underscores(sig_parser.lexed));
+    Parameters_Obj params = sig_parser.parse_parameters();
+    return SASS_MEMORY_NEW(Definition,
+                          ParserState("[built-in function]"),
+                          sig,
+                          name,
+                          params,
+                          func,
+                          false);
+  }
+
+  Definition* make_c_function(Sass_Function_Entry c_func, Context& ctx)
+  {
+    using namespace Prelexer;
+
+    const char* sig = sass_function_get_signature(c_func);
+    Parser sig_parser = Parser::from_c_str(sig, ctx, ctx.traces, ParserState("[c function]"));
+    // allow to overload generic callback plus @warn, @error and @debug with custom functions
+    sig_parser.lex < alternatives < identifier, exactly <'*'>,
+                                    exactly < Constants::warn_kwd >,
+                                    exactly < Constants::error_kwd >,
+                                    exactly < Constants::debug_kwd >
+                  >              >();
+    std::string name(Util::normalize_underscores(sig_parser.lexed));
+    Parameters_Obj params = sig_parser.parse_parameters();
+    return SASS_MEMORY_NEW(Definition,
+                          ParserState("[c function]"),
+                          sig,
+                          name,
+                          params,
+                          c_func);
+  }
+
+  namespace Functions {
+
+    std::string function_name(Signature sig)
+    {
+      std::string str(sig);
+      return str.substr(0, str.find('('));
+    }
+
+    Map* get_arg_m(const std::string& argname, Env& env, Signature sig, ParserState pstate, Backtraces traces)
+    {
+      AST_Node* value = env[argname];
+      if (Map* map = Cast<Map>(value)) return map;
+      List* list = Cast<List>(value);
+      if (list && list->length() == 0) {
+        return SASS_MEMORY_NEW(Map, pstate, 0);
+      }
+      return get_arg<Map>(argname, env, sig, pstate, traces);
+    }
+
+    double get_arg_r(const std::string& argname, Env& env, Signature sig, ParserState pstate, Backtraces traces, double lo, double hi)
+    {
+      Number* val = get_arg<Number>(argname, env, sig, pstate, traces);
+      Number tmpnr(val);
+      tmpnr.reduce();
+      double v = tmpnr.value();
+      if (!(lo <= v && v <= hi)) {
+        std::stringstream msg;
+        msg << "argument `" << argname << "` of `" << sig << "` must be between ";
+        msg << lo << " and " << hi;
+        error(msg.str(), pstate, traces);
+      }
+      return v;
+    }
+
+    Number* get_arg_n(const std::string& argname, Env& env, Signature sig, ParserState pstate, Backtraces traces)
+    {
+      Number* val = get_arg<Number>(argname, env, sig, pstate, traces);
+      val = SASS_MEMORY_COPY(val);
+      val->reduce();
+      return val;
+    }
+
+    double get_arg_val(const std::string& argname, Env& env, Signature sig, ParserState pstate, Backtraces traces)
+    {
+      Number* val = get_arg<Number>(argname, env, sig, pstate, traces);
+      Number tmpnr(val);
+      tmpnr.reduce();
+      return tmpnr.value();
+    }
+
+    double color_num(const std::string& argname, Env& env, Signature sig, ParserState pstate, Backtraces traces)
+    {
+      Number* val = get_arg<Number>(argname, env, sig, pstate, traces);
+      Number tmpnr(val);
+      tmpnr.reduce();
+      if (tmpnr.unit() == "%") {
+        return std::min(std::max(tmpnr.value() * 255 / 100.0, 0.0), 255.0);
+      } else {
+        return std::min(std::max(tmpnr.value(), 0.0), 255.0);
+      }
+    }
+
+    double alpha_num(const std::string& argname, Env& env, Signature sig, ParserState pstate, Backtraces traces) {
+      Number* val = get_arg<Number>(argname, env, sig, pstate, traces);
+      Number tmpnr(val);
+      tmpnr.reduce();
+      if (tmpnr.unit() == "%") {
+        return std::min(std::max(tmpnr.value(), 0.0), 100.0);
+      } else {
+        return std::min(std::max(tmpnr.value(), 0.0), 1.0);
+      }
+    }
+
+    Selector_List_Obj get_arg_sels(const std::string& argname, Env& env, Signature sig, ParserState pstate, Backtraces traces, Context& ctx) {
+      Expression_Obj exp = ARG(argname, Expression);
+      if (exp->concrete_type() == Expression::NULL_VAL) {
+        std::stringstream msg;
+        msg << argname << ": null is not a valid selector: it must be a string,\n";
+        msg << "a list of strings, or a list of lists of strings for `" << function_name(sig) << "'";
+        error(msg.str(), exp->pstate(), traces);
+      }
+      if (String_Constant* str = Cast<String_Constant>(exp)) {
+        str->quote_mark(0);
+      }
+      std::string exp_src = exp->to_string(ctx.c_options);
+      return Parser::parse_selector(exp_src.c_str(), ctx, traces, exp->pstate(), pstate.src, /*allow_parent=*/false);
+    }
+
+    Compound_Selector_Obj get_arg_sel(const std::string& argname, Env& env, Signature sig, ParserState pstate, Backtraces traces, Context& ctx) {
+      Expression_Obj exp = ARG(argname, Expression);
+      if (exp->concrete_type() == Expression::NULL_VAL) {
+        std::stringstream msg;
+        msg << argname << ": null is not a string for `" << function_name(sig) << "'";
+        error(msg.str(), exp->pstate(), traces);
+      }
+      if (String_Constant* str = Cast<String_Constant>(exp)) {
+        str->quote_mark(0);
+      }
+      std::string exp_src = exp->to_string(ctx.c_options);
+      Selector_List_Obj sel_list = Parser::parse_selector(exp_src.c_str(), ctx, traces, exp->pstate(), pstate.src, /*allow_parent=*/false);
+      if (sel_list->length() == 0) return {};
+      Complex_Selector_Obj first = sel_list->first();
+      if (!first->tail()) return first->head();
+      return first->tail()->head();
+    }
+
+  }
+
+}

data/vendor/ruby/2.6.0/gems/sassc-2.1.0-x86_64-linux/ext/libsass/src/fn_utils.hpp

@@ -0,0 +1,56 @@
+#ifndef SASS_FN_UTILS_H
+#define SASS_FN_UTILS_H
+#include "units.hpp"
+#include "backtrace.hpp"
+#include "environment.hpp"
+#include "ast_fwd_decl.hpp"
+#include "error_handling.hpp"
+
+namespace Sass {
+
+  #define FN_PROTOTYPE \
+    Env& env, \
+    Env& d_env, \
+    Context& ctx, \
+    Signature sig, \
+    ParserState pstate, \
+    Backtraces& traces, \
+    SelectorStack& selector_stack
+
+  typedef const char* Signature;
+  typedef PreValue* (*Native_Function)(FN_PROTOTYPE);
+  #define BUILT_IN(name) PreValue* name(FN_PROTOTYPE)
+
+  #define ARG(argname, argtype) get_arg<argtype>(argname, env, sig, pstate, traces)
+  // special function for weird hsla percent (10px == 10% == 10 != 0.1)
+  #define ARGVAL(argname) get_arg_val(argname, env, sig, pstate, traces) // double
+
+  Definition* make_native_function(Signature, Native_Function, Context& ctx);
+  Definition* make_c_function(Sass_Function_Entry c_func, Context& ctx);
+
+  namespace Functions {
+
+    template <typename T>
+    T* get_arg(const std::string& argname, Env& env, Signature sig, ParserState pstate, Backtraces traces)
+    {
+      T* val = Cast<T>(env[argname]);
+      if (!val) {
+        error("argument `" + argname + "` of `" + sig + "` must be a " + T::type_name(), pstate, traces);
+      }
+      return val;
+    }
+
+    Map* get_arg_m(const std::string& argname, Env& env, Signature sig, ParserState pstate, Backtraces traces); // maps only
+    Number* get_arg_n(const std::string& argname, Env& env, Signature sig, ParserState pstate, Backtraces traces); // numbers only
+    double alpha_num(const std::string& argname, Env& env, Signature sig, ParserState pstate, Backtraces traces); // colors only
+    double color_num(const std::string& argname, Env& env, Signature sig, ParserState pstate, Backtraces traces); // colors only
+    double get_arg_r(const std::string& argname, Env& env, Signature sig, ParserState pstate, Backtraces traces, double lo, double hi); // colors only
+    double get_arg_val(const std::string& argname, Env& env, Signature sig, ParserState pstate, Backtraces traces); // shared
+    Selector_List_Obj get_arg_sels(const std::string& argname, Env& env, Signature sig, ParserState pstate, Backtraces traces, Context& ctx); // selectors only
+    Compound_Selector_Obj get_arg_sel(const std::string& argname, Env& env, Signature sig, ParserState pstate, Backtraces traces, Context& ctx); // selectors only
+
+  }
+
+}
+
+#endif