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/operators.cpp

@@ -0,0 +1,266 @@
+// sass.hpp must go before all system headers to get the
+// __EXTENSIONS__ fix on Solaris.
+#include "sass.hpp"
+
+#include "operators.hpp"
+
+namespace Sass {
+
+  namespace Operators {
+
+    inline double add(double x, double y) { return x + y; }
+    inline double sub(double x, double y) { return x - y; }
+    inline double mul(double x, double y) { return x * y; }
+    inline double div(double x, double y) { return x / y; } // x/0 checked by caller
+
+    inline double mod(double x, double y) { // x/0 checked by caller
+      if ((x > 0 && y < 0) || (x < 0 && y > 0)) {
+        double ret = std::fmod(x, y);
+        return ret ? ret + y : ret;
+      } else {
+        return std::fmod(x, y);
+      }
+    }
+
+    typedef double (*bop)(double, double);
+    bop ops[Sass_OP::NUM_OPS] = {
+      0, 0, // and, or
+      0, 0, 0, 0, 0, 0, // eq, neq, gt, gte, lt, lte
+      add, sub, mul, div, mod
+    };
+
+    /* static function, has no pstate or traces */
+    bool eq(Expression_Obj lhs, Expression_Obj rhs)
+    {
+      // operation is undefined if one is not a number
+      if (!lhs || !rhs) throw Exception::UndefinedOperation(lhs, rhs, Sass_OP::EQ);
+      // use compare operator from ast node
+      return *lhs == *rhs;
+    }
+
+    /* static function, throws OperationError, has no pstate or traces */
+    bool cmp(Expression_Obj lhs, Expression_Obj rhs, const Sass_OP op)
+    {
+      // can only compare numbers!?
+      Number_Obj l = Cast<Number>(lhs);
+      Number_Obj r = Cast<Number>(rhs);
+      // operation is undefined if one is not a number
+      if (!l || !r) throw Exception::UndefinedOperation(lhs, rhs, op);
+      // use compare operator from ast node
+      return *l < *r;
+    }
+
+    /* static functions, throws OperationError, has no pstate or traces */
+    bool lt(Expression_Obj lhs, Expression_Obj rhs) { return cmp(lhs, rhs, Sass_OP::LT); }
+    bool neq(Expression_Obj lhs, Expression_Obj rhs) { return eq(lhs, rhs) == false; }
+    bool gt(Expression_Obj lhs, Expression_Obj rhs) { return !cmp(lhs, rhs, Sass_OP::GT) && neq(lhs, rhs); }
+    bool lte(Expression_Obj lhs, Expression_Obj rhs) { return cmp(lhs, rhs, Sass_OP::LTE) || eq(lhs, rhs); }
+    bool gte(Expression_Obj lhs, Expression_Obj rhs) { return !cmp(lhs, rhs, Sass_OP::GTE) || eq(lhs, rhs); }
+
+    /* colour math deprecation warning */
+    void op_color_deprecation(enum Sass_OP op, std::string lsh, std::string rhs, const ParserState& pstate)
+    {
+      deprecated(
+        "The operation `" + lsh + " " + sass_op_to_name(op) + " " + rhs +
+        "` is deprecated and will be an error in future versions.",
+        "Consider using Sass's color functions instead.\n"
+        "https://sass-lang.com/documentation/Sass/Script/Functions.html#other_color_functions",
+        /*with_column=*/false, pstate);
+    }
+
+    /* static function, throws OperationError, has no traces but optional pstate for returned value */
+    Value* op_strings(Sass::Operand operand, Value& lhs, Value& rhs, struct Sass_Inspect_Options opt, const ParserState& pstate, bool delayed)
+    {
+      enum Sass_OP op = operand.operand;
+
+      String_Quoted* lqstr = Cast<String_Quoted>(&lhs);
+      String_Quoted* rqstr = Cast<String_Quoted>(&rhs);
+
+      std::string lstr(lqstr ? lqstr->value() : lhs.to_string(opt));
+      std::string rstr(rqstr ? rqstr->value() : rhs.to_string(opt));
+
+      if (Cast<Null>(&lhs)) throw Exception::InvalidNullOperation(&lhs, &rhs, op);
+      if (Cast<Null>(&rhs)) throw Exception::InvalidNullOperation(&lhs, &rhs, op);
+
+      std::string sep;
+      switch (op) {
+        case Sass_OP::ADD: sep = "";   break;
+        case Sass_OP::SUB: sep = "-";  break;
+        case Sass_OP::DIV: sep = "/";  break;
+        case Sass_OP::EQ:  sep = "=="; break;
+        case Sass_OP::NEQ: sep = "!="; break;
+        case Sass_OP::LT:  sep = "<";  break;
+        case Sass_OP::GT:  sep = ">";  break;
+        case Sass_OP::LTE: sep = "<="; break;
+        case Sass_OP::GTE: sep = ">="; break;
+        default:
+          throw Exception::UndefinedOperation(&lhs, &rhs, op);
+        break;
+      }
+
+      if (op == Sass_OP::ADD) {
+        // create string that might be quoted on output (but do not unquote what we pass)
+        return SASS_MEMORY_NEW(String_Quoted, pstate, lstr + rstr, 0, false, true);
+      }
+
+      // add whitespace around operator
+      // but only if result is not delayed
+      if (sep != "" && delayed == false) {
+        if (operand.ws_before) sep = " " + sep;
+        if (operand.ws_after) sep = sep + " ";
+      }
+
+      if (op == Sass_OP::SUB || op == Sass_OP::DIV) {
+        if (lqstr && lqstr->quote_mark()) lstr = quote(lstr);
+        if (rqstr && rqstr->quote_mark()) rstr = quote(rstr);
+      }
+
+      return SASS_MEMORY_NEW(String_Constant, pstate, lstr + sep + rstr);
+    }
+
+    /* ToDo: allow to operate also with hsla colors */
+    /* static function, throws OperationError, has no traces but optional pstate for returned value */
+    Value* op_colors(enum Sass_OP op, const Color_RGBA& lhs, const Color_RGBA& rhs, struct Sass_Inspect_Options opt, const ParserState& pstate, bool delayed)
+    {
+
+      if (lhs.a() != rhs.a()) {
+        throw Exception::AlphaChannelsNotEqual(&lhs, &rhs, op);
+      }
+      if ((op == Sass_OP::DIV || op == Sass_OP::MOD) && (!rhs.r() || !rhs.g() || !rhs.b())) {
+        throw Exception::ZeroDivisionError(lhs, rhs);
+      }
+
+      op_color_deprecation(op, lhs.to_string(), rhs.to_string(), pstate);
+
+      return SASS_MEMORY_NEW(Color_RGBA,
+                             pstate,
+                             ops[op](lhs.r(), rhs.r()),
+                             ops[op](lhs.g(), rhs.g()),
+                             ops[op](lhs.b(), rhs.b()),
+                             lhs.a());
+    }
+
+    /* static function, throws OperationError, has no traces but optional pstate for returned value */
+    Value* op_numbers(enum Sass_OP op, const Number& lhs, const Number& rhs, struct Sass_Inspect_Options opt, const ParserState& pstate, bool delayed)
+    {
+      double lval = lhs.value();
+      double rval = rhs.value();
+
+      if (op == Sass_OP::MOD && rval == 0) {
+        return SASS_MEMORY_NEW(String_Quoted, pstate, "NaN");
+      }
+
+      if (op == Sass_OP::DIV && rval == 0) {
+        std::string result(lval ? "Infinity" : "NaN");
+        return SASS_MEMORY_NEW(String_Quoted, pstate, result);
+      }
+
+      size_t l_n_units = lhs.numerators.size();
+      size_t l_d_units = lhs.numerators.size();
+      size_t r_n_units = rhs.denominators.size();
+      size_t r_d_units = rhs.denominators.size();
+      // optimize out the most common and simplest case
+      if (l_n_units == r_n_units && l_d_units == r_d_units) {
+        if (l_n_units + l_d_units <= 1 && r_n_units + r_d_units <= 1) {
+          if (lhs.numerators == rhs.numerators) {
+            if (lhs.denominators == rhs.denominators) {
+              Number* v = SASS_MEMORY_COPY(&lhs);
+              v->value(ops[op](lval, rval));
+              return v;
+            }
+          }
+        }
+      }
+
+      Number_Obj v = SASS_MEMORY_COPY(&lhs);
+
+      if (lhs.is_unitless() && (op == Sass_OP::ADD || op == Sass_OP::SUB || op == Sass_OP::MOD)) {
+        v->numerators = rhs.numerators;
+        v->denominators = rhs.denominators;
+      }
+
+      if (op == Sass_OP::MUL) {
+        v->value(ops[op](lval, rval));
+        v->numerators.insert(v->numerators.end(),
+          rhs.numerators.begin(), rhs.numerators.end()
+        );
+        v->denominators.insert(v->denominators.end(),
+          rhs.denominators.begin(), rhs.denominators.end()
+        );
+        v->reduce();
+      }
+      else if (op == Sass_OP::DIV) {
+        v->value(ops[op](lval, rval));
+        v->numerators.insert(v->numerators.end(),
+          rhs.denominators.begin(), rhs.denominators.end()
+        );
+        v->denominators.insert(v->denominators.end(),
+          rhs.numerators.begin(), rhs.numerators.end()
+        );
+        v->reduce();
+      }
+      else {
+        Number ln(lhs), rn(rhs);
+        ln.reduce(); rn.reduce();
+        double f(rn.convert_factor(ln));
+        v->value(ops[op](lval, rn.value() * f));
+      }
+
+      v->pstate(pstate);
+      return v.detach();
+    }
+
+    /* static function, throws OperationError, has no traces but optional pstate for returned value */
+    Value* op_number_color(enum Sass_OP op, const Number& lhs, const Color_RGBA& rhs, struct Sass_Inspect_Options opt, const ParserState& pstate, bool delayed)
+    {
+      double lval = lhs.value();
+
+      switch (op) {
+        case Sass_OP::ADD:
+        case Sass_OP::MUL: {
+          op_color_deprecation(op, lhs.to_string(), rhs.to_string(opt), pstate);
+          return SASS_MEMORY_NEW(Color_RGBA,
+                                pstate,
+                                ops[op](lval, rhs.r()),
+                                ops[op](lval, rhs.g()),
+                                ops[op](lval, rhs.b()),
+                                rhs.a());
+        }
+        case Sass_OP::SUB:
+        case Sass_OP::DIV: {
+          std::string color(rhs.to_string(opt));
+          op_color_deprecation(op, lhs.to_string(), color, pstate);
+          return SASS_MEMORY_NEW(String_Quoted,
+                                pstate,
+                                lhs.to_string(opt)
+                                + sass_op_separator(op)
+                                + color);
+        }
+        default: break;
+      }
+      throw Exception::UndefinedOperation(&lhs, &rhs, op);
+    }
+
+    /* static function, throws OperationError, has no traces but optional pstate for returned value */
+    Value* op_color_number(enum Sass_OP op, const Color_RGBA& lhs, const Number& rhs, struct Sass_Inspect_Options opt, const ParserState& pstate, bool delayed)
+    {
+      double rval = rhs.value();
+
+      if ((op == Sass_OP::DIV || op == Sass_OP::DIV) && rval == 0) {
+        // comparison of Fixnum with Float failed?
+        throw Exception::ZeroDivisionError(lhs, rhs);
+      }
+
+      op_color_deprecation(op, lhs.to_string(), rhs.to_string(), pstate);
+
+      return SASS_MEMORY_NEW(Color_RGBA,
+                            pstate,
+                            ops[op](lhs.r(), rval),
+                            ops[op](lhs.g(), rval),
+                            ops[op](lhs.b(), rval),
+                            lhs.a());
+    }
+
+  }
+
+}

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

