hanami-sprockets 0.1.0

data/lib/hanami/sprockets/helpers.rb

@@ -0,0 +1,206 @@
+# frozen_string_literal: true
+
+require "hanami/view/html"
+
+module Hanami
+  class Assets
+    # Asset helpers for use in templates
+    #
+    # @api public
+    # @since 0.1.0
+    module Helpers
+      # Generate a stylesheet link tag
+      #
+      # @param sources [Array<String>] one or more stylesheet sources
+      # @param options [Hash] HTML attributes
+      #
+      # @return [String] HTML link tags
+      #
+      # @api public
+      # @since 0.1.0
+      def stylesheet_tag(*sources, **options)
+        sources.map do |source|
+          if external_source?(source)
+            stylesheet_link_tag(source, **options)
+          else
+            begin
+              asset = hanami_assets[source + ".css"]
+              attrs = build_stylesheet_attributes(asset, **options)
+              stylesheet_link_tag(asset.url, **attrs)
+            rescue AssetMissingError
+              stylesheet_link_tag("#{hanami_assets.config.path_prefix}/#{source}.css", **options)
+            end
+          end
+        end.join("\n").html_safe
+      end
+
+      # Generate a javascript script tag
+      #
+      # @param sources [Array<String>] one or more javascript sources
+      # @param options [Hash] HTML attributes
+      #
+      # @return [String] HTML script tags
+      #
+      # @api public
+      # @since 0.1.0
+      def javascript_tag(*sources, **options)
+        sources.map do |source|
+          if external_source?(source)
+            javascript_include_tag(source, **options)
+          else
+            begin
+              asset = hanami_assets[source + ".js"]
+              attrs = build_javascript_attributes(asset, **options)
+              javascript_include_tag(asset.url, **attrs)
+            rescue AssetMissingError
+              javascript_include_tag("#{hanami_assets.config.path_prefix}/#{source}.js", **options)
+            end
+          end
+        end.join("\n").html_safe
+      end
+
+      # Generate an image tag
+      #
+      # @param source [String] image source
+      # @param options [Hash] HTML attributes
+      #
+      # @return [String] HTML img tag
+      #
+      # @api public
+      # @since 0.1.0
+      def image_tag(source, **options)
+        if external_source?(source)
+          build_image_tag(source, **options).html_safe
+        else
+          begin
+            # Try common image extensions
+            %w[.png .jpg .jpeg .gif .svg].each do |ext|
+              begin
+                asset = hanami_assets[source + ext]
+                return build_image_tag(asset.url, **options).html_safe
+              rescue AssetMissingError
+                next
+              end
+            end
+
+            # Fallback to direct path
+            build_image_tag("#{hanami_assets.config.path_prefix}/#{source}", **options).html_safe
+          rescue AssetMissingError
+            build_image_tag("#{hanami_assets.config.path_prefix}/#{source}", **options).html_safe
+          end
+        end
+      end
+
+      # Get the URL for an asset
+      #
+      # @param source [String] asset source
+      #
+      # @return [String] asset URL
+      #
+      # @api public
+      # @since 0.1.0
+      def asset_url(source)
+        if external_source?(source)
+          source
+        else
+          begin
+            hanami_assets[source].url
+          rescue AssetMissingError
+            "#{hanami_assets.config.path_prefix}/#{source}"
+          end
+        end
+      end
+
+      # Get the path for an asset (without base URL)
+      #
+      # @param source [String] asset source
+      #
+      # @return [String] asset path
+      #
+      # @api public
+      # @since 0.1.0
+      def asset_path(source)
+        if external_source?(source)
+          source
+        else
+          begin
+            hanami_assets[source].path
+          rescue AssetMissingError
+            "#{hanami_assets.config.path_prefix}/#{source}"
+          end
+        end
+      end
+
+
+      private
+
+      def hanami_assets
+        # This should be set by the framework integration
+        @hanami_assets or raise "Hanami::Assets instance not configured"
+      end
+
+      def external_source?(source)
+        source.start_with?('http://') || source.start_with?('https://') || source.start_with?('//')
+      end
+
+      def stylesheet_link_tag(href, **options)
+        attrs = { href: href, type: "text/css", rel: "stylesheet" }.merge(options)
+        "<link#{build_html_attributes(attrs)}>"
+      end
+
+      def javascript_include_tag(src, **options)
+        attrs = { src: src, type: "text/javascript" }.merge(options)
+        "<script#{build_html_attributes(attrs)}></script>"
+      end
+
+      def build_image_tag(src, **options)
+        attrs = { src: src }.merge(options)
+        "<img#{build_html_attributes(attrs)}>"
+      end
+
+
+      def build_stylesheet_attributes(asset, **options)
+        attrs = options.dup
+
+        if hanami_assets.subresource_integrity? && asset.sri && hanami_assets.crossorigin?(asset.url)
+          attrs[:integrity] = asset.sri
+          attrs[:crossorigin] = "anonymous" unless attrs.key?(:crossorigin)
+        end
+
+        attrs
+      end
+
+      def build_javascript_attributes(asset, **options)
+        attrs = options.dup
+
+        if hanami_assets.subresource_integrity? && asset.sri && hanami_assets.crossorigin?(asset.url)
+          attrs[:integrity] = asset.sri
+          attrs[:crossorigin] = "anonymous" unless attrs.key?(:crossorigin)
+        end
+
+        attrs
+      end
+
+
+      def build_html_attributes(attrs)
+        attrs.map do |key, value|
+          if value == true
+            " #{key}"
+          elsif value
+            " #{key}=\"#{escape_html(value)}\""
+          end
+        end.join
+      end
+
+      def escape_html(string)
+        string.to_s.gsub(/[&<>"]/, {
+          "&" => "&amp;",
+          "<" => "&lt;",
+          ">" => "&gt;",
+          '"' => "&quot;"
+        })
+      end
+
+    end
+  end
+end

