pakyow-assets 0.1.2 → 1.0.0.rc1

data/lib/pakyow/assets/behavior/rendering/install_assets.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require "pakyow/support/extension"
+
+module Pakyow
+  module Assets
+    module Behavior
+      module Rendering
+        module InstallAssets
+          extend Support::Extension
+
+          apply_extension do
+            build do |view, app:|
+              if head = view.head
+                packs = app.packs(view)
+
+                if app.is_a?(Plugin)
+                  packs = app.parent.packs(view).concat(packs)
+                end
+
+                packs.uniq { |pack|
+                  pack.public_path
+                }.each do |pack|
+                  if pack.javascripts?
+                    head.object.append_html("<script src=\"#{pack.public_path}.js\"></script>\n")
+                  end
+
+                  if pack.stylesheets?
+                    head.object.append_html("<link rel=\"stylesheet\" type=\"text/css\" media=\"all\" href=\"#{pack.public_path}.css\">\n")
+                  end
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pakyow/assets/behavior/silencing.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require "pakyow/support/extension"
+
+module Pakyow
+  module Assets
+    module Behavior
+      # Silences asset requests from being logged.
+      #
+      module Silencing
+        extend Support::Extension
+
+        apply_extension do
+          on "load" do
+            if config.assets.silent
+              # silence asset requests
+              Pakyow.silence do |connection|
+                # TODO: do we need the second check?
+                connection.path.start_with?(config.assets.prefix) || self.class.asset.instances.any? { |asset|
+                  asset.logical_path == connection.path
+                }
+              end
+
+              # silence requests to public files
+              Pakyow.silence do |connection|
+                # TODO: really need an in-memory directory for these files
+                File.file?(File.join(config.assets.public_path, connection.path))
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pakyow/assets/behavior/watching.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require "pakyow/support/extension"
+
+module Pakyow
+  module Assets
+    module Behavior
+      module Watching
+        extend Support::Extension
+
+        apply_extension do
+          after "configure" do
+            config.assets.extensions.each do |extension|
+              config.process.watched_paths << File.join(config.presenter.path, "**/*#{extension}")
+
+              # Exclude vendored assets.
+              #
+              config.process.excluded_paths << File.join(config.assets.externals.path, "*#{extension}")
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pakyow/assets/errors.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require "pakyow/error"
+
+module Pakyow
+  module Assets
+    class Error < Pakyow::Error
+    end
+
+    class UnknownExternalAsset < Error
+      class_state :messages, default: {
+        default: "`{asset}' is not a known external asset"
+      }.freeze
+    end
+  end
+end

data/lib/pakyow/assets/external.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+require "http"
+
+require "pakyow/support/cli/runner"
+
+module Pakyow
+  module Assets
+    # @api private
+    class External
+      attr_reader :name, :version, :package
+
+      def initialize(name, version:, package:, files:, config:)
+        @name, @version, @config = name, version, config
+        @package = package || name
+        @files = files || []
+      end
+
+      def exist?
+        if @files.empty?
+          Dir.glob(File.join(@config.externals.path, "#{@name}*.js")).any?
+        else
+          !@files.any? { |file|
+            if File.basename(file, File.extname(file)) == @name.to_s
+              Dir.glob(File.join(@config.externals.path, "#{@name}*.js")).empty?
+            else
+              Dir.glob(File.join(@config.externals.path, "#{@name}*__#{File.basename(file, File.extname(file))}.js")).empty?
+            end
+          }
+        end
+      end
+
+      def fetch!
+        if @files.empty?
+          fetch_file!(nil)
+        else
+          @files.each do |file|
+            fetch_file!(file)
+          end
+        end
+      end
+
+      private
+
+      def fetch_file!(file)
+        name_with_version = if @version
+          "#{name}@#{@version}"
+        else
+          name.to_s
+        end
+
+        file_with_version = File.join(name_with_version, file.to_s).chomp("/")
+
+        package_with_version = if @version
+          "#{@package}@#{@version}"
+        else
+          @package.to_s
+        end
+
+        Support::CLI::Runner.new(message: "Fetching #{file_with_version}").run do |runner|
+          begin
+            response = HTTP.follow(true).get(
+              File.join(
+                @config.externals.provider,
+                package_with_version,
+                file.to_s
+              )
+            )
+
+            if response.code == 200
+              FileUtils.mkdir_p(@config.externals.path)
+
+              fetched_version = response.uri.to_s.split(@package.to_s, 2)[1].split("/", 2)[0].split("@", 2)[1]
+              file_basename = File.basename(file.to_s, File.extname(file.to_s))
+
+              local_path = if file && file_basename != name.to_s
+                File.join(
+                  @config.externals.path,
+                  "#{name}@#{fetched_version}__#{file_basename}.js"
+                )
+              else
+                File.join(
+                  @config.externals.path,
+                  "#{name}@#{fetched_version}.js"
+                )
+              end
+
+              File.open(local_path, "w") do |fp|
+                fp.write(response.body.to_s)
+              end
+
+              runner.succeeded
+            else
+              runner.failed(response.to_s)
+            end
+          rescue HTTP::ConnectionError => error
+            runner.failed(error.to_s)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pakyow/assets/framework.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require "pakyow/framework"
+
+require "pakyow/assets/asset"
+require "pakyow/assets/pack"
+
+require "pakyow/assets/behavior/config"
+require "pakyow/assets/behavior/assets"
+require "pakyow/assets/behavior/packs"
+require "pakyow/assets/behavior/silencing"
+require "pakyow/assets/behavior/externals"
+require "pakyow/assets/behavior/watching"
+require "pakyow/assets/behavior/prelaunching"
+require "pakyow/assets/behavior/processing"
+
+require "pakyow/assets/behavior/rendering/install_assets"
+
+module Pakyow
+  module Assets
+    class Framework < Pakyow::Framework(:assets)
+      def boot
+        object.class_eval do
+          # Let other frameworks load their own assets.
+          #
+          stateful :asset, Asset
+
+          # Let other frameworks load their own asset packs.
+          #
+          stateful :pack, Pack
+
+          include Behavior::Config
+          include Behavior::Assets
+          include Behavior::Packs
+          include Behavior::Silencing
+          include Behavior::Externals
+          include Behavior::Watching
+          include Behavior::Prelaunching
+          include Behavior::Processing
+
+          after "load" do
+            isolated(:Renderer) do
+              # Load this one later, in case other actions define components that will load assets.
+              #
+              include Assets::Behavior::Rendering::InstallAssets
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pakyow/assets/pack.rb

