zuora_connect_ui 0.8.2 → 0.8.3

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

@@ -0,0 +1,82 @@
+#ifndef SASS_SASS_VALUES_H
+#define SASS_SASS_VALUES_H
+
+#include "sass.h"
+
+struct Sass_Unknown {
+  enum Sass_Tag tag;
+};
+
+struct Sass_Boolean {
+  enum Sass_Tag tag;
+  bool          value;
+};
+
+struct Sass_Number {
+  enum Sass_Tag tag;
+  double        value;
+  char*         unit;
+};
+
+struct Sass_Color {
+  enum Sass_Tag tag;
+  double        r;
+  double        g;
+  double        b;
+  double        a;
+};
+
+struct Sass_String {
+  enum Sass_Tag tag;
+  bool          quoted;
+  char*         value;
+};
+
+struct Sass_List {
+  enum Sass_Tag       tag;
+  enum Sass_Separator separator;
+  bool                is_bracketed;
+  size_t              length;
+  // null terminated "array"
+  union Sass_Value**  values;
+};
+
+struct Sass_Map {
+  enum Sass_Tag        tag;
+  size_t               length;
+  struct Sass_MapPair* pairs;
+};
+
+struct Sass_Null {
+  enum Sass_Tag tag;
+};
+
+struct Sass_Error {
+  enum Sass_Tag tag;
+  char*         message;
+};
+
+struct Sass_Warning {
+  enum Sass_Tag tag;
+  char*         message;
+};
+
+union Sass_Value {
+  struct Sass_Unknown unknown;
+  struct Sass_Boolean boolean;
+  struct Sass_Number  number;
+  struct Sass_Color   color;
+  struct Sass_String  string;
+  struct Sass_List    list;
+  struct Sass_Map     map;
+  struct Sass_Null    null;
+  struct Sass_Error   error;
+  struct Sass_Warning warning;
+};
+
+struct Sass_MapPair {
+  union Sass_Value* key;
+  union Sass_Value* value;
+};
+
+#endif

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

