condenser 0.0.1

data/lib/condenser/processors/rollup_processor.rb

@@ -0,0 +1,164 @@
+require 'json'
+require 'tmpdir'
+require File.expand_path('../node_processor', __FILE__)
+
+class Condenser
+  class RollupProcessor < NodeProcessor
+
+    ROLLUP_VERSION = '0.56.1'
+    ROLLUP_SOURCE = File.expand_path('../rollup', __FILE__)
+    
+    def self.call(environment, input)
+      new.call(environment, input)
+    end
+    
+    def initialize(options = {})
+      @options = options.merge({}).freeze
+      
+      # @cache_key = [
+      #   self.class.name,
+      #   Condenser::VERSION,
+      #   SOURCE_VERSION,
+      #   @options
+      # ].freeze
+    end
+
+    def call(environment, input)
+      @environment = environment
+      @input = input
+      
+      Dir.mktmpdir do |output_dir|
+        @entry = File.join(output_dir, 'entry.js')
+        input_options = {
+          input: @entry,
+        }
+        output_options = {
+          file: File.join(output_dir, 'result.js'),
+          format: 'iife',
+          sourcemap: true
+        }
+        
+        exec_runtime(<<-JS)
+          const fs    = require('fs');
+          const path  = require('path');
+          const stdin = process.stdin;
+
+
+          var buffer = '';
+          stdin.resume();
+          stdin.setEncoding('utf8');
+          stdin.on('data', function (chunk) {
+            buffer += chunk;
+            try {
+              var message = JSON.parse(buffer);
+              stdin.emit('message', message);
+              buffer = '';
+            } catch(e) {
+              if (e.name !== "SyntaxError") {
+                console.log(JSON.stringify({method: 'error', args: [e.name, e.message]}));
+                process.exit(1);
+              }
+            }
+          });
+
+          const rollup = require("#{ROLLUP_SOURCE}");
+
+          function request(method, args) {
+            var promise = new Promise(function(resolve, reject) {
+              stdin.once('message', function(message) {
+                resolve(message['return']);
+              });
+            });
+  
+            console.log(JSON.stringify({ method: method, args: args }));
+
+            return promise;
+          }
+
+          const inputOptions = #{JSON.generate(input_options)};
+          inputOptions.plugins = [];
+          inputOptions.plugins.push({
+            name: 'erb',
+            resolveId: function (importee, importer) {
+              return request('resolve', [importee, importer]).then(function(value) {
+                return value;
+              });
+            },
+            load: function(id) {
+              return request('load', [id]).then(function(value) {
+                return value;
+              });
+            }
+          });
+          const outputOptions = #{JSON.generate(output_options)};
+
+          async function build() {
+            try {
+              const bundle = await rollup.rollup(inputOptions);
+              await bundle.write(outputOptions);
+              process.exit(0);
+            } catch(e) {
+              console.log(JSON.stringify({method: 'error', args: [e.name, e.message]}));
+              process.exit(1);
+            }
+          }
+
+          build();
+        JS
+        
+        input[:source] = File.read(File.join(output_dir, 'result.js'))
+        input[:source].delete_suffix!("//# sourceMappingURL=result.js.map\n")
+        # asset.map = File.read(File.join(output_dir, 'result.js.map'))
+      end
+    end
+    
+    def exec_runtime(script)
+      io = IO.popen([binary, '-e', script], 'r+')
+      output = ''
+      
+      begin
+        while line = io.readline
+          output << line
+          if message = JSON.parse(output)
+            case message['method']
+            when 'resolve'
+              importee, importer = message['args']
+
+              asset = if importer.nil? && importee == @entry
+                @entry
+              else
+                @environment.find!(importee, importer ? File.dirname(@entry == importer ? @input[:source_file] : importer) : nil)&.source_file
+              end
+
+              io.write(JSON.generate({return: asset}))
+            when 'load'
+              if message['args'].first == @entry
+                io.write(JSON.generate({return: {
+                  code: @input[:source], map: @input[:map]
+                }}))
+              else
+                asset = @environment.find!(message['args'].first)
+                io.write(JSON.generate({return: {
+                  code: asset.source, map: asset.sourcemap
+                }}))
+              end
+            when 'error'
+              raise exec_runtime_error(message['args'][0] + ': ' + message['args'][1])
+            end
+            output = ''
+          end
+        end
+      rescue EOFError
+      end
+      
+      io.close
+      
+      if $?.success?
+        output
+      else
+        raise exec_runtime_error(output)
+      end
+    end
+    
+  end
+end

data/lib/condenser/processors/sass_importer.rb