@@ -0,0 +1,30 @@
+#ifndef SASS_OPERATORS_H
+#define SASS_OPERATORS_H
+
+#include "values.hpp"
+#include "sass/values.h"
+
+namespace Sass {
+
+  namespace Operators {
+
+    // equality operator using AST Node operator==
+    bool eq(Expression_Obj, Expression_Obj);
+    bool neq(Expression_Obj, Expression_Obj);
+    // specific operators based on cmp and eq
+    bool lt(Expression_Obj, Expression_Obj);
+    bool gt(Expression_Obj, Expression_Obj);
+    bool lte(Expression_Obj, Expression_Obj);
+    bool gte(Expression_Obj, Expression_Obj);
+    // arithmetic for all the combinations that matter
+    Value* op_strings(Sass::Operand, Value&, Value&, struct Sass_Inspect_Options opt, const ParserState& pstate, bool delayed = false);
+    Value* op_colors(enum Sass_OP, const Color_RGBA&, const Color_RGBA&, struct Sass_Inspect_Options opt, const ParserState& pstate, bool delayed = false);
+    Value* op_numbers(enum Sass_OP, const Number&, const Number&, struct Sass_Inspect_Options opt, const ParserState& pstate, bool delayed = false);
+    Value* op_number_color(enum Sass_OP, const Number&, const Color_RGBA&, struct Sass_Inspect_Options opt, const ParserState& pstate, bool delayed = false);
+    Value* op_color_number(enum Sass_OP, const Color_RGBA&, const Number&, struct Sass_Inspect_Options opt, const ParserState& pstate, bool delayed = false);
+
+  };
+
+}
+
+#endif

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

