condenser 0.0.1

data/lib/condenser/resolve.rb

@@ -0,0 +1,202 @@
+class Condenser
+  module Resolve
+    
+    def initialize(root)
+      @reverse_mapping = nil
+    end
+    
+    def resolve(filename, base=nil, accept: nil, ignore: [])
+      dirname, basename, extensions, mime_types = decompose_path(filename, base)
+      results = []
+
+      accept ||= mime_types.empty? ? ['*/*'] : mime_types
+      accept = Array(accept)
+      
+      paths = if dirname&.start_with?('/')
+        if pat = path.find { |pa| dirname.start_with?(pa) }
+          dirname.delete_prefix!(pat)
+          dirname.delete_prefix!('/')
+          [pat]
+        else
+          []
+        end
+      else
+        path
+      end
+
+      paths.each do |path|
+        glob = path
+        glob = File.join(glob, dirname) if dirname
+        glob = File.join(glob, basename)
+        glob << '.*' unless glob.end_with?('*')
+        
+        Dir.glob(glob).sort.each do |f|
+          next if !File.file?(f) || ignore.include?(f)
+          
+          f_dirname, f_basename, f_extensions, f_mime_types = decompose_path(f)
+          if (basename == '*' || basename == f_basename)
+            if accept == ['*/*'] || mime_type_match_accept?(f_mime_types, accept)
+              asset_dir = f_dirname.delete_prefix(path).delete_prefix('/')
+              asset_basename = f_basename + f_extensions.join('')
+              asset_filename = asset_dir.empty? ? asset_basename : File.join(asset_dir, asset_basename)
+              results << Asset.new(self, {
+                filename: asset_filename,
+                content_types: f_mime_types,
+                source_file: f,
+                source_path: path
+              })
+            end
+            
+            reverse_mapping[f_mime_types]&.each do |derivative_mime_types|
+              if accept == ['*/*'] || mime_type_match_accept?(derivative_mime_types, accept)
+                asset_dir = f_dirname.delete_prefix(path).delete_prefix('/')
+                asset_basename = f_basename + derivative_mime_types.map { |t| @mime_types[t][:extensions].first }.join('')
+                asset_filename = asset_dir.empty? ? asset_basename : File.join(asset_dir, asset_basename)
+                results << Asset.new(self, {
+                  filename: asset_filename,
+                  content_types: derivative_mime_types,
+                  source_file: f,
+                  source_path: path
+                })
+              end
+            end
+          end
+        end
+      end
+
+      results = results.group_by do |a|
+        accept.find_index { |m| match_mime_types?(a.content_types, m) }
+      end
+      
+      results = results.keys.sort.reduce([]) do |c, key|
+        c += results[key].sort_by(&:filename)
+      end
+
+      results = results.map { |a| a.basepath }.uniq.map {|fn| results.find {|r| r.filename.sub(/\.(\w+)$/, '') == fn}}
+
+      results.sort_by(&:filename)
+    end
+
+    def resolve!(filename, base=nil, **kargs)
+      assets = resolve(filename, base, **kargs)
+      if assets.empty?
+        raise FileNotFound, "couldn't find file '#{filename}'"
+      else
+        assets
+      end
+    end
+
+    def find(filename, base=nil, **kargs)
+      resolve(filename, base, **kargs).first
+    end
+    
+    def find!(filename, base=nil, **kargs)
+      resolve!(filename, base, **kargs).first
+    end
+    
+    def [](filename)
+      find!(filename).export
+    end
+    
+    def find_export(filename, base=nil, **kargs)
+      asset = resolve(filename, base, **kargs).first
+      asset&.export
+    end
+
+    
+    def decompose_path(path, base=nil)
+      dirname = path.index('/') ? File.dirname(path) : nil
+      if base
+        dirname = File.expand_path(dirname, base)
+      end
+      _, basename, extensions = path.match(/([^\.\/]+)(\.[^\/]*)?$/).to_a
+
+      if extensions.nil? && basename == '*'
+        extensions = nil
+        mime_types = []
+      elsif extensions.nil?
+        mime_types = []
+      else
+        exts = []
+        while !extensions.empty?
+          matching_extensions = @extensions.keys.select { |e| extensions.end_with?(e) }
+          if matching_extensions.empty?
+            basename << extensions
+            break
+            # raise 'unkown mime'
+          else
+            matching_extensions.sort_by! { |e| -e.length }
+            exts.unshift(matching_extensions.first)
+            extensions.delete_suffix!(matching_extensions.first)
+          end
+        end
+        extensions = exts
+        mime_types = extensions.map { |k| @extensions[k] }
+      end
+      
+      
+      [ dirname, basename, extensions, mime_types ]
+    end
+    
+    def reverse_mapping
+      return @reverse_mapping if @reverse_mapping
+      map = {}
+      @mime_types.each_key do |source_mime_type|
+        to_mime_type = source_mime_type
+
+        ([nil] + (@transformers[source_mime_type]&.keys || [])).each do |transform_mime_type|
+          to_mime_type = transform_mime_type if transform_mime_type
+          
+          ([nil] + @templates.keys).each do |template_mime_type|
+            from_mimes = [source_mime_type, template_mime_type].compact
+            to_mime_types = [to_mime_type].compact
+            if from_mimes != to_mime_types
+              map[from_mimes] ||= Set.new
+              map[from_mimes] << to_mime_types
+            end
+          end
+
+        end
+      end
+      $map = map
+    end
+
+    def writers_for_mime_type(mime_type)
+      @writers.select { |m, e| match_mime_type?(mime_type, m) }.values.reduce(&:+)
+    end
+    
+    def match_mime_types?(value, matcher)
+      matcher = Array(matcher)
+      value = Array(value)
+      
+      if matcher.length == 1 && matcher.last == '*/*'
+        true
+      else
+        value.length == matcher.length && value.zip(matcher).all? { |v, m| match_mime_type?(v, m) }
+      end
+    end
+    
+    def mime_type_match_accept?(value, accept)
+      accept.any? do |a|
+        match_mime_types?(value, Array(a))
+      end
+    end
+        
+    # Public: Test mime type against mime range.
+    #
+    #    match_mime_type?('text/html', 'text/*') => true
+    #    match_mime_type?('text/plain', '*') => true
+    #    match_mime_type?('text/html', 'application/json') => false
+    #
+    # Returns true if the given value is a mime match for the given mime match
+    # specification, false otherwise.
+    def match_mime_type?(value, matcher)
+      v1, v2 = value.split('/'.freeze, 2)
+      m1, m2 = matcher.split('/'.freeze, 2)
+      (m1 == '*'.freeze || v1 == m1) && (m2.nil? || m2 == '*'.freeze || m2 == v2)
+    end
+    
+  end
+end
+
+

