zuora_connect_ui 0.8.2 → 0.8.3

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

@@ -0,0 +1,129 @@
+#ifndef SASS_SASS_CONTEXT_H
+#define SASS_SASS_CONTEXT_H
+
+#include "sass/base.h"
+#include "sass/context.h"
+#include "ast_fwd_decl.hpp"
+
+// sass config options structure
+struct Sass_Options : Sass_Output_Options {
+
+  // embed sourceMappingUrl as data uri
+  bool source_map_embed;
+
+  // embed include contents in maps
+  bool source_map_contents;
+
+  // create file urls for sources
+  bool source_map_file_urls;
+
+  // Disable sourceMappingUrl in css output
+  bool omit_source_map_url;
+
+  // Treat source_string as sass (as opposed to scss)
+  bool is_indented_syntax_src;
+
+  // The input path is used for source map
+  // generation. It can be used to define
+  // something with string compilation or to
+  // overload the input file path. It is
+  // set to "stdin" for data contexts and
+  // to the input file on file contexts.
+  char* input_path;
+
+  // The output path is used for source map
+  // generation. LibSass will not write to
+  // this file, it is just used to create
+  // information in source-maps etc.
+  char* output_path;
+
+  // Colon-separated list of paths
+  // Semicolon-separated on Windows
+  // Maybe use array interface instead?
+  char* include_path;
+  char* plugin_path;
+
+  // Include paths (linked string list)
+  struct string_list* include_paths;
+  // Plugin paths (linked string list)
+  struct string_list* plugin_paths;
+
+  // Path to source map file
+  // Enables source map generation
+  // Used to create sourceMappingUrl
+  char* source_map_file;
+
+  // Directly inserted in source maps
+  char* source_map_root;
+
+  // Custom functions that can be called from sccs code
+  Sass_Function_List c_functions;
+
+  // List of custom importers
+  Sass_Importer_List c_importers;
+
+  // List of custom headers
+  Sass_Importer_List c_headers;
+
+};
+
+
+// base for all contexts
+struct Sass_Context : Sass_Options
+{
+
+  // store context type info
+  enum Sass_Input_Style type;
+
+  // generated output data
+  char* output_string;
+
+  // generated source map json
+  char* source_map_string;
+
+  // error status
+  int error_status;
+  char* error_json;
+  char* error_text;
+  char* error_message;
+  // error position
+  char* error_file;
+  size_t error_line;
+  size_t error_column;
+  const char* error_src;
+
+  // report imported files
+  char** included_files;
+
+};
+
+// struct for file compilation
+struct Sass_File_Context : Sass_Context {
+
+  // no additional fields required
+  // input_path is already on options
+
+};
+
+// struct for data compilation
+struct Sass_Data_Context : Sass_Context {
+
+  // provided source string
+  char* source_string;
+  char* srcmap_string;
+
+};
+
+// link c and cpp context
+struct Sass_Compiler {
+  // progress status
+  Sass_Compiler_State state;
+  // original c context
+  Sass_Context* c_ctx;
+  // Sass::Context
+  Sass::Context* cpp_ctx;
+  // Sass::Block
+  Sass::Block_Obj root;
+};
+
+#endif

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