@@ -0,0 +1,198 @@
+// sass.hpp must go before all system headers to get the
+// __EXTENSIONS__ fix on Solaris.
+#include "sass.hpp"
+
+#include <string>
+#include <sstream>
+#include <iostream>
+#include <iomanip>
+
+#include "ast.hpp"
+#include "json.hpp"
+#include "context.hpp"
+#include "position.hpp"
+#include "source_map.hpp"
+
+namespace Sass {
+  SourceMap::SourceMap() : current_position(0, 0, 0), file("stdin") { }
+  SourceMap::SourceMap(const std::string& file) : current_position(0, 0, 0), file(file) { }
+
+  std::string SourceMap::render_srcmap(Context &ctx) {
+
+    const bool include_sources = ctx.c_options.source_map_contents;
+    const std::vector<std::string> links = ctx.srcmap_links;
+    const std::vector<Resource>& sources(ctx.resources);
+
+    JsonNode* json_srcmap = json_mkobject();
+
+    json_append_member(json_srcmap, "version", json_mknumber(3));
+
+    const char *file_name = file.c_str();
+    JsonNode *json_file_name = json_mkstring(file_name);
+    json_append_member(json_srcmap, "file", json_file_name);
+
+    // pass-through sourceRoot option
+    if (!ctx.source_map_root.empty()) {
+      JsonNode* root = json_mkstring(ctx.source_map_root.c_str());
+      json_append_member(json_srcmap, "sourceRoot", root);
+    }
+
+    JsonNode *json_sources = json_mkarray();
+    for (size_t i = 0; i < source_index.size(); ++i) {
+      std::string source(links[source_index[i]]);
+      if (ctx.c_options.source_map_file_urls) {
+        source = File::rel2abs(source);
+        // check for windows abs path
+        if (source[0] == '/') {
+          // ends up with three slashes
+          source = "file://" + source;
+        } else {
+          // needs an additional slash
+          source = "file:///" + source;
+        }
+      }
+      const char* source_name = source.c_str();
+      JsonNode *json_source_name = json_mkstring(source_name);
+      json_append_element(json_sources, json_source_name);
+    }
+    json_append_member(json_srcmap, "sources", json_sources);
+
+    if (include_sources && source_index.size()) {
+      JsonNode *json_contents = json_mkarray();
+      for (size_t i = 0; i < source_index.size(); ++i) {
+        const Resource& resource(sources[source_index[i]]);
+        JsonNode *json_content = json_mkstring(resource.contents);
+        json_append_element(json_contents, json_content);
+      }
+      json_append_member(json_srcmap, "sourcesContent", json_contents);
+    }
+
+    JsonNode *json_names = json_mkarray();
+    // so far we have no implementation for names
+    // no problem as we do not alter any identifiers
+    json_append_member(json_srcmap, "names", json_names);
+
+    std::string mappings = serialize_mappings();
+    JsonNode *json_mappings = json_mkstring(mappings.c_str());
+    json_append_member(json_srcmap, "mappings", json_mappings);
+
+    char *str = json_stringify(json_srcmap, "\t");
+    std::string result = std::string(str);
+    free(str);
+    json_delete(json_srcmap);
+    return result;
+  }
+
+  std::string SourceMap::serialize_mappings() {
+    std::string result = "";
+
+    size_t previous_generated_line = 0;
+    size_t previous_generated_column = 0;
+    size_t previous_original_line = 0;
+    size_t previous_original_column = 0;
+    size_t previous_original_file = 0;
+    for (size_t i = 0; i < mappings.size(); ++i) {
+      const size_t generated_line = mappings[i].generated_position.line;
+      const size_t generated_column = mappings[i].generated_position.column;
+      const size_t original_line = mappings[i].original_position.line;
+      const size_t original_column = mappings[i].original_position.column;
+      const size_t original_file = mappings[i].original_position.file;
+
+      if (generated_line != previous_generated_line) {
+        previous_generated_column = 0;
+        if (generated_line > previous_generated_line) {
+          result += std::string(generated_line - previous_generated_line, ';');
+          previous_generated_line = generated_line;
+        }
+      }
+      else if (i > 0) {
+        result += ",";
+      }
+
+      // generated column
+      result += base64vlq.encode(static_cast<int>(generated_column) - static_cast<int>(previous_generated_column));
+      previous_generated_column = generated_column;
+      // file
+      result += base64vlq.encode(static_cast<int>(original_file) - static_cast<int>(previous_original_file));
+      previous_original_file = original_file;
+      // source line
+      result += base64vlq.encode(static_cast<int>(original_line) - static_cast<int>(previous_original_line));
+      previous_original_line = original_line;
+      // source column
+      result += base64vlq.encode(static_cast<int>(original_column) - static_cast<int>(previous_original_column));
+      previous_original_column = original_column;
+    }
+
+    return result;
+  }
+
+  void SourceMap::prepend(const OutputBuffer& out)
+  {
+    Offset size(out.smap.current_position);
+    for (Mapping mapping : out.smap.mappings) {
+      if (mapping.generated_position.line > size.line) {
+        throw(std::runtime_error("prepend sourcemap has illegal line"));
+      }
+      if (mapping.generated_position.line == size.line) {
+        if (mapping.generated_position.column > size.column) {
+          throw(std::runtime_error("prepend sourcemap has illegal column"));
+        }
+      }
+    }
+    // adjust the buffer offset
+    prepend(Offset(out.buffer));
+    // now add the new mappings
+    VECTOR_UNSHIFT(mappings, out.smap.mappings);
+  }
+
+  void SourceMap::append(const OutputBuffer& out)
+  {
+    append(Offset(out.buffer));
+  }
+
+  void SourceMap::prepend(const Offset& offset)
+  {
+    if (offset.line != 0 || offset.column != 0) {
+      for (Mapping& mapping : mappings) {
+        // move stuff on the first old line
+        if (mapping.generated_position.line == 0) {
+          mapping.generated_position.column += offset.column;
+        }
+        // make place for the new lines
+        mapping.generated_position.line += offset.line;
+      }
+    }
+    if (current_position.line == 0) {
+      current_position.column += offset.column;
+    }
+    current_position.line += offset.line;
+  }
+
+  void SourceMap::append(const Offset& offset)
+  {
+    current_position += offset;
+  }
+
+  void SourceMap::add_open_mapping(const AST_Node* node)
+  {
+    mappings.push_back(Mapping(node->pstate(), current_position));
+  }
+
+  void SourceMap::add_close_mapping(const AST_Node* node)
+  {
+    mappings.push_back(Mapping(node->pstate() + node->pstate().offset, current_position));
+  }
+
+  ParserState SourceMap::remap(const ParserState& pstate) {
+    for (size_t i = 0; i < mappings.size(); ++i) {
+      if (
+        mappings[i].generated_position.file == pstate.file &&
+        mappings[i].generated_position.line == pstate.line &&
+        mappings[i].generated_position.column == pstate.column
+      ) return ParserState(pstate.path, pstate.src, mappings[i].original_position, pstate.offset);
+    }
+    return ParserState(pstate.path, pstate.src, Position(-1, -1, -1), Offset(0, 0));
+
+  }
+
+}

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

@@ -0,0 +1,62 @@
+#ifndef SASS_SOURCE_MAP_H
+#define SASS_SOURCE_MAP_H
+
+#include <string>
+#include <vector>
+
+#include "ast_fwd_decl.hpp"
+#include "base64vlq.hpp"
+#include "position.hpp"
+#include "mapping.hpp"
+
+#define VECTOR_PUSH(vec, ins) vec.insert(vec.end(), ins.begin(), ins.end())
+#define VECTOR_UNSHIFT(vec, ins) vec.insert(vec.begin(), ins.begin(), ins.end())
+
+namespace Sass {
+
+  class Context;
+  class OutputBuffer;
+
+  class SourceMap {
+
+  public:
+    std::vector<size_t> source_index;
+    SourceMap();
+    SourceMap(const std::string& file);
+
+    void append(const Offset& offset);
+    void prepend(const Offset& offset);
+    void append(const OutputBuffer& out);
+    void prepend(const OutputBuffer& out);
+    void add_open_mapping(const AST_Node* node);
+    void add_close_mapping(const AST_Node* node);
+
+    std::string render_srcmap(Context &ctx);
+    ParserState remap(const ParserState& pstate);
+
+  private:
+
+    std::string serialize_mappings();
+
+    std::vector<Mapping> mappings;
+    Position current_position;
+public:
+    std::string file;
+private:
+    Base64VLQ base64vlq;
+  };
+
+  class OutputBuffer {
+    public:
+      OutputBuffer(void)
+      : buffer(""),
+        smap()
+      { }
+    public:
+      std::string buffer;
+      SourceMap smap;
+  };
+
+}
+
+#endif

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

