sassc 0.0.9 → 0.0.10

data/ext/libsass/context.cpp

@@ -4,40 +4,40 @@
 #define PATH_SEP ':'
 #endif
 
-#ifndef SASS_AST
 #include "ast.hpp"
-#endif
-
+#include "util.hpp"
+#include "sass.h"
 #include "context.hpp"
+#include "plugins.hpp"
 #include "constants.hpp"
 #include "parser.hpp"
 #include "file.hpp"
 #include "inspect.hpp"
-#include "output_nested.hpp"
-#include "output_compressed.hpp"
+#include "output.hpp"
 #include "expand.hpp"
 #include "eval.hpp"
 #include "contextualize.hpp"
+#include "cssize.hpp"
 #include "extend.hpp"
 #include "remove_placeholders.hpp"
-#include "copy_c_str.hpp"
 #include "color_names.hpp"
 #include "functions.hpp"
 #include "backtrace.hpp"
 #include "sass2scss.h"
-
-#ifndef SASS_PRELEXER
 #include "prelexer.hpp"
-#endif
+#include "emitter.hpp"
 
-#include <iomanip>
-#include <iostream>
+#include <string>
+#include <cstdlib>
 #include <cstring>
+#include <iomanip>
 #include <sstream>
+#include <iostream>
 
 namespace Sass {
   using namespace Constants;
   using namespace File;
+  using namespace Sass;
   using std::cerr;
   using std::endl;
 
@@ -50,20 +50,24 @@ namespace Sass {
 
 
   Context::Context(Context::Data initializers)
-  : mem(Memory_Manager<AST_Node>()),
+  : // Output(this),
+    mem(Memory_Manager<AST_Node>()),
     source_c_str            (initializers.source_c_str()),
     sources                 (vector<const char*>()),
+    plugin_paths            (initializers.plugin_paths()),
     include_paths           (initializers.include_paths()),
     queue                   (vector<Sass_Queued>()),
     style_sheets            (map<string, Block*>()),
-    source_map              (resolve_relative_path(initializers.output_path(), initializers.source_map_file(), get_cwd())),
+    emitter (this),
     c_functions             (vector<Sass_C_Function_Callback>()),
-    image_path              (initializers.image_path()),
+    indent                  (initializers.indent()),
+    linefeed                (initializers.linefeed()),
     input_path              (make_canonical_path(initializers.input_path())),
     output_path             (make_canonical_path(initializers.output_path())),
     source_comments         (initializers.source_comments()),
     output_style            (initializers.output_style()),
     source_map_file         (make_canonical_path(initializers.source_map_file())),
+    source_map_root         (initializers.source_map_root()), // pass-through
     source_map_embed        (initializers.source_map_embed()),
     source_map_contents     (initializers.source_map_contents()),
     omit_source_map_url     (initializers.omit_source_map_url()),
@@ -72,9 +76,10 @@ namespace Sass {
     names_to_colors         (map<string, Color*>()),
     colors_to_names         (map<int, string>()),
     precision               (initializers.precision()),
-    _skip_source_map_update (initializers._skip_source_map_update()),
+    plugins(),
     subset_map              (Subset_Map<string, pair<Complex_Selector*, Compound_Selector*> >())
   {
+
     cwd = get_cwd();
 
     // enforce some safe defaults
@@ -85,9 +90,19 @@ namespace Sass {
     include_paths.push_back(cwd);
     collect_include_paths(initializers.include_paths_c_str());
     collect_include_paths(initializers.include_paths_array());
+    collect_plugin_paths(initializers.plugin_paths_c_str());
+    collect_plugin_paths(initializers.plugin_paths_array());
 
     setup_color_map();
 
+    for (size_t i = 0, S = plugin_paths.size(); i < S; ++i) {
+      plugins.load_plugins(plugin_paths[i]);
+    }
+
+    for(auto fn : plugins.get_functions()) {
+      c_functions.push_back(fn);
+    }
+
     string entry_point = initializers.entry_point();
     if (!entry_point.empty()) {
       string result(add_file(entry_point));
@@ -95,6 +110,9 @@ namespace Sass {
         throw "File to read not found or unreadable: " + entry_point;
       }
     }
+
+    emitter.set_filename(output_path);
+
   }
 
   Context::~Context()
@@ -110,7 +128,7 @@ namespace Sass {
     size_t i = 0;
     while (color_names[i]) {
       string name(color_names[i]);
-      Color* value = new (mem) Color("[COLOR TABLE]", Position(),
+      Color* value = new (mem) Color(ParserState("[COLOR TABLE]"),
                                      color_values[i*4],
                                      color_values[i*4+1],
                                      color_values[i*4+2],
@@ -118,9 +136,9 @@ namespace Sass {
       names_to_colors[name] = value;
       // only map fully opaque colors
       if (color_values[i*4+3] >= 1) {
-        int numval = color_values[i*4]*0x10000;
-        numval += color_values[i*4+1]*0x100;
-        numval += color_values[i*4+2];
+        int numval = static_cast<int>(color_values[i*4])*0x10000;
+        numval += static_cast<int>(color_values[i*4+1])*0x100;
+        numval += static_cast<int>(color_values[i*4+2]);
         colors_to_names[numval] = name;
       }
       ++i;
@@ -154,7 +172,6 @@ namespace Sass {
 
   void Context::collect_include_paths(const char** paths_array)
   {
-    if (*include_paths.back().rbegin() != '/') include_paths.back() += '/';
     if (paths_array) {
       for (size_t i = 0; paths_array[i]; i++) {
         collect_include_paths(paths_array[i]);
@@ -162,12 +179,45 @@ namespace Sass {
     }
   }
 
+  void Context::collect_plugin_paths(const char* paths_str)
+  {
+
+    if (paths_str) {
+      const char* beg = paths_str;
+      const char* end = Prelexer::find_first<PATH_SEP>(beg);
+
+      while (end) {
+        string path(beg, end - beg);
+        if (!path.empty()) {
+          if (*path.rbegin() != '/') path += '/';
+          plugin_paths.push_back(path);
+        }
+        beg = end + 1;
+        end = Prelexer::find_first<PATH_SEP>(beg);
+      }
+
+      string path(beg);
+      if (!path.empty()) {
+        if (*path.rbegin() != '/') path += '/';
+        plugin_paths.push_back(path);
+      }
+    }
+  }
+
+  void Context::collect_plugin_paths(const char** paths_array)
+  {
+    if (paths_array) {
+      for (size_t i = 0; paths_array[i]; i++) {
+        collect_plugin_paths(paths_array[i]);
+      }
+    }
+  }
   void Context::add_source(string load_path, string abs_path, const char* contents)
   {
     sources.push_back(contents);
     included_files.push_back(abs_path);
     queue.push_back(Sass_Queued(load_path, abs_path, contents));
-    source_map.source_index.push_back(sources.size() - 1);
+    emitter.add_source_index(sources.size() - 1);
     include_links.push_back(resolve_relative_path(abs_path, source_map_file, cwd));
   }
 
@@ -226,31 +276,15 @@ namespace Sass {
 
   char* Context::compile_block(Block* root)
   {
-    char* result = 0;
     if (!root) return 0;
-    switch (output_style) {
-      case COMPRESSED: {
-        Output_Compressed output_compressed(this);
-        root->perform(&output_compressed);
-        string output = output_compressed.get_buffer();
-        if (source_map_file != "" && !omit_source_map_url) {
-          output += format_source_mapping_url(source_map_file);
-        }
-        result = copy_c_str(output.c_str());
-      } break;
-
-      default: {
-        Output_Nested output_nested(source_comments, this);
-        root->perform(&output_nested);
-        string output = output_nested.get_buffer();
-        if (source_map_file != "" && !omit_source_map_url) {
-          output += "\n" + format_source_mapping_url(source_map_file);
-        }
-        result = copy_c_str(output.c_str());
-
-      } break;
+    root->perform(&emitter);
+    emitter.finalize();
+    OutputBuffer emitted = emitter.get_buffer();
+    string output = emitted.buffer;
+    if (source_map_file != "" && !omit_source_map_url) {
+      output += linefeed + format_source_mapping_url(source_map_file);
     }
-    return result;
+    return sass_strdup(output.c_str());
   }
 
   Block* Context::parse_file()
@@ -263,7 +297,7 @@ namespace Sass {
         0, 0
       );
       import_stack.push_back(import);
-      Parser p(Parser::from_c_str(queue[i].source, *this, queue[i].abs_path, Position(1 + i, 1, 1)));
+      Parser p(Parser::from_c_str(queue[i].source, *this, ParserState(queue[i].abs_path, i)));
       Block* ast = p.parse();
       sass_delete_import(import_stack.back());
       import_stack.pop_back();
@@ -272,7 +306,7 @@ namespace Sass {
     }
     if (root == 0) return 0;
     Env tge;
-    Backtrace backtrace(0, "", Position(), "");
+    Backtrace backtrace(0, ParserState("", 0), "");
     register_built_in_functions(*this, &tge);
     for (size_t i = 0, S = c_functions.size(); i < S; ++i) {
       register_c_function(*this, &tge, c_functions[i]);
@@ -280,10 +314,9 @@ namespace Sass {
     Eval eval(*this, &tge, &backtrace);
     Contextualize contextualize(*this, &eval, &tge, &backtrace);
     Expand expand(*this, &eval, &contextualize, &tge, &backtrace);
-    // Inspect inspect(this);
-    // Output_Nested output_nested(*this);
-
+    Cssize cssize(*this, &tge, &backtrace);
     root = root->perform(&expand)->block();
+    root = root->perform(&cssize)->block();
     if (!subset_map.empty()) {
       Extend extend(*this, subset_map);
       root->perform(&extend);
@@ -300,11 +333,12 @@ namespace Sass {
     if (!source_c_str) return 0;
     queue.clear();
     if(is_indented_syntax_src) {
-      char * contents = sass2scss(source_c_str, SASS2SCSS_PRETTIFY_1);
+      char * contents = sass2scss(source_c_str, SASS2SCSS_PRETTIFY_1 | SASS2SCSS_KEEP_COMMENT);
       add_source(input_path, input_path, contents);
+      delete [] source_c_str;
       return parse_file();
     }
-    add_source(input_path, input_path, strdup(source_c_str));
+    add_source(input_path, input_path, source_c_str);
     return parse_file();
   }
 
@@ -324,7 +358,7 @@ namespace Sass {
   {
     string url = resolve_relative_path(file, output_path, cwd);
     if (source_map_embed) {
-      string map = source_map.generate_source_map(*this);
+      string map = emitter.generate_source_map(*this);
       istringstream is( map );
       ostringstream buffer;
       base64::encoder E;
@@ -339,8 +373,8 @@ namespace Sass {
   {
     if (source_map_file == "") return 0;
     char* result = 0;
-    string map = source_map.generate_source_map(*this);
-    result = copy_c_str(map.c_str());
+    string map = emitter.generate_source_map(*this);
+    result = sass_strdup(map.c_str());
     return result;
   }
 
@@ -378,8 +412,7 @@ namespace Sass {
 
   void register_overload_stub(Context& ctx, string name, Env* env)
   {
-    Definition* stub = new (ctx.mem) Definition("[built-in function]",
-                                            Position(),
+    Definition* stub = new (ctx.mem) Definition(ParserState("[built-in function]"),
                                             0,
                                             name,
                                             0,
@@ -477,8 +510,6 @@ namespace Sass {
     // Boolean Functions
     register_function(ctx, not_sig, sass_not, env);
     register_function(ctx, if_sig, sass_if, env);
-    // Path Functions
-    register_function(ctx, image_url_sig, image_url, env);
     // Misc Functions
     register_function(ctx, inspect_sig, inspect, env);
     register_function(ctx, unique_id_sig, unique_id, env);

data/ext/libsass/context.hpp

@@ -1,47 +1,27 @@
-#define SASS_CONTEXT
+#ifndef SASS_CONTEXT_H
+#define SASS_CONTEXT_H
 
 #include <string>
 #include <vector>
 #include <map>
-#include "kwd_arg_macros.hpp"
 
-#ifndef SASS_MEMORY_MANAGER
-#include "memory_manager.hpp"
-#endif
+#define BUFFERSIZE 255
+#include "b64/encode.h"
 
-#ifndef SASS_ENVIRONMENT
+#include "ast_fwd_decl.hpp"
+#include "kwd_arg_macros.hpp"
+#include "memory_manager.hpp"
 #include "environment.hpp"
-#endif
-
-#ifndef SASS_SOURCE_MAP
 #include "source_map.hpp"
-#endif
-
-#ifndef SASS_SUBSET_MAP
 #include "subset_map.hpp"
-#endif
-
-#define BUFFERSIZE 255
-#include "b64/encode.h"
-
+#include "output.hpp"
+#include "plugins.hpp"
 #include "sass_functions.h"
 
 struct Sass_C_Function_Descriptor;
 
 namespace Sass {
   using namespace std;
-  class AST_Node;
-  class Block;
-  class Expression;
-  class Color;
-  struct Backtrace;
-  // typedef const char* Signature;
-  // struct Context;
-  // typedef Environment<AST_Node*> Env;
-  // typedef Expression* (*Native_Function)(Env&, Context&, Signature, string, size_t);
-
-  enum Output_Style { NESTED, EXPANDED, COMPACT, COMPRESSED, FORMATTED };
-
   struct Sass_Queued {
     string abs_path;
     string load_path;
@@ -50,7 +30,8 @@ namespace Sass {
     Sass_Queued(const string& load_path, const string& abs_path, const char* source);
   };
 
-  struct Context {
+  class Context {
+  public:
     Memory_Manager<AST_Node> mem;
 
     const char* source_c_str;
@@ -64,18 +45,22 @@ namespace Sass {
     vector<string> include_links;
     // vectors above have same size
 
+    vector<string> plugin_paths; // relative paths to load plugins
     vector<string> include_paths; // lookup paths for includes
     vector<Sass_Queued> queue; // queue of files to be parsed
     map<string, Block*> style_sheets; // map of paths to ASTs
-    SourceMap source_map;
+    // SourceMap source_map;
+    Output emitter;
     vector<Sass_C_Function_Callback> c_functions;
 
-    string       image_path; // for the image-url Sass function
+    string       indent; // String to be used for indentation
+    string       linefeed; // String to be used for line feeds
     string       input_path; // for relative paths in src-map
     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
     string       source_map_file; // path to source map file (enables feature)
+    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
@@ -89,24 +74,27 @@ namespace Sass {
     map<int, string>    colors_to_names;
 
     size_t precision; // precision for outputting fractional numbers
-    bool _skip_source_map_update; // status flag to skip source map updates
 
     KWD_ARG_SET(Data) {
       KWD_ARG(Data, const char*,     source_c_str);
       KWD_ARG(Data, string,          entry_point);
       KWD_ARG(Data, string,          input_path);
       KWD_ARG(Data, string,          output_path);
-      KWD_ARG(Data, string,          image_path);
+      KWD_ARG(Data, string,          indent);
+      KWD_ARG(Data, 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, vector<string>,  include_paths);
+      KWD_ARG(Data, vector<string>,  plugin_paths);
       KWD_ARG(Data, bool,            source_comments);
       KWD_ARG(Data, Output_Style,    output_style);
       KWD_ARG(Data, string,          source_map_file);
+      KWD_ARG(Data, 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,            _skip_source_map_update);
       KWD_ARG(Data, bool,            source_map_embed);
       KWD_ARG(Data, bool,            source_map_contents);
       KWD_ARG(Data, Sass_C_Import_Callback, importer);
@@ -132,11 +120,14 @@ namespace Sass {
     vector<string> get_included_files(size_t skip = 0);
 
   private:
+    void collect_plugin_paths(const char* paths_str);
+    void collect_plugin_paths(const char** paths_array);
     void collect_include_paths(const char* paths_str);
     void collect_include_paths(const char** paths_array);
     string format_source_mapping_url(const string& file);
 
     string cwd;
+    Plugins plugins;
 
     // void register_built_in_functions(Env* env);
     // void register_function(Signature sig, Native_Function f, Env* env);
@@ -148,3 +139,5 @@ namespace Sass {
   };
 
 }
+
+#endif