zuora_connect_ui 0.8.2 → 0.8.3

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

@@ -0,0 +1,298 @@
+#include "sass.hpp"
+#include "util.hpp"
+#include "context.hpp"
+#include "output.hpp"
+#include "emitter.hpp"
+#include "util_string.hpp"
+#include "utf8_string.hpp"
+
+namespace Sass {
+
+  Emitter::Emitter(struct Sass_Output_Options& opt)
+  : wbuf(),
+    opt(opt),
+    indentation(0),
+    scheduled_space(0),
+    scheduled_linefeed(0),
+    scheduled_delimiter(false),
+    scheduled_crutch(0),
+    scheduled_mapping(0),
+    in_custom_property(false),
+    in_comment(false),
+    in_wrapped(false),
+    in_media_block(false),
+    in_declaration(false),
+    in_space_array(false),
+    in_comma_array(false)
+  { }
+
+  // return buffer as string
+  std::string Emitter::get_buffer(void)
+  {
+    return wbuf.buffer;
+  }
+
+  Sass_Output_Style Emitter::output_style(void) const
+  {
+    return opt.output_style;
+  }
+
+  // PROXY METHODS FOR SOURCE MAPS
+
+  void Emitter::add_source_index(size_t idx)
+  { wbuf.smap.source_index.push_back(idx); }
+
+  std::string Emitter::render_srcmap(Context &ctx)
+  { return wbuf.smap.render_srcmap(ctx); }
+
+  void Emitter::set_filename(const std::string& str)
+  { wbuf.smap.file = str; }
+
+  void Emitter::schedule_mapping(const AST_Node* node)
+  { scheduled_mapping = node; }
+  void Emitter::add_open_mapping(const AST_Node* node)
+  { wbuf.smap.add_open_mapping(node); }
+  void Emitter::add_close_mapping(const AST_Node* node)
+  { wbuf.smap.add_close_mapping(node); }
+  ParserState Emitter::remap(const ParserState& pstate)
+  { return wbuf.smap.remap(pstate); }
+
+  // MAIN BUFFER MANIPULATION
+
+  // add outstanding delimiter
+  void Emitter::finalize(bool final)
+  {
+    scheduled_space = 0;
+    if (output_style() == SASS_STYLE_COMPRESSED)
+      if (final) scheduled_delimiter = false;
+    if (scheduled_linefeed)
+      scheduled_linefeed = 1;
+    flush_schedules();
+  }
+
+  // flush scheduled space/linefeed
+  void Emitter::flush_schedules(void)
+  {
+    // check the schedule
+    if (scheduled_linefeed) {
+      std::string linefeeds = "";
+
+      for (size_t i = 0; i < scheduled_linefeed; i++)
+        linefeeds += opt.linefeed;
+      scheduled_space = 0;
+      scheduled_linefeed = 0;
+      append_string(linefeeds);
+
+    } else if (scheduled_space) {
+      std::string spaces(scheduled_space, ' ');
+      scheduled_space = 0;
+      append_string(spaces);
+    }
+    if (scheduled_delimiter) {
+      scheduled_delimiter = false;
+      append_string(";");
+    }
+  }
+
+  // prepend some text or token to the buffer
+  void Emitter::prepend_output(const OutputBuffer& output)
+  {
+    wbuf.smap.prepend(output);
+    wbuf.buffer = output.buffer + wbuf.buffer;
+  }
+
+  // prepend some text or token to the buffer
+  void Emitter::prepend_string(const std::string& text)
+  {
+    // do not adjust mappings for utf8 bom
+    // seems they are not counted in any UA
+    if (text.compare("\xEF\xBB\xBF") != 0) {
+      wbuf.smap.prepend(Offset(text));
+    }
+    wbuf.buffer = text + wbuf.buffer;
+  }
+
+  char Emitter::last_char()
+  {
+    return wbuf.buffer.back();
+  }
+
+  // append a single char to the buffer
+  void Emitter::append_char(const char chr)
+  {
+    // write space/lf
+    flush_schedules();
+    // add to buffer
+    wbuf.buffer += chr;
+    // account for data in source-maps
+    wbuf.smap.append(Offset(chr));
+  }
+
+  // append some text or token to the buffer
+  void Emitter::append_string(const std::string& text)
+  {
+
+    // write space/lf
+    flush_schedules();
+
+    if (in_comment) {
+      std::string out = Util::normalize_newlines(text);
+      if (output_style() == COMPACT) {
+        out = comment_to_compact_string(out);
+      }
+      wbuf.smap.append(Offset(out));
+      wbuf.buffer += std::move(out);
+    } else {
+      // add to buffer
+      wbuf.buffer += text;
+      // account for data in source-maps
+      wbuf.smap.append(Offset(text));
+    }
+  }
+
+  // append some white-space only text
+  void Emitter::append_wspace(const std::string& text)
+  {
+    if (text.empty()) return;
+    if (peek_linefeed(text.c_str())) {
+      scheduled_space = 0;
+      append_mandatory_linefeed();
+    }
+  }
+
+  // append some text or token to the buffer
+  // this adds source-mappings for node start and end
+  void Emitter::append_token(const std::string& text, const AST_Node* node)
+  {
+    flush_schedules();
+    add_open_mapping(node);
+    // hotfix for browser issues
+    // this is pretty ugly indeed
+    if (scheduled_crutch) {
+      add_open_mapping(scheduled_crutch);
+      scheduled_crutch = 0;
+    }
+    append_string(text);
+    add_close_mapping(node);
+  }
+
+  // HELPER METHODS
+
+  void Emitter::append_indentation()
+  {
+    if (output_style() == COMPRESSED) return;
+    if (output_style() == COMPACT) return;
+    if (in_declaration && in_comma_array) return;
+    if (scheduled_linefeed && indentation)
+      scheduled_linefeed = 1;
+    std::string indent = "";
+    for (size_t i = 0; i < indentation; i++)
+      indent += opt.indent;
+    append_string(indent);
+  }
+
+  void Emitter::append_delimiter()
+  {
+    scheduled_delimiter = true;
+    if (output_style() == COMPACT) {
+      if (indentation == 0) {
+        append_mandatory_linefeed();
+      } else {
+        append_mandatory_space();
+      }
+    } else if (output_style() != COMPRESSED) {
+      append_optional_linefeed();
+    }
+  }
+
+  void Emitter::append_comma_separator()
+  {
+    // scheduled_space = 0;
+    append_string(",");
+    append_optional_space();
+  }
+
+  void Emitter::append_colon_separator()
+  {
+    scheduled_space = 0;
+    append_string(":");
+    if (!in_custom_property) append_optional_space();
+  }
+
+  void Emitter::append_mandatory_space()
+  {
+    scheduled_space = 1;
+  }
+
+  void Emitter::append_optional_space()
+  {
+    if ((output_style() != COMPRESSED) && buffer().size()) {
+      unsigned char lst = buffer().at(buffer().length() - 1);
+      if (!isspace(lst) || scheduled_delimiter) {
+        if (last_char() != '(') {
+          append_mandatory_space();
+        }
+      }
+    }
+  }
+
+  void Emitter::append_special_linefeed()
+  {
+    if (output_style() == COMPACT) {
+      append_mandatory_linefeed();
+      for (size_t p = 0; p < indentation; p++)
+        append_string(opt.indent);
+    }
+  }
+
+  void Emitter::append_optional_linefeed()
+  {
+    if (in_declaration && in_comma_array) return;
+    if (output_style() == COMPACT) {
+      append_mandatory_space();
+    } else {
+      append_mandatory_linefeed();
+    }
+  }
+
+  void Emitter::append_mandatory_linefeed()
+  {
+    if (output_style() != COMPRESSED) {
+      scheduled_linefeed = 1;
+      scheduled_space = 0;
+      // flush_schedules();
+    }
+  }
+
+  void Emitter::append_scope_opener(AST_Node* node)
+  {
+    scheduled_linefeed = 0;
+    append_optional_space();
+    flush_schedules();
+    if (node) add_open_mapping(node);
+    append_string("{");
+    append_optional_linefeed();
+    // append_optional_space();
+    ++ indentation;
+  }
+  void Emitter::append_scope_closer(AST_Node* node)
+  {
+    -- indentation;
+    scheduled_linefeed = 0;
+    if (output_style() == COMPRESSED)
+      scheduled_delimiter = false;
+    if (output_style() == EXPANDED) {
+      append_optional_linefeed();
+      append_indentation();
+    } else {
+      append_optional_space();
+    }
+    append_string("}");
+    if (node) add_close_mapping(node);
+    append_optional_linefeed();
+    if (indentation != 0) return;
+    if (output_style() != COMPRESSED)
+      scheduled_linefeed = 2;
+  }
+
+}

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

