condenser 1.2 → 1.3

data/lib/condenser/transformers/dart_sass_transformer.rb

@@ -0,0 +1,285 @@
+class Condenser::DartSassTransformer < Condenser::NodeProcessor
+
+  @@helper_methods = Set.new
+  
+  ACCEPT = ['text/css', 'text/scss', 'text/sass']
+
+  attr_accessor :options
+  
+  # Use this function to append Modules that contain functions to expose
+  # to dart-sass
+  def self.add_helper_methods(module_to_add = nil, &block)
+    old_methods = self.instance_methods
+    
+    self.include(module_to_add) if module_to_add
+    self.class_eval(&block) if block_given?
+    
+    @@helper_methods.merge(self.instance_methods - old_methods)
+  end
+  
+  add_helper_methods(Condenser::Sass::Functions)
+  
+  def self.syntax
+    :sass
+  end
+  
+  def initialize(dir, options = {})
+    super(dir)
+    npm_install('sass')
+    
+    @options = options.merge({
+      indentedSyntax: self.class.syntax == :sass
+    }).freeze
+  end
+
+  def helper_method_signatures
+    x = @@helper_methods.map do |name|
+      arity = self.method(name).arity
+      signature = []
+      types = []
+      if respond_to?(:"#{name}_signature")
+        send(:"#{name}_signature").each do |arg, type|
+          signature << arg
+          types << type
+        end
+      elsif arity >= 0
+        arity.times.with_index do |a|
+          signature << "$arg#{a}"
+          types << 'String'
+        end
+      end
+      
+      ["#{name}(#{signature.join(', ')})", types]
+    end
+    x
+  end
+  
+  def call(environment, input)
+    @context = environment.new_context_class#.new(environment)
+    
+    options = {
+      verbose: true,
+      file: File.join('/', input[:filename])
+    }.merge(@options)
+    @environment = environment
+    @input = input
+
+    result = exec_runtime(<<-JS)
+      const fs    = require('fs');
+      const sass = require("#{npm_module_path('sass')}");
+      const stdin = process.stdin;
+      stdin.resume();
+      stdin.setEncoding('utf8');
+      
+      // SET STDOUT to sync so that we don't get in an infinte looping waiting
+      // for Ruby to response when we haven't even sent the entire request.
+      if (process.stdout._handle) process.stdout._handle.setBlocking(true)
+        
+      const source = #{JSON.generate(input[:source])};
+      const options = #{JSON.generate(options)};
+
+      var rid = 0;
+      function request(method, ...args) {
+        var trid = rid;
+        rid += 1;
+        console.log(JSON.stringify({ rid: trid, method: method, args: args }) + "\\n");
+        
+
+        var readBuffer = '';
+        var response = null;
+        let chunk = new Buffer(1024);
+        let bytesRead;
+        
+        while (response === null) {
+          try {
+            bytesRead = fs.readSync(stdin.fd, chunk, 0, 1024);
+            if (bytesRead === null) { exit(1); }
+            readBuffer += chunk.toString('utf8', 0, bytesRead);
+            [readBuffer, response] = readResponse(readBuffer);
+          } catch (e) {
+             if (e.code !== 'EAGAIN') { throw e; }
+          }
+        }
+        return response['return'];
+      }
+      
+      function readResponse(buffer) {
+        try {
+          var message = JSON.parse(buffer);
+          return ['', message];
+        } catch(e) {
+          if (e.name === "SyntaxError") {
+            if (e.message.startsWith('Unexpected non-whitespace character after JSON at position ')) {
+              let pos = parseInt(e.message.slice(59));
+              let [b, r] = readResponse(buffer.slice(0,pos));
+              return [b + buffer.slice(pos), r];
+            } else if (e.message.startsWith('Unexpected token { in JSON at position ')) {
+              // This can be removed, once dropping support for node <= v18
+              var pos = parseInt(e.message.slice(39));
+              let [b, r] = readResponse(buffer.slice(0,pos));
+              return [b + buffer.slice(pos), r];
+            } else {
+              return [buffer, null];
+            }
+          } else {
+            console.log(JSON.stringify({method: 'error', args: [e.name, e.message]}) + "\\n");
+            process.exit(1);
+          }
+        }
+      }
+      
+      
+      options.importer = function(url, prev) { return request('load', url, prev); };
+      
+      const call_fn = function(name, types, args) {
+        const transformedArgs = [];
+        request('log', '==================')
+        args.forEach((a, i) => {
+          if (types[i] === 'Map') {
+            // Don't know how to go from SassMap to hash yet
+            transformedArgs.push({});
+          } else if (types[i] === 'List') {
+            // Don't know how to go from SassList to hash yet
+            transformedArgs.push([]);
+          } else if (!(a instanceof sass.types[types[i]])) {
+            throw "$url: Expected a string."; 
+          } else {
+            transformedArgs.push(a.getValue());
+          }
+           
+
+          // if (types[i] === 'List') { a = a.contents(); }
+        });
+        request('log', name, transformedArgs, types)
+        return new sass.types.String(request('call', name, transformedArgs));
+      }
+      options.functions = {};
+      #{JSON.generate(helper_method_signatures)}.forEach( (f) => {
+        let name = f[0].replace(/-/g, '_').replace(/(^[^\\(]+)\\(.*\\)$/, '$1');
+        options.functions[f[0]] = (...a) => call_fn(name, f[1], a);
+      })
+      
+      try {
+        options.data = source;
+        const result = sass.renderSync(options);
+        request('result', result.css.toString());
+        process.exit(0);
+      } catch(e) {
+        request('error', e.name, e.message);
+        process.exit(1);
+      }
+    JS
+    
+    input[:source] = result
+    # input[:map] = map.to_json({})
+    input[:linked_assets]         += @context.links
+    input[:process_dependencies]  += @context.dependencies
+  end
+  
+  def find(importee, importer = nil)
+    # importer ||= @input[:source_file]
+    @environment.find(expand_path(importee, importer), nil, accept: ACCEPT)
+  end
+  
+  def resolve(importee, importer = nil)
+    # importer ||= @input[:source_file]
+    @environment.resolve(expand_path(importee, importer), accept: ACCEPT)
+  end
+  
+  def expand_path(path, base=nil)
+    if path.start_with?('.')
+      File.expand_path(path, File.dirname(base)).delete_prefix(File.expand_path('.') + '/')
+    else
+      File.expand_path(path).delete_prefix(File.expand_path('.') + '/')
+    end
+  end
+  
+  def exec_runtime(script)
+    io = IO.popen([binary, '-e', script], 'r+')
+    buffer = ''
+    result = nil
+    
+    begin
+      while IO.select([io]) && io_read = io.read_nonblock(1_024)
+        buffer << io_read
+        messages = buffer.split("\n\n")
+        buffer = buffer.end_with?("\n\n") ? '' : messages.pop
+        
+        messages.each do |message|
+          message = JSON.parse(message)
+
+          ret = case message['method']
+          when 'result'
+            result = message['args'][0]
+            nil
+          when 'load'
+            importee = message['args'][0]
+            importer = message['args'][1]
+            
+            if importee.end_with?('*')
+              @context.depend_on(importee)
+              code = ""
+              resolve(importee, importer).each do |f, i|
+                code << "@import '#{f.filename}';\n"
+              end
+              { contents: code, map: nil }
+            else
+              if asset = find(importee)
+                @context.depend_on(asset.filename)
+                { contents: asset.source, map: asset.sourcemap }
+              else
+                @context.depend_on(importee)
+                nil
+              end
+            end
+          when 'error'
+            io.write(JSON.generate({rid: message['rid'], return: nil}))
+            
+            case message['args'][0]
+            when 'AssetNotFound'
+              error_message = "Could not find import \"#{message['args'][1]}\" for \"#{message['args'][2]}\".\n\n"
+              error_message << build_tree(message['args'][3], input, message['args'][2])
+              raise exec_runtime_error(error_message)
+            else
+              raise exec_runtime_error(message['args'][0] + ': ' + message['args'][1])
+            end
+          when 'call'
+            if respond_to?(message['args'][0])
+              send(message['args'][0], *message['args'][1])
+            else
+              puts '!!!'
+            end
+          end
+
+          io.write(JSON.generate({rid: message['rid'], return: ret}))
+        end
+      end
+    rescue Errno::EPIPE, EOFError
+    end
+    
+    io.close
+    if $?.success?
+      result
+    else
+      raise exec_runtime_error(buffer)
+    end
+  end
+  
+  protected
+
+  def condenser_context
+    @context
+  end
+  
+  def condenser_environment
+    @environment
+  end
+
+  
+end
+
+class Condenser::DartScssTransformer < Condenser::DartSassTransformer
+  def self.syntax
+    :scss
+  end
+end

