condenser 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: ea18e4983464493a490f76c2c31839d29e69de171033575b6db24649177189ac
+  data.tar.gz: e938a1ee91802fb1b197bb34be963d4b4d1f88663f60ee5494c5b9bd4ccdd15c
+SHA512:
+  metadata.gz: b01a8d1ed588a216f9f802a0ef0065782092957c4ff8030321a62aa1229ad3a478eb6e08b11b4d747c3e85d9c9ce0d6320ab60fb7b8e6d1ed8ba9186cfcc4c6c
+  data.tar.gz: b7ddee06c969a9601f374e58fea6b7623d779f27241d75d685e88779349e252e28e72310a7ffc2411d28e090c815cc48773bec740fc39c96658e5779fe18f2f0

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2018 Jon Bracy
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1 @@
+# condenser

data/lib/condenser.rb

@@ -0,0 +1,108 @@
+require 'logger'
+require 'active_support'
+require 'active_support/core_ext'
+
+require 'condenser/version'
+require 'condenser/errors'
+require 'condenser/environment'
+require 'condenser/pipeline'
+require 'condenser/resolve'
+require 'condenser/encoding_utils'
+require 'condenser/asset'
+require 'condenser/manifest'
+
+
+class Condenser
+  include Environment, Pipeline, Resolve
+  
+  def self.configure(&block)
+    instance_eval(&block)
+  end
+  
+  attr_reader :logger
+  attr_accessor :digestor
+  
+  def initialize(root='.', digestor: nil)
+    @logger = Logger.new($stderr, level: :warn)
+    self.digestor = digestor || Digest::SHA256
+    super(root)
+  end
+end
+
+Condenser.configure do
+  # Common asset text types
+  register_mime_type 'application/json',  extension: '.json', charset: :unicode
+  register_mime_type 'application/ruby',  extension: '.rb'
+  register_mime_type 'application/xml',   extension: '.xml'
+  register_mime_type 'text/html',         extensions: %w(.html .htm), charset: :html
+  register_mime_type 'text/plain',        extensions: %w(.txt .text)
+  register_mime_type 'text/yaml',         extensions: %w(.yml .yaml), charset: :unicode
+
+  # Common image types
+  register_mime_type 'image/x-icon',      extension: '.ico'
+  register_mime_type 'image/bmp',         extension: '.bmp'
+  register_mime_type 'image/gif',         extension: '.gif'
+  register_mime_type 'image/webp',        extension: '.webp'
+  register_mime_type 'image/png',         extension: '.png'
+  register_mime_type 'image/jpeg',        extensions: %w(.jpg .jpeg)
+  register_mime_type 'image/tiff',        extensions: %w(.tiff .tif)
+  register_mime_type 'image/svg+xml',     extension: '.svg'
+
+  # Common audio/video types
+  register_mime_type 'video/webm', extensions: ['.webm']
+  register_mime_type 'audio/basic', extensions: ['.snd', '.au']
+  register_mime_type 'audio/aiff', extensions: ['.aiff']
+  register_mime_type 'audio/mpeg', extensions: ['.mp3', '.mp2', '.m2a', '.m3a']
+  register_mime_type 'application/ogg', extensions: ['.ogx']
+  register_mime_type 'audio/ogg', extensions: ['.ogg', '.oga']
+  register_mime_type 'audio/midi', extensions: ['.midi', '.mid']
+  register_mime_type 'video/avi', extensions: ['.avi']
+  register_mime_type 'audio/wave', extensions: ['.wav', '.wave']
+  register_mime_type 'video/mp4', extensions: ['.mp4', '.m4v']
+  register_mime_type 'audio/aac', extensions: ['.aac']
+  register_mime_type 'audio/mp4', extensions: ['.m4a']
+  register_mime_type 'audio/flac', extensions: ['.flac']
+
+  # Common font types
+  register_mime_type 'application/vnd.ms-fontobject', extensions: ['.eot']
+  register_mime_type 'application/x-font-opentype', extensions: ['.otf']
+  register_mime_type 'application/x-font-ttf', extensions: ['.ttf']
+  register_mime_type 'application/font-woff', extensions: ['.woff']
+  register_mime_type 'application/font-woff2', extensions: ['.woff2']
+  
+  # Sourmaps
+  register_mime_type 'application/sourcemap', extension: '.map', charset: :unicode
+  
+  # ERB
+  require 'condenser/templating_engine/erb'
+  register_mime_type 'application/erb', extension: '.erb'
+  register_template  'application/erb', Condenser::Erubi
+  
+  # CSS
+  register_mime_type 'text/css', extension: '.css', charset: :css
+
+  # SASS
+  require 'condenser/processors/sass_processor'
+  register_mime_type    'text/sass', extensions: %w(.sass .css.sass)
+  # register_transformer  'text/sass', 'text/css', SassProcessor
+  
+  # SCSS
+  register_mime_type    'text/scss', extensions: %w(.scss .css.scss)
+  register_transformer  'text/scss', 'text/css', Condenser::ScssProcessor
+  
+  # Javascript
+  require 'condenser/processors/rollup_processor'
+  require 'condenser/processors/babel_processor'
+  register_mime_type    'application/javascript', extension: '.js', charset: :unicode
+  register_preprocessor 'application/javascript', Condenser::BabelProcessor
+  register_exporter     'application/javascript', Condenser::RollupProcessor
+  # register_minifier     'application/javascript', Uglifier
+
+  # Writers
+  require 'condenser/writers/file_writer'
+  require 'condenser/writers/zlib_writer'
+  register_mime_type 'application/gzip', extensions: %w(.gz .gzip)
+  # register_compressor 'application/gzip', Condenser::Erubi
+  register_writer '*/*', Condenser::FileWriter.new
+  register_writer Condenser::ZlibWriter::COMPRESSALBE_TYPES, Condenser::ZlibWriter.new, 'application/gzip'
+end

