zuora_connect_ui 0.8.2 → 0.8.3

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

@@ -0,0 +1,15 @@
+#ifndef SASS_BIND_H
+#define SASS_BIND_H
+
+#include <string>
+#include "backtrace.hpp"
+#include "environment.hpp"
+#include "ast_fwd_decl.hpp"
+
+namespace Sass {
+
+  void bind(std::string type, std::string name, Parameters_Obj, Arguments_Obj, Env*, Eval*, Backtraces& traces);
+
+}
+
+#endif

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

@@ -0,0 +1,64 @@
+#include "ast.hpp"
+#include "units.hpp"
+#include "position.hpp"
+#include "backtrace.hpp"
+#include "sass/values.h"
+#include "ast_fwd_decl.hpp"
+#include "error_handling.hpp"
+
+namespace Sass {
+
+  Value* c2ast(union Sass_Value* v, Backtraces traces, ParserState pstate)
+  {
+    using std::strlen;
+    using std::strcpy;
+    Value* e = NULL;
+    switch (sass_value_get_tag(v)) {
+      case SASS_BOOLEAN: {
+        e = SASS_MEMORY_NEW(Boolean, pstate, !!sass_boolean_get_value(v));
+      } break;
+      case SASS_NUMBER: {
+        e = SASS_MEMORY_NEW(Number, pstate, sass_number_get_value(v), sass_number_get_unit(v));
+      } break;
+      case SASS_COLOR: {
+        e = SASS_MEMORY_NEW(Color_RGBA, pstate, sass_color_get_r(v), sass_color_get_g(v), sass_color_get_b(v), sass_color_get_a(v));
+      } break;
+      case SASS_STRING: {
+        if (sass_string_is_quoted(v))
+          e = SASS_MEMORY_NEW(String_Quoted, pstate, sass_string_get_value(v));
+        else {
+          e = SASS_MEMORY_NEW(String_Constant, pstate, sass_string_get_value(v));
+        }
+      } break;
+      case SASS_LIST: {
+        List* l = SASS_MEMORY_NEW(List, pstate, sass_list_get_length(v), sass_list_get_separator(v));
+        for (size_t i = 0, L = sass_list_get_length(v); i < L; ++i) {
+          l->append(c2ast(sass_list_get_value(v, i), traces, pstate));
+        }
+        l->is_bracketed(sass_list_get_is_bracketed(v));
+        e = l;
+      } break;
+      case SASS_MAP: {
+        Map* m = SASS_MEMORY_NEW(Map, pstate);
+        for (size_t i = 0, L = sass_map_get_length(v); i < L; ++i) {
+          *m << std::make_pair(
+            c2ast(sass_map_get_key(v, i), traces, pstate),
+            c2ast(sass_map_get_value(v, i), traces, pstate));
+        }
+        e = m;
+      } break;
+      case SASS_NULL: {
+        e = SASS_MEMORY_NEW(Null, pstate);
+      } break;
+      case SASS_ERROR: {
+        error("Error in C function: " + std::string(sass_error_get_message(v)), pstate, traces);
+      } break;
+      case SASS_WARNING: {
+        error("Warning in C function: " + std::string(sass_warning_get_message(v)), pstate, traces);
+      } break;
+      default: break;
+    }
+    return e;
+  }
+
+}

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

@@ -0,0 +1,14 @@
+#ifndef SASS_C2AST_H
+#define SASS_C2AST_H
+
+#include "position.hpp"
+#include "backtrace.hpp"
+#include "ast_fwd_decl.hpp"
+
+namespace Sass {
+
+  Value* c2ast(union Sass_Value* v, Backtraces traces, ParserState pstate);
+
+}
+
+#endif

data/vendor/ruby/2.6.0/gems/sassc-2.2.0/ext/libsass/src/c99func.c