@@ -0,0 +1,81 @@
+require 'sass/importers'
+
+class Condenser
+  class SassImporter < Sass::Importers::Base
+
+    GLOB = /(\A|\/)(\*|\*\*\/\*)\z/
+
+    def initialize(env)
+      @environment = env
+    end
+      
+    def key(name, options)
+      [self.class.name + ':' + File.dirname(expand_path(name)), File.basename(name)]
+    end
+      
+    def public_url(name, sourcemap_directory)
+      Sass::Util.file_uri_from_path(name)
+    end
+      
+    def find_relative(name, base, options)
+      name = expand_path(name, base)
+      env = options[:condenser][:environment]
+      accept = extensions.keys.map { |x| options[:condenser][:environment].extensions[x] }
+      
+
+      if name.match(GLOB)
+        contents = ""
+        env.resolve(name, accept: accept).sort_by(&:filename).each do |asset|
+          next if asset.filename == options[:filename]
+          contents << "@import \"#{asset.filename}\";\n"
+        end
+        
+        return nil if contents == ""
+        Sass::Engine.new(contents, options.merge(
+          filename: name,
+          importer: self,
+          syntax: :scss
+        ))
+      else
+        asset = options[:condenser][:environment].find(name, accept: accept)
+
+        if asset
+          asset.process
+          Sass::Engine.new(asset.source, options.merge(
+            filename: asset.filename,
+            importer: self,
+            syntax: extensions[asset.ext]
+          ))
+        else
+          nil
+        end
+      end
+    end
+
+    def find(name, options)
+      if options[:condenser]
+        # globs must be relative
+        return if name =~ GLOB
+        super
+      else
+        super
+      end
+    end
+
+    # Allow .css files to be @import'd
+    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
+end

data/lib/condenser/processors/sass_processor.rb