@@ -0,0 +1,210 @@
+// sass.hpp must go before all system headers to get the
+// __EXTENSIONS__ fix on Solaris.
+#include "sass.hpp"
+
+#include <cstring>
+#include "util.hpp"
+#include "context.hpp"
+#include "values.hpp"
+#include "sass/functions.h"
+#include "sass_functions.hpp"
+
+extern "C" {
+  using namespace Sass;
+
+  Sass_Function_List ADDCALL sass_make_function_list(size_t length)
+  {
+    return (Sass_Function_List) calloc(length + 1, sizeof(Sass_Function_Entry));
+  }
+
+  Sass_Function_Entry ADDCALL sass_make_function(const char* signature, Sass_Function_Fn function, void* cookie)
+  {
+    Sass_Function_Entry cb = (Sass_Function_Entry) calloc(1, sizeof(Sass_Function));
+    if (cb == 0) return 0;
+    cb->signature = sass_copy_c_string(signature);
+    cb->function = function;
+    cb->cookie = cookie;
+    return cb;
+  }
+
+  void ADDCALL sass_delete_function(Sass_Function_Entry entry)
+  {
+    free(entry->signature);
+    free(entry);
+  }
+
+  // Deallocator for the allocated memory
+  void ADDCALL sass_delete_function_list(Sass_Function_List list)
+  {
+    Sass_Function_List it = list;
+    if (list == 0) return;
+    while(*list) {
+      sass_delete_function(*list);
+      ++list;
+    }
+    free(it);
+  }
+
+  // Setters and getters for callbacks on function lists
+  Sass_Function_Entry ADDCALL sass_function_get_list_entry(Sass_Function_List list, size_t pos) { return list[pos]; }
+  void sass_function_set_list_entry(Sass_Function_List list, size_t pos, Sass_Function_Entry cb) { list[pos] = cb; }
+
+  const char* ADDCALL sass_function_get_signature(Sass_Function_Entry cb) { return cb->signature; }
+  Sass_Function_Fn ADDCALL sass_function_get_function(Sass_Function_Entry cb) { return cb->function; }
+  void* ADDCALL sass_function_get_cookie(Sass_Function_Entry cb) { return cb->cookie; }
+
+  Sass_Importer_Entry ADDCALL sass_make_importer(Sass_Importer_Fn importer, double priority, void* cookie)
+  {
+    Sass_Importer_Entry cb = (Sass_Importer_Entry) calloc(1, sizeof(Sass_Importer));
+    if (cb == 0) return 0;
+    cb->importer = importer;
+    cb->priority = priority;
+    cb->cookie = cookie;
+    return cb;
+  }
+
+  Sass_Importer_Fn ADDCALL sass_importer_get_function(Sass_Importer_Entry cb) { return cb->importer; }
+  double ADDCALL sass_importer_get_priority (Sass_Importer_Entry cb) { return cb->priority; }
+  void* ADDCALL sass_importer_get_cookie(Sass_Importer_Entry cb) { return cb->cookie; }
+
+  // Just in case we have some stray import structs
+  void ADDCALL sass_delete_importer (Sass_Importer_Entry cb)
+  {
+    free(cb);
+  }
+
+  // Creator for sass custom importer function list
+  Sass_Importer_List ADDCALL sass_make_importer_list(size_t length)
+  {
+    return (Sass_Importer_List) calloc(length + 1, sizeof(Sass_Importer_Entry));
+  }
+
+  // Deallocator for the allocated memory
+  void ADDCALL sass_delete_importer_list(Sass_Importer_List list)
+  {
+    Sass_Importer_List it = list;
+    if (list == 0) return;
+    while(*list) {
+      sass_delete_importer(*list);
+      ++list;
+    }
+    free(it);
+  }
+
+  Sass_Importer_Entry ADDCALL sass_importer_get_list_entry(Sass_Importer_List list, size_t idx) { return list[idx]; }
+  void ADDCALL sass_importer_set_list_entry(Sass_Importer_List list, size_t idx, Sass_Importer_Entry cb) { list[idx] = cb; }
+
+  // Creator for sass custom importer return argument list
+  Sass_Import_List ADDCALL sass_make_import_list(size_t length)
+  {
+    return (Sass_Import**) calloc(length + 1, sizeof(Sass_Import*));
+  }
+
+  // Creator for a single import entry returned by the custom importer inside the list
+  // We take ownership of the memory for source and srcmap (freed when context is destroyd)
+  Sass_Import_Entry ADDCALL sass_make_import(const char* imp_path, const char* abs_path, char* source, char* srcmap)
+  {
+    Sass_Import* v = (Sass_Import*) calloc(1, sizeof(Sass_Import));
+    if (v == 0) return 0;
+    v->imp_path = imp_path ? sass_copy_c_string(imp_path) : 0;
+    v->abs_path = abs_path ? sass_copy_c_string(abs_path) : 0;
+    v->source = source;
+    v->srcmap = srcmap;
+    v->error = 0;
+    v->line = -1;
+    v->column = -1;
+    return v;
+  }
+
+  // Older style, but somehow still valid - keep around or deprecate?
+  Sass_Import_Entry ADDCALL sass_make_import_entry(const char* path, char* source, char* srcmap)
+  {
+    return sass_make_import(path, path, source, srcmap);
+  }
+
+  // Upgrade a normal import entry to throw an error (original path can be re-used by error reporting)
+  Sass_Import_Entry ADDCALL sass_import_set_error(Sass_Import_Entry import, const char* error, size_t line, size_t col)
+  {
+    if (import == 0) return 0;
+    if (import->error) free(import->error);
+    import->error = error ? sass_copy_c_string(error) : 0;
+    import->line = line ? line : -1;
+    import->column = col ? col : -1;
+    return import;
+  }
+
+  // Setters and getters for entries on the import list
+  void ADDCALL sass_import_set_list_entry(Sass_Import_List list, size_t idx, Sass_Import_Entry entry) { list[idx] = entry; }
+  Sass_Import_Entry ADDCALL sass_import_get_list_entry(Sass_Import_List list, size_t idx) { return list[idx]; }
+
+  // Deallocator for the allocated memory
+  void ADDCALL sass_delete_import_list(Sass_Import_List list)
+  {
+    Sass_Import_List it = list;
+    if (list == 0) return;
+    while(*list) {
+      sass_delete_import(*list);
+      ++list;
+    }
+    free(it);
+  }
+
+  // Just in case we have some stray import structs
+  void ADDCALL sass_delete_import(Sass_Import_Entry import)
+  {
+    free(import->imp_path);
+    free(import->abs_path);
+    free(import->source);
+    free(import->srcmap);
+    free(import->error);
+    free(import);
+  }
+
+  // Getter for callee entry
+  const char* ADDCALL sass_callee_get_name(Sass_Callee_Entry entry) { return entry->name; }
+  const char* ADDCALL sass_callee_get_path(Sass_Callee_Entry entry) { return entry->path; }
+  size_t ADDCALL sass_callee_get_line(Sass_Callee_Entry entry) { return entry->line; }
+  size_t ADDCALL sass_callee_get_column(Sass_Callee_Entry entry) { return entry->column; }
+  enum Sass_Callee_Type ADDCALL sass_callee_get_type(Sass_Callee_Entry entry) { return entry->type; }
+  Sass_Env_Frame ADDCALL sass_callee_get_env (Sass_Callee_Entry entry) { return &entry->env; }
+
+  // Getters and Setters for environments (lexical, local and global)
+  union Sass_Value* ADDCALL sass_env_get_lexical (Sass_Env_Frame env, const char* name) {
+    Expression* ex = Cast<Expression>((*env->frame)[name]);
+    return ex != NULL ? ast_node_to_sass_value(ex) : NULL;
+  }
+  void ADDCALL sass_env_set_lexical (Sass_Env_Frame env, const char* name, union Sass_Value* val) {
+    (*env->frame)[name] = sass_value_to_ast_node(val);
+  }
+  union Sass_Value* ADDCALL sass_env_get_local (Sass_Env_Frame env, const char* name) {
+    Expression* ex = Cast<Expression>(env->frame->get_local(name));
+    return ex != NULL ? ast_node_to_sass_value(ex) : NULL;
+  }
+  void ADDCALL sass_env_set_local (Sass_Env_Frame env, const char* name, union Sass_Value* val) {
+    env->frame->set_local(name, sass_value_to_ast_node(val));
+  }
+  union Sass_Value* ADDCALL sass_env_get_global (Sass_Env_Frame env, const char* name) {
+    Expression* ex = Cast<Expression>(env->frame->get_global(name));
+    return ex != NULL ? ast_node_to_sass_value(ex) : NULL;
+  }
+  void ADDCALL sass_env_set_global (Sass_Env_Frame env, const char* name, union Sass_Value* val) {
+    env->frame->set_global(name, sass_value_to_ast_node(val));
+  }
+
+  // Getter for import entry
+  const char* ADDCALL sass_import_get_imp_path(Sass_Import_Entry entry) { return entry->imp_path; }
+  const char* ADDCALL sass_import_get_abs_path(Sass_Import_Entry entry) { return entry->abs_path; }
+  const char* ADDCALL sass_import_get_source(Sass_Import_Entry entry) { return entry->source; }
+  const char* ADDCALL sass_import_get_srcmap(Sass_Import_Entry entry) { return entry->srcmap; }
+
+  // Getter for import error entry
+  size_t ADDCALL sass_import_get_error_line(Sass_Import_Entry entry) { return entry->line; }
+  size_t ADDCALL sass_import_get_error_column(Sass_Import_Entry entry) { return entry->column; }
+  const char* ADDCALL sass_import_get_error_message(Sass_Import_Entry entry) { return entry->error; }
+
+  // Explicit functions to take ownership of the memory
+  // Resets our own property since we do not know if it is still alive
+  char* ADDCALL sass_import_take_source(Sass_Import_Entry entry) { char* ptr = entry->source; entry->source = 0; return ptr; }
+  char* ADDCALL sass_import_take_srcmap(Sass_Import_Entry entry) { char* ptr = entry->srcmap; entry->srcmap = 0; return ptr; }
+
+}

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