data/lib/condenser/server.rb

@@ -0,0 +1,307 @@
+require 'set'
+require 'time'
+require 'rack/utils'
+
+class Condenser
+  class Server
+    
+    ALLOWED_REQUEST_METHODS = ['GET', 'HEAD'].to_set.freeze
+    
+    def initialize(condenser)
+      @condenser = condenser
+    end
+    
+    def logger
+      @condenser.logger
+    end
+
+    # `call` implements the Rack 1.x specification which accepts an
+    # `env` Hash and returns a three item tuple with the status code,
+    # headers, and body.
+    #
+    # Mapping your environment at a url prefix will serve all assets
+    # in the path.
+    #
+    #     map "/assets" do
+    #       run Condenser::Server.new(condenser)
+    #     end
+    #
+    # A request for `"/assets/foo/bar.js"` will search your
+    # environment for `"foo/bar.js"`.
+    def call(env)
+      start_time = Time.now.to_f
+      time_elapsed = lambda { ((Time.now.to_f - start_time) * 1000).to_i }
+
+      if !ALLOWED_REQUEST_METHODS.include?(env['REQUEST_METHOD'])
+        return method_not_allowed_response
+      end
+
+      msg = "Served asset #{env['PATH_INFO']} -"
+
+      # Extract the path from everything after the leading slash
+      path = Rack::Utils.unescape(env['PATH_INFO'].to_s.sub(/^\//, ''))
+      
+      if !path.valid_encoding?
+        return bad_request_response(env)
+      end
+
+      # Strip fingerprint
+      if fingerprint = path_fingerprint(path)
+        path = path.sub("-#{fingerprint}", '')
+      end
+
+      # URLs containing a `".."` are rejected for security reasons.
+      if forbidden_request?(path)
+        return forbidden_response(env)
+      end
+
+      if fingerprint
+        if_match = fingerprint
+      elsif env['HTTP_IF_MATCH']
+        if_match = env['HTTP_IF_MATCH'][/"(\w+)"$/, 1]
+      end
+
+      if env['HTTP_IF_NONE_MATCH']
+        if_none_match = env['HTTP_IF_NONE_MATCH'][/"(\w+)"$/, 1]
+      end
+
+      # Look up the asset.
+      asset = @condenser.find_export(path)
+
+      if asset.nil?
+        status = :not_found
+      elsif fingerprint && asset.etag != fingerprint
+        status = :not_found
+      elsif if_match && asset.etag != if_match
+        status = :precondition_failed
+      elsif if_none_match && asset.etag == if_none_match
+        status = :not_modified
+      else
+        status = :ok
+      end
+
+      case status
+      when :ok
+        logger.info "#{msg} 200 OK (#{time_elapsed.call}ms)"
+        ok_response(asset, env)
+      when :not_modified
+        logger.info "#{msg} 304 Not Modified (#{time_elapsed.call}ms)"
+        not_modified_response(env, if_none_match)
+      when :not_found
+        logger.info "#{msg} 404 Not Found (#{time_elapsed.call}ms)"
+        not_found_response(env)
+      when :precondition_failed
+        logger.info "#{msg} 412 Precondition Failed (#{time_elapsed.call}ms)"
+        precondition_failed_response(env)
+      end
+    rescue StandardError => e
+      logger.error "Error compiling asset #{path}:"
+      logger.error "#{e.class.name}: #{e.message}"
+
+      case File.extname(path)
+      when ".js"
+        # Re-throw JavaScript asset exceptions to the browser
+        logger.info "#{msg} 500 Internal Server Error\n\n"
+        return javascript_exception_response(e)
+      when ".css"
+        # Display CSS asset exceptions in the browser
+        logger.info "#{msg} 500 Internal Server Error\n\n"
+        return css_exception_response(e)
+      else
+        raise
+      end
+    end
+    
+    private
+      def forbidden_request?(path)
+        # Prevent access to files elsewhere on the file system
+        #
+        #     http://example.org/assets/../../../etc/passwd
+        #
+        path.include?("..") || absolute_path?(path)
+      end
+
+      def head_request?(env)
+        env['REQUEST_METHOD'] == 'HEAD'
+      end
+
+      # Returns a 200 OK response tuple
+      def ok_response(asset, env)
+        if head_request?(env)
+          [ 200, headers(env, asset, 0), [] ]
+        else
+          [ 200, headers(env, asset, asset.length), [asset.to_s] ]
+        end
+      end
+
+      # Returns a 304 Not Modified response tuple
+      def not_modified_response(env, etag)
+        [ 304, cache_headers(env, etag), [] ]
+      end
+
+      # Returns a 400 Forbidden response tuple
+      def bad_request_response(env)
+        if head_request?(env)
+          [ 400, { "Content-Type" => "text/plain", "Content-Length" => "0" }, [] ]
+        else
+          [ 400, { "Content-Type" => "text/plain", "Content-Length" => "11" }, [ "Bad Request" ] ]
+        end
+      end
+
+      # Returns a 403 Forbidden response tuple
+      def forbidden_response(env)
+        if head_request?(env)
+          [ 403, { "Content-Type" => "text/plain", "Content-Length" => "0" }, [] ]
+        else
+          [ 403, { "Content-Type" => "text/plain", "Content-Length" => "9" }, [ "Forbidden" ] ]
+        end
+      end
+
+      # Returns a 404 Not Found response tuple
+      def not_found_response(env)
+        if head_request?(env)
+          [ 404, { "Content-Type" => "text/plain", "Content-Length" => "0", "X-Cascade" => "pass" }, [] ]
+        else
+          [ 404, { "Content-Type" => "text/plain", "Content-Length" => "9", "X-Cascade" => "pass" }, [ "Not found" ] ]
+        end
+      end
+
+      def method_not_allowed_response
+        [ 405, { "Content-Type" => "text/plain", "Content-Length" => "18" }, [ "Method Not Allowed" ] ]
+      end
+
+      def precondition_failed_response(env)
+        if head_request?(env)
+          [ 412, { "Content-Type" => "text/plain", "Content-Length" => "0", "X-Cascade" => "pass" }, [] ]
+        else
+          [ 412, { "Content-Type" => "text/plain", "Content-Length" => "19", "X-Cascade" => "pass" }, [ "Precondition Failed" ] ]
+        end
+      end
+
+      # Returns a JavaScript response that re-throws a Ruby exception
+      # in the browser
+      def javascript_exception_response(exception)
+        err  = "#{exception.class.name}: #{exception.message}\n  (in #{exception.backtrace[0]})"
+        body = "throw Error(#{err.inspect})"
+        [ 200, { "Content-Type" => "application/javascript", "Content-Length" => body.bytesize.to_s }, [ body ] ]
+      end
+
+      # Returns a CSS response that hides all elements on the page and
+      # displays the exception
+      def css_exception_response(exception)
+        message   = "\n#{exception.class.name}: #{exception.message}"
+        backtrace = "\n  #{exception.backtrace.first}"
+
+        body = <<-CSS
+          html {
+            padding: 18px 36px;
+          }
+
+          head {
+            display: block;
+          }
+
+          body {
+            margin: 0;
+            padding: 0;
+          }
+
+          body > * {
+            display: none !important;
+          }
+
+          head:after, body:before, body:after {
+            display: block !important;
+          }
+
+          head:after {
+            font-family: sans-serif;
+            font-size: large;
+            font-weight: bold;
+            content: "Error compiling CSS asset";
+          }
+
+          body:before, body:after {
+            font-family: monospace;
+            white-space: pre-wrap;
+          }
+
+          body:before {
+            font-weight: bold;
+            content: "#{escape_css_content(message)}";
+          }
+
+          body:after {
+            content: "#{escape_css_content(backtrace)}";
+          }
+        CSS
+
+        [ 200, { "Content-Type" => "text/css; charset=utf-8", "Content-Length" => body.bytesize.to_s }, [ body ] ]
+      end
+
+      # Escape special characters for use inside a CSS content("...") string
+      def escape_css_content(content)
+        content.
+          gsub('\\', '\\\\005c ').
+          gsub("\n", '\\\\000a ').
+          gsub('"',  '\\\\0022 ').
+          gsub('/',  '\\\\002f ')
+      end
+
+      def cache_headers(env, etag)
+        headers = {}
+
+        # Set caching headers
+        headers["Cache-Control"] = String.new("public")
+        headers["ETag"]          = %("#{etag}")
+
+        # If the request url contains a fingerprint, set a long
+        # expires on the response
+        if path_fingerprint(env["PATH_INFO"])
+          headers["Cache-Control"] << ", max-age=31536000, immutable"
+
+        # Otherwise set `must-revalidate` since the asset could be modified.
+        else
+          headers["Cache-Control"] << ", must-revalidate"
+          headers["Vary"] = "Accept-Encoding"
+        end
+
+        headers
+      end
+
+      def headers(env, asset, length)
+        headers = {}
+
+        # Set content length header
+        headers["Content-Length"] = length.to_s
+
+        if asset&.sourcemap
+          headers['SourceMap'] = env['SCRIPT_NAME'] + env['PATH_INFO'] + '.map'
+        end
+        
+        # Set content type header
+        if type = asset.content_type
+          # Set charset param for text/* mime types
+          if type.start_with?("text/") && asset.charset
+            type += "; charset=#{asset.charset}"
+          end
+          headers["Content-Type"] = type
+        end
+
+        headers.merge(cache_headers(env, asset.etag))
+      end
+
+      # Gets ETag fingerprint.
+      #
+      #     "foo-0aa2105d29558f3eb790d411d7d8fb66.js"
+      #     # => "0aa2105d29558f3eb790d411d7d8fb66"
+      #
+      def path_fingerprint(path)
+        path[/-([0-9a-f]{7,128})\.[^.]+\z/, 1]
+      end
+      
+      def absolute_path?(path)
+        path.start_with?(File::SEPARATOR)
+      end
+  end
+end