sassc 1.8.1 → 1.8.2

data/ext/libsass/src/context.hpp

@@ -11,13 +11,15 @@
 #include "ast_fwd_decl.hpp"
 #include "kwd_arg_macros.hpp"
 #include "memory_manager.hpp"
+#include "ast_fwd_decl.hpp"
+#include "sass_context.hpp"
 #include "environment.hpp"
 #include "source_map.hpp"
 #include "subset_map.hpp"
 #include "output.hpp"
 #include "plugins.hpp"
 #include "file.hpp"
-#include "sass.h"
+
 
 struct Sass_Function;
 
@@ -25,30 +27,48 @@ namespace Sass {
 
   class Context {
   public:
+    void import_url (Import* imp, std::string load_path, const std::string& ctx_path);
+    bool call_headers(const std::string& load_path, const char* ctx_path, ParserState& pstate, Import* imp)
+    { return call_loader(load_path, ctx_path, pstate, imp, c_headers, false); };
+    bool call_importers(const std::string& load_path, const char* ctx_path, ParserState& pstate, Import* imp)
+    { return call_loader(load_path, ctx_path, pstate, imp, c_importers, true); };
+
+  private:
+    bool call_loader(const std::string& load_path, const char* ctx_path, ParserState& pstate, Import* imp, std::vector<Sass_Importer_Entry> importers, bool only_one = true);
+
+  public:
+    const std::string CWD;
+    std::string entry_path;
     size_t head_imports;
     Memory_Manager mem;
+    Plugins plugins;
+    Output emitter;
+
+    // resources add under our control
+    // these are guaranteed to be freed
+    std::vector<char*> strings;
+    std::vector<Resource> resources;
+    std::map<const std::string, const StyleSheet> sheets;
+    Subset_Map<std::string, std::pair<Complex_Selector*, Compound_Selector*> > subset_map;
+    std::vector<Sass_Import_Entry> import_stack;
 
-    struct Sass_Options* c_options;
     struct Sass_Compiler* c_compiler;
-    char* source_c_str;
+    struct Sass_Options* c_options;
 
-    // c-strs containing Sass file contents
-    // we will overtake ownership of memory
-    std::vector<char*> sources;
-    // strings get freed with context
-    std::vector<char*> strings;
     // absolute paths to includes
     std::vector<std::string> included_files;
-    // relative links to includes
-    std::vector<std::string> include_links;
+    // relative includes for sourcemap
+    std::vector<std::string> srcmap_links;
     // vectors above have same size
 
     std::vector<std::string> plugin_paths; // relative paths to load plugins
     std::vector<std::string> include_paths; // lookup paths for includes
-    std::vector<Sass_Queued> queue; // queue of files to be parsed
-    std::map<std::string, Block*> style_sheets; // map of paths to ASTs
-    // SourceMap source_map;
-    Output emitter;
+
+
+
+
+
+    void apply_custom_headers(Block* root, const char* path, ParserState pstate);
 
     std::vector<Sass_Importer_Entry> c_headers;
     std::vector<Sass_Importer_Entry> c_importers;
@@ -58,71 +78,25 @@ namespace Sass {
     void add_c_importer(Sass_Importer_Entry importer);
     void add_c_function(Sass_Function_Entry function);
 
-    std::string       indent; // String to be used for indentation
-    std::string       linefeed; // String to be used for line feeds
-    std::string       input_path; // for relative paths in src-map
-    std::string       output_path; // for relative paths to the output
-    bool         source_comments; // for inline debug comments in css output
-    Output_Style output_style; // output style for the generated css code
-    std::string       source_map_file; // path to source map file (enables feature)
-    std::string       source_map_root; // path for sourceRoot property (pass-through)
-    bool         source_map_embed; // embed in sourceMappingUrl (as data-url)
-    bool         source_map_contents; // insert included contents into source map
-    bool         omit_source_map_url; // disable source map comment in css output
-    bool         is_indented_syntax_src; // treat source string as sass
-
-    // overload import calls
-    std::vector<Sass_Import_Entry> import_stack;
-
-    size_t precision; // precision for outputting fractional numbers
-
-    KWD_ARG_SET(Data) {
-      KWD_ARG(Data, struct Sass_Options*,      c_options)
-      KWD_ARG(Data, struct Sass_Compiler*,     c_compiler)
-      KWD_ARG(Data, char*,                     source_c_str)
-      KWD_ARG(Data, std::string,               entry_point)
-      KWD_ARG(Data, std::string,               input_path)
-      KWD_ARG(Data, std::string,               output_path)
-      KWD_ARG(Data, std::string,               indent)
-      KWD_ARG(Data, std::string,               linefeed)
-      KWD_ARG(Data, const char*,               include_paths_c_str)
-      KWD_ARG(Data, const char*,               plugin_paths_c_str)
-      // KWD_ARG(Data, const char**,              include_paths_array)
-      // KWD_ARG(Data, const char**,              plugin_paths_array)
-      KWD_ARG(Data, std::vector<std::string>,  include_paths)
-      KWD_ARG(Data, std::vector<std::string>,  plugin_paths)
-      KWD_ARG(Data, bool,                      source_comments)
-      KWD_ARG(Data, Output_Style,              output_style)
-      KWD_ARG(Data, std::string,               source_map_file)
-      KWD_ARG(Data, std::string,               source_map_root)
-      KWD_ARG(Data, bool,                      omit_source_map_url)
-      KWD_ARG(Data, bool,                      is_indented_syntax_src)
-      KWD_ARG(Data, size_t,                    precision)
-      KWD_ARG(Data, bool,                      source_map_embed)
-      KWD_ARG(Data, bool,                      source_map_contents)
-    };
-
-    Context(Data);
-    ~Context();
-    static std::string get_cwd();
-
-    Block* parse_file();
-    Block* parse_string();
-    void add_source(std::string, std::string, char*);
-
-    std::string add_file(const std::string& imp_path, bool delay = false);
-    std::string add_file(const std::string& imp_path, const std::string& abs_path, ParserState pstate);
-
-    void process_queue_entry(Sass_Queued& entry, size_t idx);
-
-    // allow to optionally overwrite the input path
-    // default argument for input_path is std::string("stdin")
-    // usefull to influence the source-map generating etc.
-    char* compile_file();
-    char* compile_string();
-    char* compile_block(Block* root);
-    char* generate_source_map();
-
+    const std::string indent; // String to be used for indentation
+    const std::string linefeed; // String to be used for line feeds
+    const std::string input_path; // for relative paths in src-map
+    const std::string output_path; // for relative paths to the output
+    const std::string source_map_file; // path to source map file (enables feature)
+    const std::string source_map_root; // path for sourceRoot property (pass-through)
+
+    virtual ~Context();
+    Context(struct Sass_Context*);
+    virtual Block* parse() = 0;
+    virtual Block* compile();
+    virtual char* render(Block* root);
+    virtual char* render_srcmap();
+
+    void register_resource(const Include&, const Resource&);
+    std::vector<Include> find_includes(const Importer& import);
+    Include load_import(const Importer&, ParserState pstate);
+
+    Sass_Output_Style output_style() { return c_options->output_style; };
     std::vector<std::string> get_included_files(bool skip = false, size_t headers = 0);
 
   private:
@@ -133,8 +107,6 @@ namespace Sass {
     std::string format_embedded_source_map();
     std::string format_source_mapping_url(const std::string& out_path);
 
-    std::string cwd;
-    Plugins plugins;
 
     // void register_built_in_functions(Env* env);
     // void register_function(Signature sig, Native_Function f, Env* env);
@@ -142,7 +114,32 @@ namespace Sass {
     // void register_overload_stub(std::string name, Env* env);
 
   public:
-    Subset_Map<std::string, std::pair<Complex_Selector*, Compound_Selector*> > subset_map;
+    const std::string& cwd() { return CWD; };
+  };
+
+  class File_Context : public Context {
+  public:
+    File_Context(struct Sass_File_Context* ctx)
+    : Context(ctx)
+    { }
+    virtual ~File_Context();
+    virtual Block* parse();
+  };
+
+  class Data_Context : public Context {
+  public:
+    char* source_c_str;
+    char* srcmap_c_str;
+    Data_Context(struct Sass_Data_Context* ctx)
+    : Context(ctx)
+    {
+      source_c_str       = ctx->source_string;
+      srcmap_c_str       = ctx->srcmap_string;
+      ctx->source_string = 0; // passed away
+      ctx->srcmap_string = 0; // passed away
+    }
+    virtual ~Data_Context();
+    virtual Block* parse();
   };
 
 }

data/ext/libsass/src/debugger.hpp

@@ -524,7 +524,9 @@ inline void debug_ast(AST_Node* node, std::string ind, Env* env)
     Number* expression = dynamic_cast<Number*>(node);
     std::cerr << ind << "Number " << expression;
     std::cerr << " (" << pstate_source_position(node) << ")";
-    std::cerr << " [" << expression->value() << expression->unit() << "]" << std::endl;
+    std::cerr << " [" << expression->value() << expression->unit() << "]" <<
+      " [hash: " << expression->hash() << "] " <<
+      std::endl;
   } else if (dynamic_cast<String_Quoted*>(node)) {
     String_Quoted* expression = dynamic_cast<String_Quoted*>(node);
     std::cerr << ind << "String_Quoted " << expression;

data/ext/libsass/src/emitter.cpp

@@ -18,7 +18,8 @@ namespace Sass {
     in_media_block(false),
     in_declaration(false),
     in_space_array(false),
-    in_comma_array(false)
+    in_comma_array(false),
+    in_debug(false)
   { }
 
   // return buffer as string
@@ -27,9 +28,9 @@ namespace Sass {
     return wbuf.buffer;
   }
 
-  Output_Style Emitter::output_style(void)
+  Sass_Output_Style Emitter::output_style(void)
   {
-    return ctx ? ctx->output_style : COMPRESSED;
+    return ctx ? ctx->output_style() : SASS_STYLE_COMPRESSED;
   }
 
   // PROXY METHODS FOR SOURCE MAPS
@@ -37,8 +38,8 @@ namespace Sass {
   void Emitter::add_source_index(size_t idx)
   { wbuf.smap.source_index.push_back(idx); }
 
-  std::string Emitter::generate_source_map(Context &ctx)
-  { return wbuf.smap.generate_source_map(ctx); }
+  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; }
@@ -105,7 +106,7 @@ namespace Sass {
     // write space/lf
     flush_schedules();
 
-    if (in_comment && output_style() == COMPACT) {
+    if (in_comment && output_style() == SASS_STYLE_COMPACT) {
       // unescape comment nodes
       std::string out = comment_to_string(text);
       // add to buffer
@@ -144,8 +145,8 @@ namespace Sass {
 
   void Emitter::append_indentation()
   {
-    if (output_style() == COMPRESSED) return;
-    if (output_style() == COMPACT) return;
+    if (output_style() == SASS_STYLE_COMPRESSED) return;
+    if (output_style() == SASS_STYLE_COMPACT) return;
     if (in_declaration && in_comma_array) return;
     if (scheduled_linefeed && indentation)
       scheduled_linefeed = 1;
@@ -158,13 +159,13 @@ namespace Sass {
   void Emitter::append_delimiter()
   {
     scheduled_delimiter = true;
-    if (output_style() == COMPACT) {
+    if (output_style() == SASS_STYLE_COMPACT) {
       if (indentation == 0) {
         append_mandatory_linefeed();
       } else {
         append_mandatory_space();
       }
-    } else if (output_style() != COMPRESSED) {
+    } else if (output_style() != SASS_STYLE_COMPRESSED) {
       append_optional_linefeed();
     }
   }
@@ -190,7 +191,7 @@ namespace Sass {
 
   void Emitter::append_optional_space()
   {
-    if (output_style() != COMPRESSED && buffer().size()) {
+    if ((output_style() != SASS_STYLE_COMPRESSED || in_debug) && buffer().size()) {
       char lst = buffer().at(buffer().length() - 1);
       if (!isspace(lst) || scheduled_delimiter) {
         append_mandatory_space();
@@ -200,7 +201,7 @@ namespace Sass {
 
   void Emitter::append_special_linefeed()
   {
-    if (output_style() == COMPACT) {
+    if (output_style() == SASS_STYLE_COMPACT) {
       append_mandatory_linefeed();
       for (size_t p = 0; p < indentation; p++)
         append_string(ctx ? ctx->indent : "  ");
@@ -210,7 +211,7 @@ namespace Sass {
   void Emitter::append_optional_linefeed()
   {
     if (in_declaration && in_comma_array) return;
-    if (output_style() == COMPACT) {
+    if (output_style() == SASS_STYLE_COMPACT) {
       append_mandatory_space();
     } else {
       append_mandatory_linefeed();
@@ -219,7 +220,7 @@ namespace Sass {
 
   void Emitter::append_mandatory_linefeed()
   {
-    if (output_style() != COMPRESSED) {
+    if (output_style() != SASS_STYLE_COMPRESSED) {
       scheduled_linefeed = 1;
       scheduled_space = 0;
       // flush_schedules();
@@ -241,9 +242,9 @@ namespace Sass {
   {
     -- indentation;
     scheduled_linefeed = 0;
-    if (output_style() == COMPRESSED)
+    if (output_style() == SASS_STYLE_COMPRESSED)
       scheduled_delimiter = false;
-    if (output_style() == EXPANDED) {
+    if (output_style() == SASS_STYLE_EXPANDED) {
       append_optional_linefeed();
       append_indentation();
     } else {
@@ -253,7 +254,7 @@ namespace Sass {
     if (node) add_close_mapping(node);
     append_optional_linefeed();
     if (indentation != 0) return;
-    if (output_style() != COMPRESSED)
+    if (output_style() != SASS_STYLE_COMPRESSED)
       scheduled_linefeed = 2;
   }
 

data/ext/libsass/src/emitter.hpp

@@ -2,6 +2,7 @@
 #define SASS_EMITTER_H
 
 #include <string>
+#include "sass/base.h"
 #include "source_map.hpp"
 #include "ast_fwd_decl.hpp"
 
@@ -25,7 +26,7 @@ namespace Sass {
       void set_filename(const std::string& str);
       void add_open_mapping(AST_Node* node);
       void add_close_mapping(AST_Node* node);
-      std::string generate_source_map(Context &ctx);
+      std::string render_srcmap(Context &ctx);
       ParserState remap(const ParserState& pstate);
 
     public:
@@ -47,12 +48,14 @@ namespace Sass {
       // nested lists need parentheses
       bool in_space_array;
       bool in_comma_array;
+      // list separators don't get compressed in @debug
+      bool in_debug;
 
     public:
       // return buffer as std::string
       std::string get_buffer(void);
       // flush scheduled space/linefeed
-      Output_Style output_style(void);
+      Sass_Output_Style output_style(void);
       // add outstanding linefeed
       void finalize(void);
       // flush scheduled space/linefeed

data/ext/libsass/src/error_handling.cpp

@@ -1,14 +1,55 @@
+#include "ast.hpp"
 #include "prelexer.hpp"
 #include "backtrace.hpp"
+#include "to_string.hpp"
 #include "error_handling.hpp"
 
 #include <iostream>
 
 namespace Sass {
 
-  Error_Invalid::Error_Invalid(Type type, ParserState pstate, std::string message)
-  : type(type), pstate(pstate), message(message)
-  { }
+  namespace Exception {
+
+    Base::Base(ParserState pstate, std::string msg)
+    : std::runtime_error(msg),
+      msg(msg), pstate(pstate)
+    { }
+
+    const char* Base::what() const throw()
+    {
+      return msg.c_str();
+    }
+
+    InvalidSass::InvalidSass(ParserState pstate, std::string msg)
+    : Base(pstate, msg)
+    { }
+
+
+    InvalidParent::InvalidParent(Selector* parent, Selector* selector)
+    : Base(selector->pstate()), parent(parent), selector(selector)
+    {
+      msg = "Invalid parent selector for \"";
+      msg += selector->to_string(false);
+      msg += "\": \"";
+      msg += parent->to_string(false);;
+      msg += "\"";
+    }
+
+    InvalidArgumentType::InvalidArgumentType(ParserState pstate, std::string fn, std::string arg, std::string type, const Value* value)
+    : Base(pstate), fn(fn), arg(arg), type(type), value(value)
+    {
+      msg  = arg + ": \"";
+      msg += value->to_string(true, 5);
+      msg += "\" is not a " + type;
+      msg += " for `" + fn + "'";
+    }
+
+    InvalidSyntax::InvalidSyntax(ParserState pstate, std::string msg)
+    : Base(pstate, msg)
+    { }
+
+  }
+
 
   void warn(std::string msg, ParserState pstate)
   {
@@ -22,18 +63,48 @@ namespace Sass {
     warn(msg, pstate);
   }
 
-  void deprecated(std::string msg, ParserState pstate)
+  void deprecated_function(std::string msg, ParserState pstate)
   {
     std::string cwd(Sass::File::get_cwd());
+    std::string abs_path(Sass::File::rel2abs(pstate.path, cwd, cwd));
+    std::string rel_path(Sass::File::abs2rel(pstate.path, cwd, cwd));
+    std::string output_path(Sass::File::path_for_console(rel_path, abs_path, pstate.path));
+
     std::cerr << "DEPRECATION WARNING: " << msg << std::endl;
     std::cerr << "will be an error in future versions of Sass." << std::endl;
-    std::string rel_path(Sass::File::resolve_relative_path(pstate.path, cwd, cwd));
-    std::cerr << "        on line " << pstate.line+1 << " of " << rel_path << std::endl;
+    std::cerr << "        on line " << pstate.line+1 << " of " << output_path << std::endl;
+  }
+
+  void deprecated(std::string msg, std::string msg2, ParserState pstate)
+  {
+    std::string cwd(Sass::File::get_cwd());
+    std::string abs_path(Sass::File::rel2abs(pstate.path, cwd, cwd));
+    std::string rel_path(Sass::File::abs2rel(pstate.path, cwd, cwd));
+    std::string output_path(Sass::File::path_for_console(rel_path, pstate.path, pstate.path));
+
+    std::cerr << "DEPRECATION WARNING on line " << pstate.line + 1;
+    if (output_path.length()) std::cerr << " of " << output_path;
+    std::cerr << ":" << std::endl;
+    std::cerr << msg << " and will be an error in future versions of Sass." << std::endl;
+    if (msg2.length()) std::cerr << msg2 << std::endl;
+    std::cerr << std::endl;
+  }
+
+  void deprecated_bind(std::string msg, ParserState pstate)
+  {
+    std::string cwd(Sass::File::get_cwd());
+    std::string abs_path(Sass::File::rel2abs(pstate.path, cwd, cwd));
+    std::string rel_path(Sass::File::abs2rel(pstate.path, cwd, cwd));
+    std::string output_path(Sass::File::path_for_console(rel_path, abs_path, pstate.path));
+
+    std::cerr << "WARNING: " << msg << std::endl;
+    std::cerr << "        on line " << pstate.line+1 << " of " << output_path << std::endl;
+    std::cerr << "This will be an error in future versions of Sass." << std::endl;
   }
 
   void error(std::string msg, ParserState pstate)
   {
-    throw Error_Invalid(Error_Invalid::syntax, pstate, msg);
+    throw Exception::InvalidSyntax(pstate, msg);
   }
 
   void error(std::string msg, ParserState pstate, Backtrace* bt)