@@ -0,0 +1,50 @@
+#ifndef SASS_SASS_FUNCTIONS_H
+#define SASS_SASS_FUNCTIONS_H
+
+#include "sass.h"
+#include "environment.hpp"
+#include "fn_utils.hpp"
+
+// Struct to hold custom function callback
+struct Sass_Function {
+  char*            signature;
+  Sass_Function_Fn function;
+  void*            cookie;
+};
+
+// External import entry
+struct Sass_Import {
+  char* imp_path; // path as found in the import statement
+  char *abs_path; // path after importer has resolved it
+  char* source;
+  char* srcmap;
+  // error handling
+  char* error;
+  size_t line;
+  size_t column;
+};
+
+// External environments
+struct Sass_Env {
+  // links to parent frames
+  Sass::Env* frame;
+};
+
+// External call entry
+struct Sass_Callee {
+  const char* name;
+  const char* path;
+  size_t line;
+  size_t column;
+  enum Sass_Callee_Type type;
+  struct Sass_Env env;
+};
+
+// Struct to hold importer callback
+struct Sass_Importer {
+  Sass_Importer_Fn importer;
+  double           priority;
+  void*            cookie;
+};
+
+#endif

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

@@ -0,0 +1,152 @@
+// sass.hpp must go before all system headers to get the
+// __EXTENSIONS__ fix on Solaris.
+#include "sass.hpp"
+
+#include "node.hpp"
+
+namespace Sass {
+
+
+  /*
+    # This is the equivalent of ruby's Sass::Util.paths.
+    #
+    # Return an array of all possible paths through the given arrays.
+    #
+    # @param arrs [NodeCollection<NodeCollection<Node>>]
+    # @return [NodeCollection<NodeCollection<Node>>]
+    #
+    # @example
+    #   paths([[1, 2], [3, 4], [5]]) #=>
+    #     # [[1, 3, 5],
+    #     #  [2, 3, 5],
+    #     #  [1, 4, 5],
+    #     #  [2, 4, 5]]
+
+   The following is the modified version of the ruby code that was more portable to C++. You
+   should be able to drop it into ruby 3.2.19 and get the same results from ruby sass.
+
+    def paths(arrs)
+        // I changed the inject and maps to an iterative approach to make it easier to implement in C++
+      loopStart = [[]]
+
+      for arr in arrs do
+        permutations = []
+        for e in arr do
+          for path in loopStart do
+            permutations.push(path + [e])
+          end
+        end
+        loopStart = permutations
+      end
+    end
+  */
+  Node paths(const Node& arrs) {
+
+    Node loopStart = Node::createCollection();
+    loopStart.collection()->push_back(Node::createCollection());
+
+    for (NodeDeque::iterator arrsIter = arrs.collection()->begin(), arrsEndIter = arrs.collection()->end();
+    	arrsIter != arrsEndIter; ++arrsIter) {
+
+      Node& arr = *arrsIter;
+
+      Node permutations = Node::createCollection();
+
+      for (NodeDeque::iterator arrIter = arr.collection()->begin(), arrIterEnd = arr.collection()->end();
+      	arrIter != arrIterEnd; ++arrIter) {
+
+        Node& e = *arrIter;
+
+        for (NodeDeque::iterator loopStartIter = loopStart.collection()->begin(), loopStartIterEnd = loopStart.collection()->end();
+          loopStartIter != loopStartIterEnd; ++loopStartIter) {
+
+          Node& path = *loopStartIter;
+
+          Node newPermutation = Node::createCollection();
+          newPermutation.got_line_feed = arr.got_line_feed;
+          newPermutation.plus(path);
+          newPermutation.collection()->push_back(e);
+
+          permutations.collection()->push_back(newPermutation);
+        }
+      }
+
+      loopStart = permutations;
+    }
+
+    return loopStart;
+  }
+
+
+  /*
+  This is the equivalent of ruby sass' Sass::Util.flatten and [].flatten.
+  Sass::Util.flatten requires the number of levels to flatten, while
+  [].flatten doesn't and will flatten the entire array. This function
+  supports both.
+
+  # Flattens the first `n` nested arrays. If n == -1, all arrays will be flattened
+  #
+  # @param arr [NodeCollection] The array to flatten
+  # @param n [int] The number of levels to flatten
+  # @return [NodeCollection] The flattened array
+
+  The following is the modified version of the ruby code that was more portable to C++. You
+  should be able to drop it into ruby 3.2.19 and get the same results from ruby sass.
+
+  def flatten(arr, n = -1)
+    if n != -1 and n == 0 then
+      return arr
+    end
+
+    flattened = []
+
+    for e in arr do
+      if e.is_a?(Array) then
+        flattened.concat(flatten(e, n - 1))
+      else
+        flattened << e
+      end
+    end
+
+    return flattened
+  end
+  */
+  Node flatten(Node& arr, int n) {
+    if (n != -1 && n == 0) {
+      return arr;
+    }
+
+    Node flattened = Node::createCollection();
+    if (arr.got_line_feed) flattened.got_line_feed = true;
+
+    for (NodeDeque::iterator iter = arr.collection()->begin(), iterEnd = arr.collection()->end();
+    	iter != iterEnd; iter++) {
+    	Node& e = *iter;
+
+      // e has the lf set
+      if (e.isCollection()) {
+
+      	// e.collection().got_line_feed = e.got_line_feed;
+      	Node recurseFlattened = flatten(e, n - 1);
+
+      	if(e.got_line_feed) {
+      		 flattened.got_line_feed = e.got_line_feed;
+      	  recurseFlattened.got_line_feed = e.got_line_feed;
+      	}
+
+      	for(auto i : (*recurseFlattened.collection())) {
+          if (recurseFlattened.got_line_feed) {
+
+            i.got_line_feed = true;
+          }
+          flattened.collection()->push_back(i);
+      	}
+
+      } else {
+      	flattened.collection()->push_back(e);
+      }
+    }
+
+    return flattened;
+  }
+}