@@ -0,0 +1,103 @@
+#ifndef SASS_EMITTER_H
+#define SASS_EMITTER_H
+
+// sass.hpp must go before all system headers to get the
+// __EXTENSIONS__ fix on Solaris.
+#include "sass.hpp"
+
+#include <string>
+
+#include "sass/base.h"
+#include "source_map.hpp"
+#include "ast_fwd_decl.hpp"
+
+namespace Sass {
+  class Context;
+
+  class Emitter {
+
+    public:
+      Emitter(struct Sass_Output_Options& opt);
+      virtual ~Emitter() { }
+
+    protected:
+      OutputBuffer wbuf;
+    public:
+      const std::string& buffer(void) { return wbuf.buffer; }
+      const SourceMap smap(void) { return wbuf.smap; }
+      const OutputBuffer output(void) { return wbuf; }
+      // proxy methods for source maps
+      void add_source_index(size_t idx);
+      void set_filename(const std::string& str);
+      void add_open_mapping(const AST_Node* node);
+      void add_close_mapping(const AST_Node* node);
+      void schedule_mapping(const AST_Node* node);
+      std::string render_srcmap(Context &ctx);
+      ParserState remap(const ParserState& pstate);
+
+    public:
+      struct Sass_Output_Options& opt;
+      size_t indentation;
+      size_t scheduled_space;
+      size_t scheduled_linefeed;
+      bool scheduled_delimiter;
+      const AST_Node* scheduled_crutch;
+      const AST_Node* scheduled_mapping;
+
+    public:
+      // output strings different in custom css properties
+      bool in_custom_property;
+      // output strings different in comments
+      bool in_comment;
+      // selector list does not get linefeeds
+      bool in_wrapped;
+      // lists always get a space after delimiter
+      bool in_media_block;
+      // nested list must not have parentheses
+      bool in_declaration;
+      // nested lists need parentheses
+      bool in_space_array;
+      bool in_comma_array;
+
+    public:
+      // return buffer as std::string
+      std::string get_buffer(void);
+      // flush scheduled space/linefeed
+      Sass_Output_Style output_style(void) const;
+      // add outstanding linefeed
+      void finalize(bool final = true);
+      // flush scheduled space/linefeed
+      void flush_schedules(void);
+      // prepend some text or token to the buffer
+      void prepend_string(const std::string& text);
+      void prepend_output(const OutputBuffer& out);
+      // append some text or token to the buffer
+      void append_string(const std::string& text);
+      // append a single character to buffer
+      void append_char(const char chr);
+      // append some white-space only text
+      void append_wspace(const std::string& text);
+      // append some text or token to the buffer
+      // this adds source-mappings for node start and end
+      void append_token(const std::string& text, const AST_Node* node);
+      // query last appended character
+      char last_char();
+
+    public: // syntax sugar
+      void append_indentation();
+      void append_optional_space(void);
+      void append_mandatory_space(void);
+      void append_special_linefeed(void);
+      void append_optional_linefeed(void);
+      void append_mandatory_linefeed(void);
+      void append_scope_opener(AST_Node* node = 0);
+      void append_scope_closer(AST_Node* node = 0);
+      void append_comma_separator(void);
+      void append_colon_separator(void);
+      void append_delimiter(void);
+
+  };
+
+}
+
+#endif

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