data/lib/condenser/asset.rb

@@ -0,0 +1,221 @@
+require 'set'
+require 'digest/md5'
+require 'digest/sha1'
+require 'digest/sha2'
+require 'condenser/export'
+
+class Condenser
+  class Asset
+    
+    include EncodingUtils
+    
+    attr_reader :environment, :filename, :content_types, :source_file, :source_path
+    attr_reader :linked_assets, :dependencies
+    attr_writer :source, :sourcemap
+
+    attr_accessor :imports
+    
+    def initialize(env, attributes={})
+      @environment    = env
+      
+      @filename       = attributes[:filename]
+      @content_types  = Array(attributes[:content_types] || attributes[:content_type])
+
+      @source_file    = attributes[:source_file]
+      @source_path    = attributes[:source_path]
+      
+      @linked_assets  = Set.new
+      @dependencies   = Set.new
+      
+      @processed      = false
+      @exported       = false
+    end
+    
+    def path
+      filename.sub(/\.(\w+)$/) { |ext| "-#{etag}#{ext}" }
+    end
+    
+    def content_type
+      @content_types.last
+    end
+    
+    def process
+      process! if @processed == false
+    end
+    
+    def basepath
+      dirname, basename, extensions, mime_types = @environment.decompose_path(filename)
+      [dirname, basename].compact.join('/')
+    end
+    
+    def cache_key(data)
+    end
+    
+    def process!(source=nil, source_digest=nil, content_digest=nil)
+      source ||= File.binread(@source_file)
+      source_digest ||= Digest::SHA1.base64digest(source)
+      content_digest ||= Digest::SHA1.base64digest(@content_types.join(':'))
+
+      result = @environment.cache.fetch("process/#{source_digest}/#{content_digest}") do
+        dirname, basename, extensions, mime_types = @environment.decompose_path(@source_file)
+        data = {
+          source: source,
+          source_file: @source_file,
+          source_digest: source_digest,
+        
+          filename: @filename.dup,
+          content_type: mime_types,
+
+          map: nil,
+          linked_assets: [],
+          dependencies: []
+        }
+        
+        while @environment.templates.has_key?(data[:content_type].last)
+          templator = @environment.templates[data[:content_type].pop]
+          templator.call(@environment, data)
+          data[:filename] = data[:filename].gsub(/\.#{extensions.last}$/, '')
+        end
+      
+        case @environment.mime_types[data[:content_type].last][:charset]
+        when :unicode
+          detect_unicode(data[:source])
+        when :css
+          detect_css(data[:source])
+        when :html
+          detect_html(data[:source])
+        else
+          detect(data[:source]) if mime_types.last.start_with?('text/')
+        end
+        
+        if @environment.preprocessors.has_key?(data[:content_type].last)
+          @environment.preprocessors[data[:content_type].last].each do |processor|
+            processor.call(@environment, data)
+          end
+        end
+      
+        if data[:content_type].last != @content_types.last && @environment.transformers.has_key?(data[:content_type].last)
+          @environment.transformers[data[:content_type].pop].each do |to_mime_type, processor|
+            processor.call(@environment, data)
+            data[:content_type] << to_mime_type
+          end
+        end
+      
+        if mime_types != @content_types
+          raise ContentTypeMismatch, "mime type(s) \"#{@content_types.join(', ')}\" does not match requested mime type(s) \"#{data[:mime_types].join(', ')}\""
+        end
+      
+        data[:digest] = @environment.digestor.digest(data[:source])
+        data[:digest_name] = @environment.digestor.name.sub(/^.*::/, '').downcase
+        data
+      end
+      @processed = true
+
+      @source = result[:source]
+      @sourcemap = result[:map]
+      @filename = result[:filename]
+      @content_types = result[:content_type]
+      @linked_assets = result[:linked_assets]
+      @digest = result[:digest]
+      @digest_name = result[:digest_name]
+      @dependencies = result[:dependencies]
+    end
+    
+    def export
+      source ||= File.binread(@source_file)
+      source_digest ||= Digest::SHA1.base64digest(source)
+      content_digest ||= Digest::SHA1.base64digest(@content_types.join(':'))
+      
+      process!(source, source_digest, content_digest) if !@processed
+      
+      result = @environment.cache.fetch("export/#{source_digest}/#{content_digest}") do
+        dirname, basename, extensions, mime_types = @environment.decompose_path(@filename)
+        data = {
+          source: @source,
+          source_file: @source_file,
+          source_digest: source_digest,
+        
+          filename: @filename.dup,
+          content_types: @content_types,
+
+          sourcemap: nil,
+          linked_assets: [],
+          dependencies: []
+        }
+        @environment.exporters[content_type]&.call(@environment, data)
+        data[:digest] = @environment.digestor.digest(data[:source])
+        data[:digest_name] = @environment.digestor.name.sub(/^.*::/, '').downcase
+        data
+      end
+      
+      Export.new(@environment, result)
+    end
+    
+    def to_s
+      # process
+      @source
+    end
+    
+    def source
+      process
+      @source
+    end
+    
+    def sourcemap
+      process
+      @sourcemap
+    end
+    
+    def length
+      # process
+      @source.bytesize
+    end
+    alias size length
+    
+    def digest
+      # process
+      @digest
+    end
+    
+    def charset
+      @source.encoding.name.downcase
+    end
+
+    # Public: Returns String hexdigest of source.
+    def hexdigest
+      # process
+      @digest.unpack('H*'.freeze).first
+    end
+    alias_method :etag, :hexdigest
+    
+    def integrity
+      "#{@digest_name}-#{[@digest].pack('m0')}"
+    end
+    
+    def to_json
+      { path: path, digest: hexdigest, size: size, integrity: integrity }
+    end
+    
+    def write(output_directory)
+      files = @environment.writers_for_mime_type(content_type).map do |writer|
+        writer[0].call(output_directory, self)
+      end
+      files.flatten.compact
+    end
+    
+    def ext
+      File.extname(filename)
+    end
+      
+    # Public: Compare assets.
+    #
+    # Assets are equal if they share the same path and digest.
+    #
+    # Returns true or false.
+    def eql?(other)
+      self.class == other.class && self.filename == other.filename && self.content_types == other.content_types
+    end
+    alias_method :==, :eql?
+    
+  end
+end

data/lib/condenser/cache/memory_store.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+class Condenser::Cache
+  # Public: Basic in memory LRU cache.
+  #
+  # Assign the instance to the Environment#cache.
+  #
+  #     environment.cache = Sprockets::Cache::MemoryStore.new(1000)
+  #
+  # See Also
+  #
+  #   ActiveSupport::Cache::MemoryStore
+  #
+  class MemoryStore
+    # Internal: Default key limit for store.
+    DEFAULT_MAX_SIZE = 33_554_432 # 32 Megabytes
+    PER_ENTRY_OVERHEAD = 240
+
+    def initialize(options = {})
+      @max_size = options[:size] || DEFAULT_MAX_SIZE
+      @cache = {}
+      @key_access = {}
+      @cache_size = 0
+    end
+
+    def clear
+      @cache.clear
+      @key_access.clear
+      @cache_size = 0
+    end
+    
+    def fetch(key)
+      value = get(key)
+      
+      if value.nil?
+        value = yield
+        set(key, Marshal.dump(value))
+      else
+        value = Marshal.load(value)
+      end
+      value
+    end
+    
+    def get(key)
+      value = @cache[key]
+      @key_access[key] = Time.now.to_f if value
+      value
+    end
+
+    def cached_size(key, value)
+      key.to_s.bytesize + value.bytesize + PER_ENTRY_OVERHEAD
+    end
+    
+    def set(key, value)
+      if old_value = @cache[key]
+        @cache_size -= (old_value.bytesize - value.bytesize)
+      else
+        @cache_size += cached_size(key, value)
+      end
+      @cache[key] = value
+      @key_access[key] = Time.now.to_f
+      prune if @cache_size > @max_size
+      value
+    end
+    
+    def delete(key)
+      @key_access.delete(key)
+      if value = @cache.delete(key)
+        @cache_size -= cached_size(key, value)
+        true
+      else
+        false
+      end
+    end
+    
+    def prune
+      keys = @key_access.keys.sort { |a, b| @key_access[a].to_f <=> @key_access[b].to_f }
+      keys.each do |key|
+        delete(key)
+        return if @cache_size <= @max_size
+      end
+    end
+
+    # Public: Pretty inspect
+    #
+    # Returns String.
+    def inspect
+      "#<#{self.class} size=#{@cache_size}/#{@max_size}>"
+    end
+
+  end
+end