@@ -0,0 +1,339 @@
+// sass.hpp must go before all system headers to get the
+// __EXTENSIONS__ fix on Solaris.
+#include "sass.hpp"
+
+#include "ast.hpp"
+#include "output.hpp"
+#include "util.hpp"
+
+namespace Sass {
+
+  Output::Output(Sass_Output_Options& opt)
+  : Inspect(Emitter(opt)),
+    charset(""),
+    top_nodes(0)
+  {}
+
+  Output::~Output() { }
+
+  void Output::fallback_impl(AST_Node* n)
+  {
+    return n->perform(this);
+  }
+
+  void Output::operator()(Number* n)
+  {
+    // check for a valid unit here
+    // includes result for reporting
+    if (!n->is_valid_css_unit()) {
+      // should be handle in check_expression
+      throw Exception::InvalidValue({}, *n);
+    }
+    // use values to_string facility
+    std::string res = n->to_string(opt);
+    // output the final token
+    append_token(res, n);
+  }
+
+  void Output::operator()(Import* imp)
+  {
+    top_nodes.push_back(imp);
+  }
+
+  void Output::operator()(Map* m)
+  {
+    // should be handle in check_expression
+    throw Exception::InvalidValue({}, *m);
+  }
+
+  OutputBuffer Output::get_buffer(void)
+  {
+
+    Emitter emitter(opt);
+    Inspect inspect(emitter);
+
+    size_t size_nodes = top_nodes.size();
+    for (size_t i = 0; i < size_nodes; i++) {
+      top_nodes[i]->perform(&inspect);
+      inspect.append_mandatory_linefeed();
+    }
+
+    // flush scheduled outputs
+    // maybe omit semicolon if possible
+    inspect.finalize(wbuf.buffer.size() == 0);
+    // prepend buffer on top
+    prepend_output(inspect.output());
+    // make sure we end with a linefeed
+    if (!ends_with(wbuf.buffer, opt.linefeed)) {
+      // if the output is not completely empty
+      if (!wbuf.buffer.empty()) append_string(opt.linefeed);
+    }
+
+    // search for unicode char
+    for(const char& chr : wbuf.buffer) {
+      // skip all ascii chars
+      // static cast to unsigned to handle `char` being signed / unsigned
+      if (static_cast<unsigned>(chr) < 128) continue;
+      // declare the charset
+      if (output_style() != COMPRESSED)
+        charset = "@charset \"UTF-8\";"
+                + std::string(opt.linefeed);
+      else charset = "\xEF\xBB\xBF";
+      // abort search
+      break;
+    }
+
+    // add charset as first line, before comments and imports
+    if (!charset.empty()) prepend_string(charset);
+
+    return wbuf;
+
+  }
+
+  void Output::operator()(Comment* c)
+  {
+    // if (indentation && txt == "/**/") return;
+    bool important = c->is_important();
+    if (output_style() != COMPRESSED || important) {
+      if (buffer().size() == 0) {
+        top_nodes.push_back(c);
+      } else {
+        in_comment = true;
+        append_indentation();
+        c->text()->perform(this);
+        in_comment = false;
+        if (indentation == 0) {
+          append_mandatory_linefeed();
+        } else {
+          append_optional_linefeed();
+        }
+      }
+    }
+  }
+
+  void Output::operator()(Ruleset* r)
+  {
+    Selector_Obj s     = r->selector();
+    Block_Obj    b     = r->block();
+
+    // Filter out rulesets that aren't printable (process its children though)
+    if (!Util::isPrintable(r, output_style())) {
+      for (size_t i = 0, L = b->length(); i < L; ++i) {
+        const Statement_Obj& stm = b->at(i);
+        if (Cast<Has_Block>(stm)) {
+          if (!Cast<Declaration>(stm)) {
+            stm->perform(this);
+          }
+        }
+      }
+      return;
+    }
+
+    if (output_style() == NESTED) indentation += r->tabs();
+    if (opt.source_comments) {
+      std::stringstream ss;
+      append_indentation();
+      std::string path(File::abs2rel(r->pstate().path));
+      ss << "/* line " << r->pstate().line + 1 << ", " << path << " */";
+      append_string(ss.str());
+      append_optional_linefeed();
+    }
+    scheduled_crutch = s;
+    if (s) s->perform(this);
+    append_scope_opener(b);
+    for (size_t i = 0, L = b->length(); i < L; ++i) {
+      Statement_Obj stm = b->at(i);
+      bool bPrintExpression = true;
+      // Check print conditions
+      if (Declaration* dec = Cast<Declaration>(stm)) {
+        if (String_Constant* valConst = Cast<String_Constant>(dec->value())) {
+          std::string val(valConst->value());
+          if (String_Quoted* qstr = Cast<String_Quoted>(valConst)) {
+            if (!qstr->quote_mark() && val.empty()) {
+              bPrintExpression = false;
+            }
+          }
+        }
+        else if (List* list = Cast<List>(dec->value())) {
+          bool all_invisible = true;
+          for (size_t list_i = 0, list_L = list->length(); list_i < list_L; ++list_i) {
+            Expression* item = list->at(list_i);
+            if (!item->is_invisible()) all_invisible = false;
+          }
+          if (all_invisible && !list->is_bracketed()) bPrintExpression = false;
+        }
+      }
+      // Print if OK
+      if (bPrintExpression) {
+        stm->perform(this);
+      }
+    }
+    if (output_style() == NESTED) indentation -= r->tabs();
+    append_scope_closer(b);
+
+  }
+  void Output::operator()(Keyframe_Rule* r)
+  {
+    Block_Obj b = r->block();
+    Selector_Obj v = r->name();
+
+    if (!v.isNull()) {
+      v->perform(this);
+    }
+
+    if (!b) {
+      append_colon_separator();
+      return;
+    }
+
+    append_scope_opener();
+    for (size_t i = 0, L = b->length(); i < L; ++i) {
+      Statement_Obj stm = b->at(i);
+      stm->perform(this);
+      if (i < L - 1) append_special_linefeed();
+    }
+    append_scope_closer();
+  }
+
+  void Output::operator()(Supports_Block* f)
+  {
+    if (f->is_invisible()) return;
+
+    Supports_Condition_Obj c = f->condition();
+    Block_Obj b              = f->block();
+
+    // Filter out feature blocks that aren't printable (process its children though)
+    if (!Util::isPrintable(f, output_style())) {
+      for (size_t i = 0, L = b->length(); i < L; ++i) {
+        Statement_Obj stm = b->at(i);
+        if (Cast<Has_Block>(stm)) {
+          stm->perform(this);
+        }
+      }
+      return;
+    }
+
+    if (output_style() == NESTED) indentation += f->tabs();
+    append_indentation();
+    append_token("@supports", f);
+    append_mandatory_space();
+    c->perform(this);
+    append_scope_opener();
+
+    for (size_t i = 0, L = b->length(); i < L; ++i) {
+      Statement_Obj stm = b->at(i);
+      stm->perform(this);
+      if (i < L - 1) append_special_linefeed();
+    }
+
+    if (output_style() == NESTED) indentation -= f->tabs();
+
+    append_scope_closer();
+
+  }
+
+  void Output::operator()(Media_Block* m)
+  {
+    if (m->is_invisible()) return;
+
+    Block_Obj b     = m->block();
+
+    // Filter out media blocks that aren't printable (process its children though)
+    if (!Util::isPrintable(m, output_style())) {
+      for (size_t i = 0, L = b->length(); i < L; ++i) {
+        Statement_Obj stm = b->at(i);
+        if (Cast<Has_Block>(stm)) {
+          stm->perform(this);
+        }
+      }
+      return;
+    }
+    if (output_style() == NESTED) indentation += m->tabs();
+    append_indentation();
+    append_token("@media", m);
+    append_mandatory_space();
+    in_media_block = true;
+    m->media_queries()->perform(this);
+    in_media_block = false;
+    append_scope_opener();
+
+    for (size_t i = 0, L = b->length(); i < L; ++i) {
+      if (b->at(i)) {
+      Statement_Obj stm = b->at(i);
+        stm->perform(this);
+      }
+      if (i < L - 1) append_special_linefeed();
+    }
+
+    if (output_style() == NESTED) indentation -= m->tabs();
+    append_scope_closer();
+  }
+
+  void Output::operator()(Directive* a)
+  {
+    std::string      kwd   = a->keyword();
+    Selector_Obj   s     = a->selector();
+    Expression_Obj v     = a->value();
+    Block_Obj      b     = a->block();
+
+    append_indentation();
+    append_token(kwd, a);
+    if (s) {
+      append_mandatory_space();
+      in_wrapped = true;
+      s->perform(this);
+      in_wrapped = false;
+    }
+    if (v) {
+      append_mandatory_space();
+      // ruby sass bug? should use options?
+      append_token(v->to_string(/* opt */), v);
+    }
+    if (!b) {
+      append_delimiter();
+      return;
+    }
+
+    if (b->is_invisible() || b->length() == 0) {
+      append_optional_space();
+      return append_string("{}");
+    }
+
+    append_scope_opener();
+
+    bool format = kwd != "@font-face";;
+
+    for (size_t i = 0, L = b->length(); i < L; ++i) {
+      Statement_Obj stm = b->at(i);
+      stm->perform(this);
+      if (i < L - 1 && format) append_special_linefeed();
+    }
+
+    append_scope_closer();
+  }
+
+  void Output::operator()(String_Quoted* s)
+  {
+    if (s->quote_mark()) {
+      append_token(quote(s->value(), s->quote_mark()), s);
+    } else if (!in_comment) {
+      append_token(string_to_output(s->value()), s);
+    } else {
+      append_token(s->value(), s);
+    }
+  }
+
+  void Output::operator()(String_Constant* s)
+  {
+    std::string value(s->value());
+    if (s->can_compress_whitespace() && output_style() == COMPRESSED) {
+      value.erase(std::remove_if(value.begin(), value.end(), ::isspace), value.end());
+    }
+    if (!in_comment && !in_custom_property) {
+      append_token(string_to_output(value), s);
+    } else {
+      append_token(value, s);
+    }
+  }
+
+}

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

@@ -0,0 +1,47 @@
+#ifndef SASS_OUTPUT_H
+#define SASS_OUTPUT_H
+
+#include <string>
+#include <vector>
+
+#include "util.hpp"
+#include "inspect.hpp"
+#include "operation.hpp"
+
+namespace Sass {
+  class Context;
+
+  class Output : public Inspect {
+  protected:
+    using Inspect::operator();
+
+  public:
+    Output(Sass_Output_Options& opt);
+    virtual ~Output();
+
+  protected:
+    std::string charset;
+    std::vector<AST_Node*> top_nodes;
+
+  public:
+    OutputBuffer get_buffer(void);
+
+    virtual void operator()(Map*);
+    virtual void operator()(Ruleset*);
+    virtual void operator()(Supports_Block*);
+    virtual void operator()(Media_Block*);
+    virtual void operator()(Directive*);
+    virtual void operator()(Keyframe_Rule*);
+    virtual void operator()(Import*);
+    virtual void operator()(Comment*);
+    virtual void operator()(Number*);
+    virtual void operator()(String_Quoted*);
+    virtual void operator()(String_Constant*);
+
+    void fallback_impl(AST_Node* n);
+
+  };
+
+}
+
+#endif