@@ -0,0 +1,260 @@
+#include "sass.hpp"
+#include "ast.hpp"
+#include "environment.hpp"
+
+namespace Sass {
+
+  template <typename T>
+  Environment<T>::Environment(bool is_shadow)
+  : local_frame_(environment_map<std::string, T>()),
+    parent_(0), is_shadow_(false)
+  { }
+  template <typename T>
+  Environment<T>::Environment(Environment<T>* env, bool is_shadow)
+  : local_frame_(environment_map<std::string, T>()),
+    parent_(env), is_shadow_(is_shadow)
+  { }
+  template <typename T>
+  Environment<T>::Environment(Environment<T>& env, bool is_shadow)
+  : local_frame_(environment_map<std::string, T>()),
+    parent_(&env), is_shadow_(is_shadow)
+  { }
+
+  // link parent to create a stack
+  template <typename T>
+  void Environment<T>::link(Environment& env) { parent_ = &env; }
+  template <typename T>
+  void Environment<T>::link(Environment* env) { parent_ = env; }
+
+  // this is used to find the global frame
+  // which is the second last on the stack
+  template <typename T>
+  bool Environment<T>::is_lexical() const
+  {
+    return !! parent_ && parent_->parent_;
+  }
+
+  // only match the real root scope
+  // there is still a parent around
+  // not sure what it is actually use for
+  // I guess we store functions etc. there
+  template <typename T>
+  bool Environment<T>::is_global() const
+  {
+    return parent_ && ! parent_->parent_;
+  }
+
+  template <typename T>
+  environment_map<std::string, T>& Environment<T>::local_frame() {
+    return local_frame_;
+  }
+
+  template <typename T>
+  bool Environment<T>::has_local(const std::string& key) const
+  { return local_frame_.find(key) != local_frame_.end(); }
+
+  template <typename T> EnvResult
+  Environment<T>::find_local(const std::string& key)
+  {
+    auto end = local_frame_.end();
+    auto it = local_frame_.find(key);
+    return EnvResult(it, it != end);
+  }
+
+  template <typename T>
+  T& Environment<T>::get_local(const std::string& key)
+  { return local_frame_[key]; }
+
+  template <typename T>
+  void Environment<T>::set_local(const std::string& key, const T& val)
+  {
+    local_frame_[key] = val;
+  }
+  template <typename T>
+  void Environment<T>::set_local(const std::string& key, T&& val)
+  {
+    local_frame_[key] = val;
+  }
+
+  template <typename T>
+  void Environment<T>::del_local(const std::string& key)
+  { local_frame_.erase(key); }
+
+  template <typename T>
+  Environment<T>* Environment<T>::global_env()
+  {
+    Environment* cur = this;
+    while (cur->is_lexical()) {
+      cur = cur->parent_;
+    }
+    return cur;
+  }
+
+  template <typename T>
+  bool Environment<T>::has_global(const std::string& key)
+  { return global_env()->has(key); }
+
+  template <typename T>
+  T& Environment<T>::get_global(const std::string& key)
+  { return (*global_env())[key]; }
+
+  template <typename T>
+  void Environment<T>::set_global(const std::string& key, const T& val)
+  {
+    global_env()->local_frame_[key] = val;
+  }
+  template <typename T>
+  void Environment<T>::set_global(const std::string& key, T&& val)
+  {
+    global_env()->local_frame_[key] = val;
+  }
+
+  template <typename T>
+  void Environment<T>::del_global(const std::string& key)
+  { global_env()->local_frame_.erase(key); }
+
+  template <typename T>
+  Environment<T>* Environment<T>::lexical_env(const std::string& key)
+  {
+    Environment* cur = this;
+    while (cur) {
+      if (cur->has_local(key)) {
+        return cur;
+      }
+      cur = cur->parent_;
+    }
+    return this;
+  }
+
+  // see if we have a lexical variable
+  // move down the stack but stop before we
+  // reach the global frame (is not included)
+  template <typename T>
+  bool Environment<T>::has_lexical(const std::string& key) const
+  {
+    auto cur = this;
+    while (cur->is_lexical()) {
+      if (cur->has_local(key)) return true;
+      cur = cur->parent_;
+    }
+    return false;
+  }
+
+  // see if we have a lexical we could update
+  // either update already existing lexical value
+  // or if flag is set, we create one if no lexical found
+  template <typename T>
+  void Environment<T>::set_lexical(const std::string& key, const T& val)
+  {
+    Environment<T>* cur = this;
+    bool shadow = false;
+    while ((cur && cur->is_lexical()) || shadow) {
+      EnvResult rv(cur->find_local(key));
+      if (rv.found) {
+        rv.it->second = val;
+        return;
+      }
+      shadow = cur->is_shadow();
+      cur = cur->parent_;
+    }
+    set_local(key, val);
+  }
+  // this one moves the value
+  template <typename T>
+  void Environment<T>::set_lexical(const std::string& key, T&& val)
+  {
+    Environment<T>* cur = this;
+    bool shadow = false;
+    while ((cur && cur->is_lexical()) || shadow) {
+      EnvResult rv(cur->find_local(key));
+      if (rv.found) {
+        rv.it->second = val;
+        return;
+      }
+      shadow = cur->is_shadow();
+      cur = cur->parent_;
+    }
+    set_local(key, val);
+  }
+
+  // look on the full stack for key
+  // include all scopes available
+  template <typename T>
+  bool Environment<T>::has(const std::string& key) const
+  {
+    auto cur = this;
+    while (cur) {
+      if (cur->has_local(key)) {
+        return true;
+      }
+      cur = cur->parent_;
+    }
+    return false;
+  }
+
+  // look on the full stack for key
+  // include all scopes available
+  template <typename T> EnvResult
+  Environment<T>::find(const std::string& key)
+  {
+    auto cur = this;
+    while (true) {
+      EnvResult rv(cur->find_local(key));
+      if (rv.found) return rv;
+      cur = cur->parent_;
+      if (!cur) return rv;
+    }
+  };
+
+  // use array access for getter and setter functions
+  template <typename T>
+  T& Environment<T>::get(const std::string& key)
+  {
+    auto cur = this;
+    while (cur) {
+      if (cur->has_local(key)) {
+        return cur->get_local(key);
+      }
+      cur = cur->parent_;
+    }
+    return get_local(key);
+  }
+
+  // use array access for getter and setter functions
+  template <typename T>
+  T& Environment<T>::operator[](const std::string& key)
+  {
+    auto cur = this;
+    while (cur) {
+      if (cur->has_local(key)) {
+        return cur->get_local(key);
+      }
+      cur = cur->parent_;
+    }
+    return get_local(key);
+  }
+/*
+  #ifdef DEBUG
+  template <typename T>
+  size_t Environment<T>::print(std::string prefix)
+  {
+    size_t indent = 0;
+    if (parent_) indent = parent_->print(prefix) + 1;
+    std::cerr << prefix << std::string(indent, ' ') << "== " << this << std::endl;
+    for (typename environment_map<std::string, T>::iterator i = local_frame_.begin(); i != local_frame_.end(); ++i) {
+      if (!ends_with(i->first, "[f]") && !ends_with(i->first, "[f]4") && !ends_with(i->first, "[f]2")) {
+        std::cerr << prefix << std::string(indent, ' ') << i->first << " " << i->second;
+        if (Value* val = Cast<Value>(i->second))
+        { std::cerr << " : " << val->to_string(); }
+        std::cerr << std::endl;
+      }
+    }
+    return indent ;
+  }
+  #endif
+*/
+  // compile implementation for AST_Node
+  template class Environment<AST_Node_Obj>;
+
+}
+