data/lib/condenser/transformers/jst_transformer.rb

@@ -23,32 +23,32 @@ class Condenser::JstTransformer < Condenser::NodeProcessor
       const source = #{JSON.generate(input[:source])};
       const options = #{JSON.generate(opts).gsub(/"@?babel[\/-][^"]+"/) { |m| "require(#{m})"}};
 
-      function globalVar(scope, name) {
-        if (name in scope.globals) {
-          return true;
-        } else if (scope.parent === null || scope.parent === undefined) {
-          return false;
-        } else {
-          return globalVar(scope.parent, name);
-        }
-      }
-
+      let scope = [['document', 'window']];
+      
       options['plugins'].unshift(function({ types: t }) {
         return {
           visitor: {
             Identifier(path, state) {
-              if ( path.parent.type == 'MemberExpression' && path.parent.object != path.node) {
+              if ( path.parent.type === 'MemberExpression' && path.parent.object !== path.node) {
                 return;
               }
-              if ( path.parent.type == 'ImportSpecifier' || path.parent.type == 'ImportDefaultSpecifier' || path.parent.type =='FunctionDeclaration') {
+              
+              if ( path.parent.type === 'ImportSpecifier' ||
+                   path.parent.type === 'ImportDefaultSpecifier' ||
+                   path.parent.type === 'FunctionDeclaration' ||
+                   path.parent.type === 'FunctionExpression' ||
+                   path.parent.type === 'ArrowFunctionExpression' ||
+                   path.parent.type === 'SpreadElement' ||
+                   path.parent.type === 'CatchClause' ) {
+                return;
+              }
+              
+              if ( path.parent.type === 'ObjectProperty' && path.parent.key === path.node ) {
                 return;
               }
 
-              if (
-                path.node.name !== 'document' &&
-                path.node.name !== 'window' &&
-                !(path.node.name in global) &&
-                globalVar(path.scope, path.node.name)
+              if ( !(path.node.name in global) &&
+                   !scope.find((s) => s.find(v => v === path.node.name))
               ) {
                 path.replaceWith(
                   t.memberExpression(t.identifier("locals"), path.node)
@@ -58,6 +58,56 @@ class Condenser::JstTransformer < Condenser::NodeProcessor
           }
         };
       });
+      
+
+      options['plugins'].unshift(function({ types: t }) {
+          return {
+            visitor: {
+              "FunctionDeclaration|FunctionExpression|ArrowFunctionExpression": {
+                enter(path, state) {
+                  if (path.node.id) { scope[scope.length-1].push(path.node.id.name); }
+                  scope.push(path.node.params.map((n) => n.type === 'RestElement' ? n.argument.name : n.name));
+                }
+              },
+              CatchClause: {
+                enter(path, state) {
+                  scope.push([]);
+                  if (path.node.param.name) { scope[scope.length-1].push(path.node.param.name); }
+                }
+              },
+              Scopable: {
+                enter(path, state) {
+                  if (path.node.type !== 'Program' &&
+                      path.node.type !== 'CatchClause' &&
+                      path.parent.type !== 'FunctionDeclaration' &&
+                      path.parent.type !== 'FunctionExpression' &&
+                      path.parent.type !== 'ArrowFunctionExpression' &&
+                      path.parent.type !== 'ExportDefaultDeclaration') {
+                    scope.push([]);
+                  }
+                },
+                exit(path, state) {
+                  if (path.node.type !== 'Program' &&
+                      path.parent.type !== 'ExportDefaultDeclaration') {
+                    scope.pop();
+                  }
+                }
+              },
+              ImportDeclaration(path, state) {
+                path.node.specifiers.forEach((s) => scope[scope.length-1].push(s.local.name));
+              },
+              ClassDeclaration(path, state) {
+                if (path.node.id) {
+                  scope[scope.length-1].push(path.node.id.name)
+                }
+              },
+              VariableDeclaration(path, state) {
+                path.node.declarations.forEach((s) => scope[scope.length-1].push(s.id.name));
+              }
+            }
+          };
+      });
+
 
       try {
         const result = babel.transform(source, options);

data/lib/condenser/transformers/sass/functions.rb

@@ -0,0 +1,133 @@
+# Public: Functions injected into Sass context during Condenser evaluation.
+#
+# This module may be extended to add global functionality to all Condenser
+# Sass environments. Though, scoping your functions to just your environment
+# is preferred.
+#
+# module Condenser::SassProcessor::Functions
+#   def asset_path(path, options = {})
+#   end
+# end
+module Condenser::Sass
+  module Functions
+  
+    # Public: Generate a url for asset path.
+    #
+    # Defaults to Context#asset_path.
+    def asset_path(path, options = {})
+      condenser_context.link_asset(path)
+
+      path = condenser_context.asset_path(path, options)
+      query    = "?#{query}" if query
+      fragment = "##{fragment}" if fragment
+      "#{path}#{query}#{fragment}"
+    end
+    
+    def asset_path_signature
+      {
+        "$path" => "String",
+        "$options: ()" => 'Map'
+      }
+    end
+    
+    # Public: Generate a asset url() link.
+    #
+    # path - String
+    def asset_url(path, options = {})
+      "url(#{asset_path(path, options)})"
+    end
+
+    def asset_url_signature
+      {
+        "$path" => "String",
+        "$options: ()" => 'Map'
+      }
+    end
+    
+    # Public: Generate url for image path.
+    def image_path(path)
+      asset_path(path, type: :image)
+    end
+
+    # Public: Generate a image url() link.
+    def image_url(path)
+      asset_url(path, type: :image)
+    end
+
+    # Public: Generate url for video path.
+    def video_path(path)
+      asset_path(path, type: :video)
+    end
+
+    # Public: Generate a video url() link.
+    def video_url(path)
+      asset_url(path, type: :video)
+    end
+
+    # Public: Generate url for audio path.
+    def audio_path(path)
+      asset_path(path, type: :audio)
+    end
+
+    # Public: Generate a audio url() link.
+    def audio_url(path)
+      asset_url(path, type: :audio)
+    end
+
+    # Public: Generate url for font path.
+    def font_path(path)
+      asset_path(path, type: :font)
+    end
+
+    # Public: Generate a font url() link.
+    def font_url(path)
+      asset_url(path, type: :font)
+    end
+
+    # Public: Generate url for javascript path.
+    def javascript_path(path)
+      asset_path(path, type: :javascript)
+    end
+
+    # Public: Generate a javascript url() link.
+    def javascript_url(path)
+      asset_url(path, type: :javascript)
+    end
+
+    # Public: Generate url for stylesheet path.
+    def stylesheet_path(path)
+      asset_path(path, type: :stylesheet)
+    end
+
+    # Public: Generate a stylesheet url() link.
+    def stylesheet_url(path)
+      asset_url(path, type: :stylesheet)
+    end
+
+    # Public: Generate a data URI for asset path.
+    def asset_data_url(path)
+      url = condenser_environment.asset_data_uri(path.value)
+      Sass::Script::String.new("url(" + url + ")")
+    end
+
+    protected
+      # Public: The Environment.
+      #
+      # Returns Condenser::Environment.
+      def condenser_context
+        options[:condenser][:context]
+      end
+    
+      def condenser_environment
+        options[:condenser][:environment]
+      end
+
+      # Public: Mutatable set of dependencies.
+      #
+      # Returns a Set.
+      def condenser_dependencies
+        options[:asset][:process_dependencies]
+      end
+
+  end
+end

data/lib/condenser/transformers/sass/importer.rb

@@ -0,0 +1,48 @@
+require "sassc"
+
+class Condenser::Sass::Importer < SassC::Importer
+    
+  def imports(name, base)
+    name = expand_path(name, base)
+    env = options[:condenser][:environment]
+    accept = extensions.keys.map { |x| options[:condenser][:environment].extensions[x] }
+
+    options[:asset][:process_dependencies] << [name, accept.map{ |i| [i] }]
+
+    imports = []
+    env.resolve(name, accept: accept).sort_by(&:filename).each do |asset|
+      next if asset.filename == options[:filename]
+      imports << Import.new(asset.filename, source: asset.source, source_map_path: nil)
+    end
+
+    if imports.empty? && env.npm_path
+      package = File.join(env.npm_path, name, 'package.json')
+      if File.exist?(package)
+        package = JSON.parse(File.read(package))
+        if package['style']
+          imports << Import.new(name, source: File.read(File.join(env.npm_path, name, package['style'])), source_map_path: nil)
+        end
+      end
+    end
+
+    raise Condenser::FileNotFound, "couldn't find file '#{name}'" if imports.empty?
+
+    imports
+  end
+  
+  # Allow .css files to be @imported
+  def extensions
+    { '.sass' => :sass, '.scss' => :scss, '.css' => :scss }
+  end
+  
+  private
+
+    def expand_path(path, base=nil)
+      if path.start_with?('.')
+        File.expand_path(path, File.dirname(base)).delete_prefix(File.expand_path('.') + '/')
+      else
+        File.expand_path(path).delete_prefix(File.expand_path('.') + '/')
+      end
+    end
+      
+end

data/lib/condenser/transformers/sass.rb

@@ -0,0 +1,4 @@
+module Condenser::Sass
+  autoload :Functions, 'condenser/transformers/sass/functions'
+  autoload :Importer, 'condenser/transformers/sass/importer'
+end