data/lib/hanami/sprockets/middleware.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module Hanami
+  class Assets
+    # Rack middleware for serving assets in development
+    #
+    # @api public
+    # @since 0.1.0
+    class Middleware
+      # @api private
+      # @since 0.1.0
+      def initialize(app, assets)
+        @app = app
+        @assets = assets
+      end
+
+      # @api private
+      # @since 0.1.0
+      def call(env)
+        request = Rack::Request.new(env)
+
+        # Check if this is an asset request
+        if asset_request?(request.path)
+          serve_asset(request.path)
+        else
+          @app.call(env)
+        end
+      end
+
+      private
+
+      def asset_request?(path)
+        path.start_with?(@assets.config.path_prefix)
+      end
+
+      def serve_asset(path)
+        # Remove the path prefix to get the logical path
+        logical_path = path.sub(@assets.config.path_prefix + "/", "")
+
+        begin
+          # Try to find the asset first
+          sprockets_asset = @assets.environment.find_asset(logical_path)
+
+          # If not found and looks like a fingerprinted asset, try stripping the fingerprint
+          if !sprockets_asset && logical_path.match(/-[a-f0-9]+(\.[^.]+)$/)
+            base_name = logical_path.sub(/-[a-f0-9]+(\.[^.]+)$/, '\1')
+            sprockets_asset = @assets.environment.find_asset(base_name)
+            logical_path = base_name if sprockets_asset
+          end
+          if sprockets_asset
+            headers = {
+              'Content-Type' => sprockets_asset.content_type,
+              'Content-Length' => sprockets_asset.bytesize.to_s,
+              'ETag' => %("#{sprockets_asset.etag}"),
+              'Cache-Control' => 'public, max-age=31536000'
+            }
+
+            [200, headers, [sprockets_asset.source]]
+          else
+            [404, { 'Content-Type' => 'text/plain' }, ['Asset not found']]
+          end
+        rescue => e
+          [500, { 'Content-Type' => 'text/plain' }, ["Asset error: #{e.message}"]]
+        end
+      end
+    end
+  end
+end

data/lib/hanami/sprockets/version.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Hanami
+  class Assets
+    # @api private
+    # @since 0.1.0
+    VERSION = "0.1.0"
+  end
+end

data/lib/hanami/sprockets.rb

