propshaft 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 2eb4dab520f6e9bc958d7ea65ed10531ab418ac34c3daefdcec0b4d61094bcdd
+  data.tar.gz: 8d76024de20625ee78b0cc8409a2e74b66ac0ccd8203ba14e263d89b649da21d
+SHA512:
+  metadata.gz: 5f8fbd11cd6a8a9031be35139887e1cec8e3823a4eb68e79ad61df91a307aa1222927fd8d87316c6b55df979cdd91f57bc4d653e092190a1b7933db175e44f14
+  data.tar.gz: 70a5ad6e8382e5dafc4bed6b26e1f9ba5008f6bd536961393b807cbb47580dbfc95c1c1cbe04b1b4954968213c2aa112ed822e156fe8f044209bade7ccc79de8

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2021 Basecamp
+
+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,43 @@
+# Propshaft
+
+Propshaft is an asset pipeline library for Rails. It's built for era where bundling assets to save on HTTP connections is no longer urgent, where JavaScript and CSS is either compiled by dedicated Node.js bundlers or served directly to the browsers, and where increases in bandwidth has made the need for minification less pressing. These factors allow for a dramatically simpler and faster asset pipeline compared to previous options, like Sprockets.
+
+So that's what Propshaft doesn't do. Here's what it actually does provide:
+
+1. Configurable load path: You can register directories from multiple places in your app and gems, and reference assets from all of these paths as though they were one.
+1. Digest processing: All assets in the load path will be copied (or compiled) in a precompilation step for production that also stamps all of them with a digest hash, so you can use long-expiry cache headers for better performance. The digested assets can be referred to through their logical path because the processing leaves a manifest file that provides a way to translate.
+1. Development server: There's no need to precompile the assets in development. You can refer to them via the same asset_path helpers and they'll be served by a development server.
+1. Basic compiler step: Propshaft was explicitly not designed to provide full transpiler capabilities. You can get that better elsewhere. But it does offer a simple input->output compiler setup that by default is used to translate `asset-path` function calls in CSS to `url(digested-asset)` instead.
+
+
+## Installation
+
+With Rails 7+, you can start a new application with propshaft using `rails new myapp -a propshaft` (pending the merge of [rails/rails#43261](https://github.com/rails/rails/pull/43261)).
+
+
+## Usage
+
+Propshaft makes all the assets from all the paths its been configured with through `config.assets.paths` available for serving and will copy all of them into `public/assets` when precompiling. This is unlike Sprockets, which did not copy over assets that hadn't been explicitly included in one of bundled assets.
+
+These assets can be referenced through their logical path using the normal helpers like `asset_path`, `image_tag`, `javascript_include_tag`, and all the other asset helper tags. These logical references are automatically converted into digest-aware paths in production when `assets:precompile` has been run (through a json mapping file found in `public/assets/.manifest.json`).
+
+Additionally, Propshaft ships with a CSS function called `asset-path("image.svg")` that'll be compiled into `url("/assets/image-f2e1ec14d6856e1958083094170ca6119c529a73.svg")` when doing `assets:precompile`. This function is applied to all `.css` files.
+
+
+## Migrating from Sprockets
+
+Propshaft does a lot less than Sprockets, by design, so it might well be a fair bit of work to migrate, if it's even desirable. This is particularly true if you rely on Sprockets to provide any form of transpiling, like CoffeeScript or Sass, or if you rely on any gems that do. You'll need to either stop transpiling or use a Node-based transpiler, like those in `jsbundling-rails` and `cssbundling-rails`.
+
+On the other hand, if you're already bundling JavaScript and CSS through a Node-based setup, then Propshaft is going to slot in easily. Since you don't need another tool to bundle or transpile. Just to digest and serve.
+
+But for greenfield apps using the default import-map approach, Propshaft can also work well, if you're able to deal with vanilla CSS.
+
+
+## Will Propshaft replace Sprockets as the Rails default?
+
+Most likely, but Sprockets need to be supported as well for a long time to come. Plenty of apps and gems were built on Sprocket features, and they won't be migrating soon. Still working out the compatibility story. This is very much alpha software at the moment.
+
+
+## License
+
+Propshaft is released under the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,11 @@
+require "bundler/setup"
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new do |test|
+  test.libs << "test"
+  test.test_files = FileList["test/**/*_test.rb"]
+  test.warning = false
+end
+
+task default: :test

data/lib/propshaft/assembly.rb

@@ -0,0 +1,50 @@
+require "propshaft/load_path"
+require "propshaft/resolver/dynamic"
+require "propshaft/resolver/static"
+require "propshaft/server"
+require "propshaft/processor"
+require "propshaft/compilers"
+require "propshaft/compilers/css_asset_urls"
+
+class Propshaft::Assembly
+  attr_reader :config
+
+  def initialize(config)
+    @config = config
+  end
+
+  def load_path
+    Propshaft::LoadPath.new(config.paths)
+  end
+
+  def resolver
+    if manifest_path.exist?
+      Propshaft::Resolver::Static.new manifest_path: manifest_path, prefix: config.prefix
+    else
+      Propshaft::Resolver::Dynamic.new load_path: load_path, prefix: config.prefix
+    end
+  end
+
+  def server
+    Propshaft::Server.new(self)
+  end
+
+  def processor
+    Propshaft::Processor.new \
+      load_path: load_path, output_path: config.output_path, compilers: compilers
+  end
+
+  def compilers
+    @compilers ||=
+      Propshaft::Compilers.new(self).tap do |compilers|
+        Array(config.compilers).each do |(mime_type, klass)|
+          compilers.register mime_type, klass
+        end
+      end
+  end
+
+  private
+    def manifest_path
+      config.output_path.join(Propshaft::Processor::MANIFEST_FILENAME)
+    end
+end

data/lib/propshaft/asset.rb

@@ -0,0 +1,34 @@
+require "digest/sha1"
+require "action_dispatch/http/mime_type"
+
+class Propshaft::Asset
+  attr_reader :path, :logical_path
+
+  def initialize(path, logical_path:)
+    @path, @logical_path = path, Pathname.new(logical_path)
+  end
+
+  def content
+    File.binread(path)
+  end
+
+  def content_type
+    Mime::Type.lookup_by_extension(logical_path.extname.from(1))
+  end
+
+  def length
+    content.size
+  end
+
+  def digest
+    Digest::SHA1.hexdigest(content)
+  end
+
+  def digested_path
+    logical_path.sub(/\.(\w+)$/) { |ext| "-#{digest}#{ext}" }
+  end
+
+  def ==(other_asset)
+    logical_path.hash == other_asset.logical_path.hash
+  end
+end

data/lib/propshaft/compilers/css_asset_urls.rb

@@ -0,0 +1,13 @@
+class Propshaft::Compilers::CssAssetUrls
+  attr_reader :assembly
+
+  def initialize(assembly)
+    @assembly = assembly
+  end
+
+  def compile(input)
+    input.gsub(/asset-path\(["']([^"')]+)["']\)/) do |match|
+      %[url("/#{assembly.config.prefix}/#{assembly.load_path.find($1).digested_path}")]
+    end
+  end
+end

data/lib/propshaft/compilers.rb

@@ -0,0 +1,33 @@
+class Propshaft::Compilers
+  attr_reader :registrations, :assembly
+
+  def initialize(assembly)
+    @assembly      = assembly
+    @registrations = Hash.new
+  end
+
+  def register(mime_type, klass)
+    registrations[mime_type] ||= []
+    registrations[mime_type] << klass
+  end
+
+  def any?
+    registrations.any?
+  end
+
+  def compilable?(asset)
+    registrations[asset.content_type.to_s].present?
+  end
+
+  def compile(asset)
+    if relevant_registrations = registrations[asset.content_type.to_s]
+      asset.content.dup.tap do |input|
+        relevant_registrations.each do |compiler|
+          input.replace compiler.new(assembly).compile(input)
+        end
+      end
+    else
+      asset.content
+    end
+  end
+end

data/lib/propshaft/helper.rb

@@ -0,0 +1,5 @@
+module Propshaft::Helper
+  def compute_asset_path(path, options = {})
+    Rails.application.assets.resolver.resolve(path)
+  end
+end

data/lib/propshaft/load_path.rb

@@ -0,0 +1,42 @@
+require "propshaft/asset"
+
+class Propshaft::LoadPath
+  attr_reader :paths
+
+  def initialize(paths = [])
+    @paths = Array(paths).collect { |path| Pathname.new(path) }
+  end
+
+  def find(asset_name)
+    assets_by_path[asset_name]
+  end
+
+  def assets
+    assets_by_path.values
+  end
+
+  def manifest
+    Hash.new.tap do |manifest|
+      assets.each do |asset|
+        manifest[asset.logical_path.to_s] = asset.digested_path.to_s
+      end
+    end
+  end
+
+  private
+    def assets_by_path
+      Hash.new.tap do |mapped|
+        paths.each do |path|
+          all_files_from_tree(path).each do |file|
+            logical_path = file.relative_path_from(path)
+
+            mapped[logical_path.to_s] ||= Propshaft::Asset.new(file, logical_path: logical_path)
+          end
+        end
+      end
+    end
+
+    def all_files_from_tree(path)
+      path.children.flat_map { |child| child.directory? ? all_files_from_tree(child) : child }
+    end
+end

data/lib/propshaft/processor.rb

@@ -0,0 +1,74 @@
+class Propshaft::Processor
+  MANIFEST_FILENAME = ".manifest.json"
+
+  attr_reader :load_path, :output_path, :compilers
+
+  def initialize(load_path:, output_path:, compilers:)
+    @load_path, @output_path = load_path, output_path
+    @compilers = compilers
+  end
+
+  def process
+    ensure_output_path_exists
+    write_manifest
+    output_assets
+    compress_assets
+  end
+
+  private
+    def ensure_output_path_exists
+      FileUtils.mkdir_p output_path
+    end
+
+
+    def write_manifest
+      File.open(output_path.join(MANIFEST_FILENAME), "wb+") do |manifest|
+        manifest.write load_path.manifest.to_json
+      end
+    end
+
+
+    def output_assets
+      load_path.assets.each do |asset|
+        unless output_path.join(asset.digested_path).exist?
+          FileUtils.mkdir_p output_path.join(asset.digested_path.parent)
+          output_asset(asset)
+        end
+      end
+    end
+
+    def output_asset(asset)
+      compile_asset(asset) || copy_asset(asset)
+    end
+
+    def copy_asset(asset)
+      FileUtils.copy asset.path, output_path.join(asset.digested_path)
+    end
+
+    def compile_asset(asset)
+      File.open(output_path.join(asset.digested_path), "w+") do |file|
+        begin
+          file.write compilers.compile(asset)
+        rescue Encoding::UndefinedConversionError
+          # FIXME: Not sure if there's a better way here?
+          file.write compilers.compile(asset).force_encoding("UTF-8")
+        end
+      end if compilers.compilable?(asset)
+    end
+
+
+    def compress_assets
+      # FIXME: Only try to compress text assets with brotli
+      load_path.assets.each do |asset|
+        compress_asset output_path.join(asset.digested_path)
+      end if compressor_available?
+    end
+
+    def compress_asset(path)
+      `brotli #{path} -o #{path}.br` unless Pathname.new(path.to_s + ".br").exist?
+    end
+
+    def compressor_available?
+      `which brotli`.present?
+    end
+end

data/lib/propshaft/railtie.rb

@@ -0,0 +1,54 @@
+require "rails"
+require "rails/railtie"
+require "active_support/ordered_options"
+
+# FIXME: There's gotta be a better way than this hack?
+class Rails::Engine < Rails::Railtie
+  initializer :append_assets_path, group: :all do |app|
+    app.config.assets.paths.unshift(*paths["vendor/assets"].existent_directories)
+    app.config.assets.paths.unshift(*paths["lib/assets"].existent_directories)
+    app.config.assets.paths.unshift(*paths["app/assets"].existent_directories)
+  end
+end
+
+module Propshaft
+  class Railtie < ::Rails::Railtie
+    config.assets = ActiveSupport::OrderedOptions.new
+    config.assets.paths     = []
+    config.assets.prefix    = "/assets"
+    config.assets.compilers = [ [ "text/css", Propshaft::Compilers::CssAssetUrls ] ]
+
+    # Compatibility shiming (need to provide log warnings when used)
+    config.assets.precompile     = []
+    config.assets.debug          = nil
+    config.assets.quiet          = nil
+    config.assets.compile        = nil
+    config.assets.version        = nil
+    config.assets.css_compressor = nil
+    config.assets.js_compressor  = nil
+
+    config.after_initialize do |app|
+      config.assets.output_path ||=
+        Pathname.new(File.join(app.config.paths["public"].first, app.config.assets.prefix))
+
+      app.assets = Propshaft::Assembly.new(app.config.assets)
+
+      app.routes.prepend do
+        mount app.assets.server => app.assets.config.prefix
+      end
+
+      ActiveSupport.on_load(:action_view) do
+        include Propshaft::Helper
+      end
+    end
+
+    rake_tasks do |app|
+      namespace :assets do
+        desc "Compile all the assets from config.assets.paths"
+        task precompile: :environment do
+          Rails.application.assets.processor.process
+        end
+      end
+    end
+  end
+end

data/lib/propshaft/resolver/dynamic.rb

@@ -0,0 +1,15 @@
+module Propshaft::Resolver
+  class Dynamic
+    attr_reader :load_path, :prefix
+
+    def initialize(load_path:, prefix:)
+      @load_path, @prefix = load_path, prefix
+    end
+
+    def resolve(logical_path)
+      if asset = load_path.find(logical_path)
+        File.join prefix, asset.logical_path
+      end
+    end
+  end
+end

data/lib/propshaft/resolver/static.rb

@@ -0,0 +1,20 @@
+module Propshaft::Resolver
+  class Static
+    attr_reader :manifest_path, :prefix
+
+    def initialize(manifest_path:, prefix:)
+      @manifest_path, @prefix = manifest_path, prefix
+    end
+
+    def resolve(logical_path)
+      if asset_path = parsed_manifest[logical_path]
+        File.join prefix, asset_path
+      end
+    end
+
+    private
+      def parsed_manifest
+        @parsed_manifest ||= JSON.parse(manifest_path.read)
+      end
+  end
+end

data/lib/propshaft/server.rb

@@ -0,0 +1,31 @@
+require "rack/utils"
+
+class Propshaft::Server
+  def initialize(assembly)
+    @assembly = assembly
+  end
+
+  def call(env)
+    if asset = @assembly.load_path.find(requested_path(env))
+      compiled_content = @assembly.compilers.compile(asset)
+
+      [ 
+        200, 
+        {
+          "Content-Length" => compiled_content.length.to_s,
+          "Content-Type"   => asset.content_type,
+          "ETag"           => asset.digest,
+          "Cache-Control"  => "public, must-revalidate"
+        },
+        [ compiled_content ]
+      ]
+    else
+      [ 404, { "Content-Type" => "text/plain", "Content-Length" => "9" }, [ "Not found" ] ]
+    end
+  end
+
+  private
+    def requested_path(env)
+      Rack::Utils.unescape(env["PATH_INFO"].to_s.sub(/^\//, ""))
+    end
+end

data/lib/propshaft/version.rb

@@ -0,0 +1,3 @@
+module Propshaft
+  VERSION = "0.1.0"
+end

data/lib/propshaft.rb

@@ -0,0 +1,3 @@
+require "propshaft/assembly"
+require "propshaft/helper"
+require "propshaft/railtie"

metadata

@@ -0,0 +1,72 @@
+--- !ruby/object:Gem::Specification
+name: propshaft
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- David Heinemeier Hansson
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2021-09-19 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 7.0.0.alpha2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 7.0.0.alpha2
+description: 
+email: dhh@hey.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- MIT-LICENSE
+- README.md
+- Rakefile
+- lib/propshaft.rb
+- lib/propshaft/assembly.rb
+- lib/propshaft/asset.rb
+- lib/propshaft/compilers.rb
+- lib/propshaft/compilers/css_asset_urls.rb
+- lib/propshaft/helper.rb
+- lib/propshaft/load_path.rb
+- lib/propshaft/processor.rb
+- lib/propshaft/railtie.rb
+- lib/propshaft/resolver/dynamic.rb
+- lib/propshaft/resolver/static.rb
+- lib/propshaft/server.rb
+- lib/propshaft/version.rb
+homepage: https://github.com/rails/propshaft
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.7.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.1.4
+signing_key: 
+specification_version: 4
+summary: Deliver assets for Rails.
+test_files: []