@@ -0,0 +1,300 @@
+require 'sass'
+require 'condenser/processors/sass_importer'
+
+class Condenser
+  # Processor engine class for the SASS/SCSS compiler. Depends on the `sass` gem.
+  #
+  # For more infomation see:
+  #
+  #   https://github.com/sass/sass
+  #   https://github.com/rails/sass-rails
+  #
+  class SassProcessor
+    # autoload :CacheStore, 'sprockets/sass_cache_store'
+
+    # Internal: Defines default sass syntax to use. Exposed so the ScssProcessor
+    # may override it.
+    def self.syntax
+      :sass
+    end
+
+    # Public: Return singleton instance with default options.
+    #
+    # Returns SassProcessor object.
+    def self.instance
+      @instance ||= new
+    end
+
+    def self.call(environment, input)
+      instance.call(environment, input)
+    end
+
+    def self.cache_key
+      instance.cache_key
+    end
+
+    attr_reader :cache_key
+
+    # Public: Initialize template with custom options.
+    #
+    # options - Hash
+    # cache_version - String custom cache version. Used to force a cache
+    #                 change after code changes are made to Sass Functions.
+    #
+    def initialize(options = {}, &block)
+      @cache_version = options[:cache_version]
+      # @cache_key = "#{self.class.name}:#{VERSION}:#{Autoload::Sass::VERSION}:#{@cache_version}".freeze
+      @importer_class = options[:importer] || Condenser::SassImporter || Sass::Importers::Filesystem
+      
+      @sass_config = options[:sass_config] || {}
+      @functions = Module.new do
+        include Functions
+        include options[:functions] if options[:functions]
+        class_eval(&block) if block_given?
+      end
+    end
+
+    def call(environment, input)
+      # context = input[:environment].context_class.new(input)
+
+      engine_options = merge_options({
+        filename:     input[:filename],
+        syntax:       self.class.syntax,
+        cache_store:  nil,#build_cache_store(input, @cache_version),
+        load_paths:   environment.path,#.environment.paths.map { |p| @importer_class.new(p.to_s) },
+       importer:     @importer_class.new(environment),
+        condenser: {
+          context: environment.new_context_class,
+          environment: environment
+        }
+      })
+
+      engine = Sass::Engine.new(input[:source], engine_options)
+
+      css, map = engine.render_with_sourcemap('')
+      # Utils.module_include(Sass::Script::Functions, @functions) do
+      #   engine.render_with_sourcemap('')
+      # end
+
+      css = css.delete_suffix!("\n/*# sourceMappingURL= */\n")
+
+
+      input[:source] = css
+      # input[:map] = map.to_json({})
+    end
+
+    private
+
+    # Public: Build the cache store to be used by the Sass engine.
+    #
+    # input - the input hash.
+    # version - the cache version.
+    #
+    # Override this method if you need to use a different cache than the
+    # Sprockets cache.
+    def build_cache_store(input, version)
+      CacheStore.new(input[:cache], version)
+    end
+
+    def merge_options(options)
+      defaults = @sass_config.dup
+
+      if load_paths = defaults.delete(:load_paths)
+        options[:load_paths] += load_paths
+      end
+
+      options.merge!(defaults)
+      options
+    end
+
+    # Public: Functions injected into Sass context during Sprockets evaluation.
+    #
+    # This module may be extended to add global functionality to all Sprockets
+    # Sass environments. Though, scoping your functions to just your environment
+    # is preferred.
+    #
+    # module Sprockets::SassProcessor::Functions
+    #   def asset_path(path, options = {})
+    #   end
+    # end
+    #
+    module Functions
+      # Public: Generate a url for asset path.
+      #
+      # Default implementation is deprecated. Currently defaults to
+      # Context#asset_path.
+      #
+      # Will raise NotImplementedError in the future. Users should provide their
+      # own base implementation.
+      #
+      # Returns a Sass::Script::String.
+      def asset_path(path, options = {})
+        path = path.value
+
+        path, _, query, fragment = URI.split(path)[5..8]
+        path     = sprockets_context.asset_path(path, options)
+        query    = "?#{query}" if query
+        fragment = "##{fragment}" if fragment
+
+        Sass::Script::String.new("#{path}#{query}#{fragment}", :string)
+      end
+
+      # Public: Generate a asset url() link.
+      #
+      # path - Sass::Script::String URL path
+      #
+      # Returns a Sass::Script::String.
+      def asset_url(path, options = {})
+        Sass::Script::String.new("url(#{asset_path(path, options).value})")
+      end
+
+      # Public: Generate url for image path.
+      #
+      # path - Sass::Script::String URL path
+      #
+      # Returns a Sass::Script::String.
+      def image_path(path)
+        asset_path(path, type: :image)
+      end
+
+      # Public: Generate a image url() link.
+      #
+      # path - Sass::Script::String URL path
+      #
+      # Returns a Sass::Script::String.
+      def image_url(path)
+        asset_url(path, type: :image)
+      end
+
+      # Public: Generate url for video path.
+      #
+      # path - Sass::Script::String URL path
+      #
+      # Returns a Sass::Script::String.
+      def video_path(path)
+        asset_path(path, type: :video)
+      end
+
+      # Public: Generate a video url() link.
+      #
+      # path - Sass::Script::String URL path
+      #
+      # Returns a Sass::Script::String.
+      def video_url(path)
+        asset_url(path, type: :video)
+      end
+
+      # Public: Generate url for audio path.
+      #
+      # path - Sass::Script::String URL path
+      #
+      # Returns a Sass::Script::String.
+      def audio_path(path)
+        asset_path(path, type: :audio)
+      end
+
+      # Public: Generate a audio url() link.
+      #
+      # path - Sass::Script::String URL path
+      #
+      # Returns a Sass::Script::String.
+      def audio_url(path)
+        asset_url(path, type: :audio)
+      end
+
+      # Public: Generate url for font path.
+      #
+      # path - Sass::Script::String URL path
+      #
+      # Returns a Sass::Script::String.
+      def font_path(path)
+        asset_path(path, type: :font)
+      end
+
+      # Public: Generate a font url() link.
+      #
+      # path - Sass::Script::String URL path
+      #
+      # Returns a Sass::Script::String.
+      def font_url(path)
+        asset_url(path, type: :font)
+      end
+
+      # Public: Generate url for javascript path.
+      #
+      # path - Sass::Script::String URL path
+      #
+      # Returns a Sass::Script::String.
+      def javascript_path(path)
+        asset_path(path, type: :javascript)
+      end
+
+      # Public: Generate a javascript url() link.
+      #
+      # path - Sass::Script::String URL path
+      #
+      # Returns a Sass::Script::String.
+      def javascript_url(path)
+        asset_url(path, type: :javascript)
+      end
+
+      # Public: Generate url for stylesheet path.
+      #
+      # path - Sass::Script::String URL path
+      #
+      # Returns a Sass::Script::String.
+      def stylesheet_path(path)
+        asset_path(path, type: :stylesheet)
+      end
+
+      # Public: Generate a stylesheet url() link.
+      #
+      # path - Sass::Script::String URL path
+      #
+      # Returns a Sass::Script::String.
+      def stylesheet_url(path)
+        asset_url(path, type: :stylesheet)
+      end
+
+      # Public: Generate a data URI for asset path.
+      #
+      # path - Sass::Script::String logical asset path
+      #
+      # Returns a Sass::Script::String.
+      def asset_data_url(path)
+        url = sprockets_context.asset_data_uri(path.value)
+        Sass::Script::String.new("url(" + url + ")")
+      end
+
+      protected
+        # Public: The Environment.
+        #
+        # Returns Sprockets::Environment.
+        def sprockets_environment
+          options[:sprockets][:environment]
+        end
+
+        # Public: Mutatable set of dependencies.
+        #
+        # Returns a Set.
+        def sprockets_dependencies
+          options[:sprockets][:dependencies]
+        end
+
+        # Deprecated: Get the Context instance. Use APIs on
+        # sprockets_environment or sprockets_dependencies directly.
+        #
+        # Returns a Context instance.
+        def sprockets_context
+          options[:sprockets][:context]
+        end
+
+    end
+  end
+
+  class ScssProcessor < SassProcessor
+    def self.syntax
+      :scss
+    end
+  end
+end