@@ -0,0 +1,54 @@
+/*
+  Copyright (C) 2011 Joseph A. Adams (joeyadams3.14159@gmail.com)
+  All rights reserved.
+
+  Permission is hereby granted, free of charge, to any person obtaining a copy
+  of this software and associated documentation files (the "Software"), to deal
+  in the Software without restriction, including without limitation the rights
+  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+  copies of the Software, and to permit persons to whom the Software is
+  furnished to do so, subject to the following conditions:
+
+  The above copyright notice and this permission notice shall be included in
+  all copies or substantial portions of the Software.
+
+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+  THE SOFTWARE.
+*/
+
+#if defined(_MSC_VER) && _MSC_VER < 1900
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdarg.h>
+
+static int c99_vsnprintf(char* str, size_t size, const char* format, va_list ap)
+{
+    int count = -1;
+
+    if (size != 0)
+        count = _vsnprintf_s(str, size, _TRUNCATE, format, ap);
+    if (count == -1)
+        count = _vscprintf(format, ap);
+
+    return count;
+}
+
+int snprintf(char* str, size_t size, const char* format, ...)
+{
+    int count;
+    va_list ap;
+
+    va_start(ap, format);
+    count = c99_vsnprintf(str, size, format, ap);
+    va_end(ap);
+
+    return count;
+}
+
+#endif

data/vendor/ruby/2.6.0/gems/sassc-2.2.0/ext/libsass/src/cencode.c

@@ -0,0 +1,108 @@
+/*
+cencoder.c - c source to a base64 encoding algorithm implementation
+
+This is part of the libb64 project, and has been placed in the public domain.
+For details, see http://sourceforge.net/projects/libb64
+*/
+
+#include "b64/cencode.h"
+
+void base64_init_encodestate(base64_encodestate* state_in)
+{
+	state_in->step = step_A;
+	state_in->result = 0;
+	state_in->stepcount = 0;
+}
+
+char base64_encode_value(char value_in)
+{
+	static const char* encoding = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+	if (value_in > 63) return '=';
+	return encoding[(int)value_in];
+}
+
+int base64_encode_block(const char* plaintext_in, int length_in, char* code_out, base64_encodestate* state_in)
+{
+	const char* plainchar = plaintext_in;
+	const char* const plaintextend = plaintext_in + length_in;
+	char* codechar = code_out;
+	char result;
+	char fragment;
+
+	result = state_in->result;
+
+	switch (state_in->step)
+	{
+		while (1)
+		{
+	case step_A:
+			if (plainchar == plaintextend)
+			{
+				state_in->result = result;
+				state_in->step = step_A;
+				return (int)(codechar - code_out);
+			}
+			fragment = *plainchar++;
+			result = (fragment & 0x0fc) >> 2;
+			*codechar++ = base64_encode_value(result);
+			result = (fragment & 0x003) << 4;
+			#ifndef _MSC_VER
+				/* fall through */
+			#endif
+	case step_B:
+			if (plainchar == plaintextend)
+			{
+				state_in->result = result;
+				state_in->step = step_B;
+				return (int)(codechar - code_out);
+			}
+			fragment = *plainchar++;
+			result |= (fragment & 0x0f0) >> 4;
+			*codechar++ = base64_encode_value(result);
+			result = (fragment & 0x00f) << 2;
+			#ifndef _MSC_VER
+				/* fall through */
+			#endif
+	case step_C:
+			if (plainchar == plaintextend)
+			{
+				state_in->result = result;
+				state_in->step = step_C;
+				return (int)(codechar - code_out);
+			}
+			fragment = *plainchar++;
+			result |= (fragment & 0x0c0) >> 6;
+			*codechar++ = base64_encode_value(result);
+			result  = (fragment & 0x03f) >> 0;
+			*codechar++ = base64_encode_value(result);
+
+			++(state_in->stepcount);
+		}
+	}
+	/* control should not reach here */
+	return (int)(codechar - code_out);
+}
+
+int base64_encode_blockend(char* code_out, base64_encodestate* state_in)
+{
+	char* codechar = code_out;
+
+	switch (state_in->step)
+	{
+	case step_B:
+		*codechar++ = base64_encode_value(state_in->result);
+		*codechar++ = '=';
+		*codechar++ = '=';
+		break;
+	case step_C:
+		*codechar++ = base64_encode_value(state_in->result);
+		*codechar++ = '=';
+		break;
+	case step_A:
+		break;
+	}
+	*codechar++ = '\n';
+
+	return (int)(codechar - code_out);
+}
+

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