@@ -0,0 +1,338 @@
+# frozen_string_literal: true
+
+require "json"
+require "pathname"
+require "zeitwerk"
+require "sprockets"
+require "base64"
+require "digest"
+
+module Hanami
+  # Assets management for Ruby web applications using Sprockets
+  #
+  # @since 0.1.0
+  class Assets
+    # @since 0.1.0
+    # @api private
+    def self.gem_loader
+      @gem_loader ||= Zeitwerk::Loader.new.tap do |loader|
+        root = File.expand_path("..", __dir__)
+        loader.tag = "hanami-sprockets"
+        loader.push_dir(root)
+        loader.ignore(
+          "#{root}/hanami-sprockets.rb",
+          "#{root}/hanami/sprockets/version.rb",
+          "#{root}/hanami/sprockets/errors.rb"
+        )
+        loader.enable_reloading if loader.respond_to?(:enable_reloading)
+        loader.inflector = Zeitwerk::GemInflector.new("#{root}/hanami-sprockets.rb")
+      end
+    end
+
+    gem_loader.setup
+    require_relative "sprockets/version"
+    require_relative "sprockets/errors"
+    require_relative "sprockets/config"
+    require_relative "sprockets/base_url"
+    require_relative "sprockets/asset"
+    require_relative "sprockets/helpers"
+    require_relative "sprockets/middleware"
+
+    # Returns the directory (under `public/assets/`) to be used for storing a slice's compiled
+    # assets.
+    #
+    # This is shared logic used by both Hanami (for the assets provider) and Hanami::CLI (for the
+    # assets commands).
+    #
+    # @since 0.1.0
+    # @api private
+    def self.public_assets_dir(slice)
+      return nil if slice.app.eql?(slice)
+
+      slice.slice_name.to_s.split("/").map { |name| "_#{name}" }.join("/")
+    end
+
+    # @api private
+    # @since 0.1.0
+    attr_reader :config
+
+    # @api private
+    # @since 0.1.0
+    attr_reader :root
+
+    # @api private
+    # @since 0.1.0
+    attr_reader :environment
+
+    # @api public
+    # @since 0.1.0
+    def initialize(config:, root:)
+      @config = config
+      @root = Pathname(root)
+      @environment = setup_sprockets_environment
+    end
+
+    # Returns the asset at the given path.
+    #
+    # @return [Hanami::Sprockets::Asset] the asset
+    #
+    # @raise AssetMissingError if no asset can be found at the path
+    #
+    # @api public
+    # @since 0.1.0
+    def [](path)
+      # Find the asset using Sprockets
+      sprockets_asset = environment.find_asset(path)
+
+      raise AssetMissingError.new(path) unless sprockets_asset
+
+      # Generate the asset path - use digest_path for fingerprinting in production
+      asset_path = if config.digest
+        "#{config.path_prefix}/#{sprockets_asset.digest_path}"
+      else
+        "#{config.path_prefix}/#{sprockets_asset.logical_path}"
+      end
+
+      # Create our Asset wrapper
+      Asset.new(
+        path: asset_path,
+        base_url: config.base_url,
+        sri: calculate_sri(sprockets_asset),
+        logical_path: sprockets_asset.logical_path,
+        digest_path: sprockets_asset.digest_path,
+        content_type: sprockets_asset.content_type,
+        source: sprockets_asset.source
+      )
+    end
+
+    # Returns true if subresource integrity is configured.
+    #
+    # @return [Boolean]
+    #
+    # @api public
+    # @since 0.1.0
+    def subresource_integrity?
+      config.subresource_integrity.any?
+    end
+
+    # Returns true if the given source path is a cross-origin request.
+    #
+    # @return [Boolean]
+    #
+    # @api public
+    # @since 0.1.0
+    def crossorigin?(source_path)
+      config.crossorigin?(source_path)
+    end
+
+    # Precompile assets (for production)
+    #
+    # @api public
+    # @since 0.1.0
+    def precompile(target_dir = nil, &block)
+      target_dir ||= root.join("public", "assets")
+      target_dir = Pathname(target_dir)
+      target_dir.mkpath
+
+      manifest = ::Sprockets::Manifest.new(environment, target_dir, "manifest.json")
+
+      # Precompile configured assets - compile by explicit names first
+      ['app.css', 'app.js'].each do |asset|
+        begin
+          manifest.compile(asset)
+          block&.call(asset) if block
+        rescue Sprockets::FileNotFound
+          # Asset doesn't exist, skip it
+        end
+      end
+
+      # Then process configured precompile patterns
+      config.precompile.each do |asset|
+        begin
+          manifest.compile(asset)
+          block&.call(asset) if block
+        rescue Sprockets::FileNotFound
+          # Asset doesn't exist, skip it
+        end
+      end
+
+      # Write the manifest file
+      File.write(File.join(target_dir, "manifest.json"), JSON.pretty_generate(manifest.assets))
+
+      manifest
+    end
+
+    # Get all logical paths (useful for debugging)
+    #
+    # @api public
+    # @since 0.1.0
+    def logical_paths
+      paths = []
+      # Walk through all load paths and find assets
+      environment.paths.each do |load_path|
+        next unless Dir.exist?(load_path)
+
+        Dir.glob("**/*", base: load_path).each do |file|
+          full_path = File.join(load_path, file)
+          next unless File.file?(full_path)
+          next if File.basename(file).start_with?(".")
+
+          # Try to find it as an asset to see if Sprockets can handle it
+          begin
+            if environment.find_asset(file)
+              paths << file
+            end
+          rescue
+            # Skip files that cause errors
+          end
+        end
+      end
+
+      paths.uniq.sort
+    end
+    # Clear the cache (useful in development)
+    #
+    # @api public
+    # @since 0.1.0
+    def clear_cache!
+      @environment = setup_sprockets_environment
+    end
+
+    private
+
+    def setup_sprockets_environment
+      env = ::Sprockets::Environment.new(root.to_s)
+
+      # Set up context class for helpers
+      assets_config = config
+      env.context_class.class_eval do
+        define_method :asset_path do |path, options = {}|
+          # Find the asset and return its path
+          asset = environment.find_asset(path)
+          if asset
+            if assets_config.digest
+              "#{assets_config.path_prefix}/#{asset.digest_path}"
+            else
+              "#{assets_config.path_prefix}/#{asset.logical_path}"
+            end
+          else
+            "#{assets_config.path_prefix}/#{path}"
+          end
+        end
+
+        define_method :asset_url do |path, options = {}|
+          asset_path(path, options)
+        end
+      end
+
+      # Add common Rails-like asset paths
+      potential_paths = [
+        "app/assets/stylesheets",
+        "app/assets/javascripts",
+        "app/assets/images",
+        "app/assets/fonts",
+        "lib/assets/stylesheets",
+        "lib/assets/javascripts",
+        "lib/assets/images",
+        "vendor/assets/stylesheets",
+        "vendor/assets/javascripts",
+        "vendor/assets/images"
+      ]
+
+      potential_paths.each do |path_str|
+        full_path = root.join(path_str)
+        env.append_path(full_path.to_s) if full_path.exist?
+      end
+
+      # Add any additional paths from config
+      config.asset_paths.each { |path| env.append_path(path) }
+
+      # Automatically discover and add gem asset paths
+      discover_gem_asset_paths.each { |path| env.append_path(path) }
+
+      # Configure processors based on what gems are available
+      configure_processors(env)
+
+      env
+    end
+
+    def configure_processors(env)
+      # Sprockets will auto-detect most processors if the gems are available
+      # But we can explicitly configure them here if needed
+
+      # SCSS/Sass support (if sassc is available)
+      begin
+        require 'sassc'
+        # SassC will automatically be used for .scss and .sass files
+        # Sprockets will handle this automatically
+      rescue LoadError
+        # Sass not available, that's fine
+      end
+
+      # CoffeeScript support (if coffee-rails is available)
+      begin
+        require 'coffee_script'
+        # Sprockets will automatically use CoffeeScript if available
+      rescue LoadError
+        # CoffeeScript not available, that's fine
+      end
+
+      # ES6+ support via Babel (if babel-transpiler is available)
+      begin
+        require 'babel/transpiler'
+        env.register_transformer 'application/javascript', 'application/javascript', Sprockets::BabelProcessor
+      rescue LoadError
+        # Babel not available, that's fine
+      end
+    end
+
+    def discover_gem_asset_paths
+      paths = []
+
+      # Common asset directory patterns that gems use
+      asset_patterns = [
+        'assets/stylesheets',
+        'assets/javascripts',
+        'assets/images',
+        'assets/fonts',
+        'app/assets/stylesheets',
+        'app/assets/javascripts',
+        'app/assets/images',
+        'vendor/assets/stylesheets',
+        'vendor/assets/javascripts'
+      ]
+
+      # Iterate through all loaded gems
+      Gem.loaded_specs.each do |name, spec|
+        asset_patterns.each do |pattern|
+          potential_path = File.join(spec.gem_dir, pattern)
+          if File.directory?(potential_path)
+            paths << potential_path
+          end
+        end
+      end
+
+      paths
+    end
+
+    def calculate_sri(sprockets_asset)
+      return nil unless subresource_integrity?
+
+      algorithms = config.subresource_integrity
+      sri_values = []
+
+      algorithms.each do |algorithm|
+        case algorithm
+        when :sha256
+          sri_values << "sha256-#{Base64.strict_encode64(Digest::SHA256.digest(sprockets_asset.source))}"
+        when :sha384
+          sri_values << "sha384-#{Base64.strict_encode64(Digest::SHA384.digest(sprockets_asset.source))}"
+        when :sha512
+          sri_values << "sha512-#{Base64.strict_encode64(Digest::SHA512.digest(sprockets_asset.source))}"
+        end
+      end
+
+      sri_values.join(" ")
+    end
+  end
+end

data/lib/hanami-sprockets.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require_relative "hanami/sprockets"