@@ -0,0 +1,171 @@
+# frozen_string_literal: true
+
+require "digest/md5"
+require "forwardable"
+
+require "pakyow/support/core_refinements/string/normalization"
+
+require "pakyow/assets/asset"
+require "pakyow/assets/source_map"
+
+module Pakyow
+  module Assets
+    class Pack
+      using Support::Refinements::String::Normalization
+
+      attr_reader :name, :public_path
+
+      def initialize(name, config, prefix: "/")
+        @name, @config = name, config
+        @assets = []
+        @packed = { js: [], css: [] }
+        @public_path = String.normalize_path(
+          File.join(config.prefix, prefix, "packs", name.to_s)
+        )
+      end
+
+      def finalize
+        tap do
+          if @config.fingerprint
+            extension = File.extname(@public_path)
+            @public_path = File.join(
+              File.dirname(@public_path),
+              File.basename(@public_path, extension) + "__" + fingerprint + extension
+            )
+          end
+
+          pack_assets!
+        end
+      end
+
+      def <<(asset)
+        @assets << asset.disable_source_map
+      end
+
+      def packed(path)
+        if path.start_with?(@public_path + ".")
+          @packed[File.extname(path)[1..-1].to_sym]
+        else
+          nil
+        end
+      end
+
+      def javascripts
+        @packed[:js]
+      end
+
+      def stylesheets
+        @packed[:css]
+      end
+
+      def javascripts?
+        javascripts.any?
+      end
+
+      def stylesheets?
+        stylesheets.any?
+      end
+
+      def fingerprint
+        @assets.flat_map(&:fingerprint).sort.each_with_object(Digest::MD5.new) { |fingerprint, digest|
+          digest.update(fingerprint)
+        }.hexdigest
+      end
+
+      def public_js_path
+        @public_path + ".js"
+      end
+
+      def public_css_path
+        @public_path + ".css"
+      end
+
+      private
+
+      def pack_assets!
+        @packed[:js] = PackedAssets.new(@assets.select { |asset|
+          asset.mime_suffix == "javascript"
+        }, public_js_path, @config, @name)
+
+        @packed[:css] = PackedAssets.new(@assets.select { |asset|
+          asset.mime_suffix == "css"
+        }, public_css_path, @config, @name)
+      end
+    end
+
+    class PackedAssets
+      extend Forwardable
+      def_delegators :@assets, :any?
+
+      attr_reader :public_path, :assets
+
+      def initialize(assets, public_path, config, name)
+        @assets, @public_path, @config, @name = assets, public_path, config, name
+      end
+
+      def initialize_copy(_)
+        super
+
+        @assets = @assets.map(&:dup)
+      end
+
+      def mime_type
+        @assets.first&.mime_type
+      end
+
+      def mime_suffix
+        @assets.first&.mime_suffix
+      end
+
+      def each(&block)
+        @assets.each do |asset|
+          asset.each(&block)
+        end
+
+        if @config.source_maps && source_map?
+          yield source_mapping_url
+        end
+      end
+
+      def read
+        String.new.tap do |packed_asset|
+          @assets.each do |asset|
+            packed_asset << asset.read
+          end
+
+          if @config.source_maps && source_map?
+            packed_asset << source_mapping_url
+          end
+        end
+      end
+
+      def bytesize
+        bytes = @assets.map(&:bytesize).inject(&:+)
+
+        if @config.source_maps && source_map?
+          bytes += source_mapping_url.bytesize
+        end
+
+        bytes
+      end
+
+      def source_map
+        @assets.select(&:source_map?).inject(
+          SourceMap.new(
+            file: File.basename(@public_path)
+          )
+        ) { |merged, asset|
+          merged.merge(asset.source_map)
+        }
+      end
+
+      def source_map?
+        @assets.any?(&:source_map?)
+      end
+
+      def source_mapping_url
+        SourceMap.mapping_url(path: @public_path, type: @assets.first.mime_suffix)
+      end
+    end
+  end
+end