@@ -0,0 +1,58 @@
+// sass.hpp must go before all system headers to get the
+// __EXTENSIONS__ fix on Solaris.
+#include "sass.hpp"
+
+#include "ast.hpp"
+#include "subset_map.hpp"
+
+namespace Sass {
+
+  void Subset_Map::put(const Compound_Selector_Obj& sel, const SubSetMapPair& value)
+  {
+    if (sel->empty()) throw std::runtime_error("internal error: subset map keys may not be empty");
+    size_t index = values_.size();
+    values_.push_back(value);
+    for (size_t i = 0, S = sel->length(); i < S; ++i)
+    {
+      hash_[(*sel)[i]].push_back(std::make_pair(sel, index));
+    }
+  }
+
+  std::vector<SubSetMapPair> Subset_Map::get_kv(const Compound_Selector_Obj& sel)
+  {
+    SimpleSelectorDict dict(sel->begin(), sel->end()); // XXX Set
+    std::vector<size_t> indices;
+    for (size_t i = 0, S = sel->length(); i < S; ++i) {
+      if (!hash_.count((*sel)[i])) {
+        continue;
+      }
+      const std::vector<std::pair<Compound_Selector_Obj, size_t> >& subsets = hash_[(*sel)[i]];
+      for (const std::pair<Compound_Selector_Obj, size_t>& item : subsets) {
+        bool include = true;
+        for (const Simple_Selector_Obj& it : item.first->elements()) {
+          auto found = dict.find(it);
+          if (found == dict.end()) {
+            include = false;
+            break;
+          }
+        }
+        if (include) indices.push_back(item.second);
+      }
+    }
+    sort(indices.begin(), indices.end());
+    std::vector<size_t>::iterator indices_end = unique(indices.begin(), indices.end());
+    indices.resize(distance(indices.begin(), indices_end));
+
+    std::vector<SubSetMapPair> results;
+    for (size_t i = 0, S = indices.size(); i < S; ++i) {
+      results.push_back(values_[indices[i]]);
+    }
+    return results;
+  }
+
+  std::vector<SubSetMapPair> Subset_Map::get_v(const Compound_Selector_Obj& sel)
+  {
+    return get_kv(sel);
+  }
+
+}

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

@@ -0,0 +1,76 @@
+#ifndef SASS_SUBSET_MAP_H
+#define SASS_SUBSET_MAP_H
+
+#include <map>
+#include <set>
+#include <vector>
+#include <algorithm>
+#include <iterator>
+
+#include "ast_fwd_decl.hpp"
+
+
+// #include <iostream>
+// #include <sstream>
+// template<typename T>
+// std::string vector_to_string(std::vector<T> v)
+// {
+//   std::stringstream buffer;
+//   buffer << "[";
+
+//   if (!v.empty())
+//   {  buffer << v[0]; }
+//   else
+//   { buffer << "]"; }
+
+//   if (v.size() == 1)
+//   { buffer << "]"; }
+//   else
+//   {
+//     for (size_t i = 1, S = v.size(); i < S; ++i) buffer << ", " << v[i];
+//     buffer << "]";
+//   }
+
+//   return buffer.str();
+// }
+
+// template<typename T>
+// std::string set_to_string(set<T> v)
+// {
+//   std::stringstream buffer;
+//   buffer << "[";
+//   typename std::set<T>::iterator i = v.begin();
+//   if (!v.empty())
+//   {  buffer << *i; }
+//   else
+//   { buffer << "]"; }
+
+//   if (v.size() == 1)
+//   { buffer << "]"; }
+//   else
+//   {
+//     for (++i; i != v.end(); ++i) buffer << ", " << *i;
+//     buffer << "]";
+//   }
+
+//   return buffer.str();
+// }
+
+namespace Sass {
+
+  class Subset_Map {
+  private:
+    std::vector<SubSetMapPair> values_;
+    std::map<Simple_Selector_Obj, std::vector<std::pair<Compound_Selector_Obj, size_t> >, OrderNodes > hash_;
+  public:
+    void put(const Compound_Selector_Obj& sel, const SubSetMapPair& value);
+    std::vector<SubSetMapPair> get_kv(const Compound_Selector_Obj& s);
+    std::vector<SubSetMapPair> get_v(const Compound_Selector_Obj& s);
+    bool empty() { return values_.empty(); }
+    void clear() { values_.clear(); hash_.clear(); }
+    const std::vector<SubSetMapPair> values(void) { return values_; }
+  };
+
+}
+
+#endif