@@ -0,0 +1,394 @@
+// sass.hpp must go before all system headers to get the
+// __EXTENSIONS__ fix on Solaris.
+#include "sass.hpp"
+
+#include <vector>
+
+#include "check_nesting.hpp"
+
+namespace Sass {
+
+  CheckNesting::CheckNesting()
+  : parents(std::vector<Statement*>()),
+    traces(std::vector<Backtrace>()),
+    parent(0), current_mixin_definition(0)
+  { }
+
+  void error(AST_Node* node, Backtraces traces, std::string msg) {
+    traces.push_back(Backtrace(node->pstate()));
+    throw Exception::InvalidSass(node->pstate(), traces, msg);
+  }
+
+  Statement* CheckNesting::visit_children(Statement* parent)
+  {
+    Statement* old_parent = this->parent;
+
+    if (At_Root_Block* root = Cast<At_Root_Block>(parent)) {
+      std::vector<Statement*> old_parents = this->parents;
+      std::vector<Statement*> new_parents;
+
+      for (size_t i = 0, L = this->parents.size(); i < L; i++) {
+        Statement* p = this->parents.at(i);
+        if (!root->exclude_node(p)) {
+          new_parents.push_back(p);
+        }
+      }
+      this->parents = new_parents;
+
+      for (size_t i = this->parents.size(); i > 0; i--) {
+        Statement* p = 0;
+        Statement* gp = 0;
+        if (i > 0) p = this->parents.at(i - 1);
+        if (i > 1) gp = this->parents.at(i - 2);
+
+        if (!this->is_transparent_parent(p, gp)) {
+          this->parent = p;
+          break;
+        }
+      }
+
+      At_Root_Block* ar = Cast<At_Root_Block>(parent);
+      Block* ret = ar->block();
+
+      if (ret != NULL) {
+        for (auto n : ret->elements()) {
+          n->perform(this);
+        }
+      }
+
+      this->parent = old_parent;
+      this->parents = old_parents;
+
+      return ret;
+    }
+
+    if (!this->is_transparent_parent(parent, old_parent)) {
+      this->parent = parent;
+    }
+
+    this->parents.push_back(parent);
+
+    Block* b = Cast<Block>(parent);
+
+    if (Trace* trace = Cast<Trace>(parent)) {
+      if (trace->type() == 'i') {
+        this->traces.push_back(Backtrace(trace->pstate()));
+      }
+    }
+
+    if (!b) {
+      if (Has_Block* bb = Cast<Has_Block>(parent)) {
+        b = bb->block();
+      }
+    }
+
+    if (b) {
+      for (auto n : b->elements()) {
+        n->perform(this);
+      }
+    }
+
+    this->parent = old_parent;
+    this->parents.pop_back();
+
+    if (Trace* trace = Cast<Trace>(parent)) {
+      if (trace->type() == 'i') {
+        this->traces.pop_back();
+      }
+    }
+
+    return b;
+  }
+
+
+  Statement* CheckNesting::operator()(Block* b)
+  {
+    return this->visit_children(b);
+  }
+
+  Statement* CheckNesting::operator()(Definition* n)
+  {
+    if (!this->should_visit(n)) return NULL;
+    if (!is_mixin(n)) {
+      visit_children(n);
+      return n;
+    }
+
+    Definition* old_mixin_definition = this->current_mixin_definition;
+    this->current_mixin_definition = n;
+
+    visit_children(n);
+
+    this->current_mixin_definition = old_mixin_definition;
+
+    return n;
+  }
+
+  Statement* CheckNesting::operator()(If* i)
+  {
+    this->visit_children(i);
+
+    if (Block* b = Cast<Block>(i->alternative())) {
+      for (auto n : b->elements()) n->perform(this);
+    }
+
+    return i;
+  }
+
+  bool CheckNesting::should_visit(Statement* node)
+  {
+    if (!this->parent) return true;
+
+    if (Cast<Content>(node))
+    { this->invalid_content_parent(this->parent, node); }
+
+    if (is_charset(node))
+    { this->invalid_charset_parent(this->parent, node); }
+
+    if (Cast<Extension>(node))
+    { this->invalid_extend_parent(this->parent, node); }
+
+    // if (Cast<Import>(node))
+    // { this->invalid_import_parent(this->parent); }
+
+    if (this->is_mixin(node))
+    { this->invalid_mixin_definition_parent(this->parent, node); }
+
+    if (this->is_function(node))
+    { this->invalid_function_parent(this->parent, node); }
+
+    if (this->is_function(this->parent))
+    { this->invalid_function_child(node); }
+
+    if (Declaration* d = Cast<Declaration>(node))
+    {
+      this->invalid_prop_parent(this->parent, node);
+      this->invalid_value_child(d->value());
+    }
+
+    if (Cast<Declaration>(this->parent))
+    { this->invalid_prop_child(node); }
+
+    if (Cast<Return>(node))
+    { this->invalid_return_parent(this->parent, node); }
+
+    return true;
+  }
+
+  void CheckNesting::invalid_content_parent(Statement* parent, AST_Node* node)
+  {
+    if (!this->current_mixin_definition) {
+      error(node, traces, "@content may only be used within a mixin.");
+    }
+  }
+
+  void CheckNesting::invalid_charset_parent(Statement* parent, AST_Node* node)
+  {
+    if (!(
+        is_root_node(parent)
+    )) {
+      error(node, traces, "@charset may only be used at the root of a document.");
+    }
+  }
+
+  void CheckNesting::invalid_extend_parent(Statement* parent, AST_Node* node)
+  {
+    if (!(
+        Cast<Ruleset>(parent) ||
+        Cast<Mixin_Call>(parent) ||
+        is_mixin(parent)
+    )) {
+      error(node, traces, "Extend directives may only be used within rules.");
+    }
+  }
+
+  // void CheckNesting::invalid_import_parent(Statement* parent, AST_Node* node)
+  // {
+  //   for (auto pp : this->parents) {
+  //     if (
+  //         Cast<Each>(pp) ||
+  //         Cast<For>(pp) ||
+  //         Cast<If>(pp) ||
+  //         Cast<While>(pp) ||
+  //         Cast<Trace>(pp) ||
+  //         Cast<Mixin_Call>(pp) ||
+  //         is_mixin(pp)
+  //     ) {
+  //       error(node, traces, "Import directives may not be defined within control directives or other mixins.");
+  //     }
+  //   }
+
+  //   if (this->is_root_node(parent)) {
+  //     return;
+  //   }
+
+  //   if (false/*n.css_import?*/) {
+  //     error(node, traces, "CSS import directives may only be used at the root of a document.");
+  //   }
+  // }
+
+  void CheckNesting::invalid_mixin_definition_parent(Statement* parent, AST_Node* node)
+  {
+    for (Statement* pp : this->parents) {
+      if (
+          Cast<Each>(pp) ||
+          Cast<For>(pp) ||
+          Cast<If>(pp) ||
+          Cast<While>(pp) ||
+          Cast<Trace>(pp) ||
+          Cast<Mixin_Call>(pp) ||
+          is_mixin(pp)
+      ) {
+        error(node, traces, "Mixins may not be defined within control directives or other mixins.");
+      }
+    }
+  }
+
+  void CheckNesting::invalid_function_parent(Statement* parent, AST_Node* node)
+  {
+    for (Statement* pp : this->parents) {
+      if (
+          Cast<Each>(pp) ||
+          Cast<For>(pp) ||
+          Cast<If>(pp) ||
+          Cast<While>(pp) ||
+          Cast<Trace>(pp) ||
+          Cast<Mixin_Call>(pp) ||
+          is_mixin(pp)
+      ) {
+        error(node, traces, "Functions may not be defined within control directives or other mixins.");
+      }
+    }
+  }
+
+  void CheckNesting::invalid_function_child(Statement* child)
+  {
+    if (!(
+        Cast<Each>(child) ||
+        Cast<For>(child) ||
+        Cast<If>(child) ||
+        Cast<While>(child) ||
+        Cast<Trace>(child) ||
+        Cast<Comment>(child) ||
+        Cast<Debug>(child) ||
+        Cast<Return>(child) ||
+        Cast<Variable>(child) ||
+        // Ruby Sass doesn't distinguish variables and assignments
+        Cast<Assignment>(child) ||
+        Cast<Warning>(child) ||
+        Cast<Error>(child)
+    )) {
+      error(child, traces, "Functions can only contain variable declarations and control directives.");
+    }
+  }
+
+  void CheckNesting::invalid_prop_child(Statement* child)
+  {
+    if (!(
+        Cast<Each>(child) ||
+        Cast<For>(child) ||
+        Cast<If>(child) ||
+        Cast<While>(child) ||
+        Cast<Trace>(child) ||
+        Cast<Comment>(child) ||
+        Cast<Declaration>(child) ||
+        Cast<Mixin_Call>(child)
+    )) {
+      error(child, traces, "Illegal nesting: Only properties may be nested beneath properties.");
+    }
+  }
+
+  void CheckNesting::invalid_prop_parent(Statement* parent, AST_Node* node)
+  {
+    if (!(
+        is_mixin(parent) ||
+        is_directive_node(parent) ||
+        Cast<Ruleset>(parent) ||
+        Cast<Keyframe_Rule>(parent) ||
+        Cast<Declaration>(parent) ||
+        Cast<Mixin_Call>(parent)
+    )) {
+      error(node, traces, "Properties are only allowed within rules, directives, mixin includes, or other properties.");
+    }
+  }
+
+  void CheckNesting::invalid_value_child(AST_Node* d)
+  {
+    if (Map* m = Cast<Map>(d)) {
+      traces.push_back(Backtrace(m->pstate()));
+      throw Exception::InvalidValue(traces, *m);
+    }
+    if (Number* n = Cast<Number>(d)) {
+      if (!n->is_valid_css_unit()) {
+        traces.push_back(Backtrace(n->pstate()));
+        throw Exception::InvalidValue(traces, *n);
+      }
+    }
+
+    // error(dbg + " isn't a valid CSS value.", m->pstate(),);
+
+  }
+
+  void CheckNesting::invalid_return_parent(Statement* parent, AST_Node* node)
+  {
+    if (!this->is_function(parent)) {
+      error(node, traces, "@return may only be used within a function.");
+    }
+  }
+
+  bool CheckNesting::is_transparent_parent(Statement* parent, Statement* grandparent)
+  {
+    bool parent_bubbles = parent && parent->bubbles();
+
+    bool valid_bubble_node = parent_bubbles &&
+                             !is_root_node(grandparent) &&
+                             !is_at_root_node(grandparent);
+
+    return Cast<Import>(parent) ||
+           Cast<Each>(parent) ||
+           Cast<For>(parent) ||
+           Cast<If>(parent) ||
+           Cast<While>(parent) ||
+           Cast<Trace>(parent) ||
+           valid_bubble_node;
+  }
+
+  bool CheckNesting::is_charset(Statement* n)
+  {
+    Directive* d = Cast<Directive>(n);
+    return d && d->keyword() == "charset";
+  }
+
+  bool CheckNesting::is_mixin(Statement* n)
+  {
+    Definition* def = Cast<Definition>(n);
+    return def && def->type() == Definition::MIXIN;
+  }
+
+  bool CheckNesting::is_function(Statement* n)
+  {
+    Definition* def = Cast<Definition>(n);
+    return def && def->type() == Definition::FUNCTION;
+  }
+
+  bool CheckNesting::is_root_node(Statement* n)
+  {
+    if (Cast<Ruleset>(n)) return false;
+
+    Block* b = Cast<Block>(n);
+    return b && b->is_root();
+  }
+
+  bool CheckNesting::is_at_root_node(Statement* n)
+  {
+    return Cast<At_Root_Block>(n) != NULL;
+  }
+
+  bool CheckNesting::is_directive_node(Statement* n)
+  {
+    return Cast<Directive>(n) ||
+           Cast<Import>(n) ||
+           Cast<Media_Block>(n) ||
+           Cast<Supports_Block>(n);
+  }
+}