pakyow-assets 1.0.0.rc5 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3c3f1a35dd0d09ca7a3d69237efe8e7025bf41950aaf4e71d451dd2cdf98b951
-  data.tar.gz: 4699e827b358f61137c48b41518620d6bd9db2b5cad381e406138dc8fa28ce8f
+  metadata.gz: 7357562921c8d3675d55cbb3f8a4cfee62703be2f32ecad38812ade2e279df78
+  data.tar.gz: c93e8b3c23a969ea6fb01fb9771d593da48babad12d0844e3b14ea7ae15ab667
 SHA512:
-  metadata.gz: 5b499aadd5fdc1429280b1b3f12d558880a106295c7930b4e14674d106b0efc07d17c862b507842712f5fa4edc9437b61d6cd5258d9334aa1be7d98f1bc0e772
-  data.tar.gz: 42a7c1acf7c0f73902841fb13b1f71721626c8bfedb89c12500f6cfcb4c570bb6aeafe8b77bd217fa8c9316c61711c0a07598e4b22fb0e98525f5e1aa1a760e2
+  metadata.gz: 2d1fafecd727a1e6155a154ea95d1bad80d0b40399f1f8c7e73411d460990739bdae381d4e0800223d2839663aae8a18608616ea12ae1ddf211b5488d94251a9
+  data.tar.gz: 3eb3b99bf5d6d9e9eb28cd4a7462649f0e6424078d7b8b740917c0df87d4c17e95e32dbfacc8f5892aca5bb3e0db56a7b40be9fe6f497c8a4c699707c481fcee

data/CHANGELOG.md

@@ -0,0 +1,5 @@
+# UNRELEASED
+
+# 1.0
+
+  * Hello, Web

data/lib/pakyow/application/actions/assets/process.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module Pakyow
+  class Application
+    module Actions
+      module Assets
+        # Pipeline Action that processes assets at request time.
+        #
+        # This is intended for development use, please don't use it in production.
+        # Instead, precompile assets into the public directory.
+        #
+        class Process
+          def call(connection)
+            if connection.app.config.assets.process
+              # TODO: can we short circuit if the request path doesn't match the connection?
+              if asset = find_asset(connection) || find_pack(connection) || find_asset_map(connection) || find_pack_map(connection)
+                connection.set_header("content-type", asset.mime_type)
+                connection.body = asset
+                connection.halt
+              end
+            end
+          end
+
+          private
+
+          def find_asset(connection, path = connection.path)
+            connection.app.state(:asset).find { |asset|
+              asset.public_path == path
+            }
+          end
+
+          def find_pack(connection, path = connection.path)
+            connection.app.state(:pack).lazy.map { |pack|
+              pack.packed(path)
+            }.find { |packed| !packed.nil? && packed.any? }
+          end
+
+          def find_asset_map(connection)
+            if wants_map?(connection)
+              if (asset = find_asset(connection, unmapped(connection))) && asset.source_map?
+                asset.source_map
+              end
+            end
+          end
+
+          def find_pack_map(connection)
+            if (pack = find_pack(connection, unmapped(connection))) && pack.source_map?
+              pack.source_map
+            else
+              nil
+            end
+          end
+
+          def wants_map?(connection)
+            connection.path.end_with?(".map")
+          end
+
+          def unmapped(connection)
+            File.join(File.dirname(connection.path), File.basename(connection.path, ".map"))
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pakyow/application/actions/assets/public.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+require "mini_mime"
+
+require "pakyow/support/core_refinements/string/normalization"
+
+module Pakyow
+  class Application
+    module Actions
+      module Assets
+        class Public
+          using Support::Refinements::String::Normalization
+
+          # Pipeline Action that serves files out of your public directory.
+          #
+          def initialize(app)
+            @asset_paths = app.state(:asset).map(&:public_path) + app.state(:pack).flat_map { |pack|
+              [pack.public_css_path, pack.public_js_path]
+            }
+
+            @prefix = if app.is_a?(Plugin)
+              Pathname.new(app.class.mount_path)
+            else
+              Pathname.new("/")
+            end
+          end
+
+          def call(connection)
+            if connection.app.config.assets.public
+              public_path = public_path(connection)
+
+              if public?(public_path)
+                if mime = MiniMime.lookup_by_filename(public_path)
+                  connection.set_header("content-type", mime.content_type)
+                end
+
+                if connection.app.config.assets.cache && asset?(connection)
+                  set_cache_headers(connection, public_path)
+                end
+
+                connection.body = File.open(public_path)
+                connection.halt
+              end
+            end
+          end
+
+          private
+
+          def public?(path)
+            File.file?(path)
+          end
+
+          def public_path(connection)
+            File.join(
+              connection.app.config.assets.public_path,
+              String.normalize_path(
+                Pathname.new(connection.path).relative_path_from(@prefix).to_s
+              )
+            )
+          end
+
+          def asset?(connection)
+            @asset_paths.include?(connection.path)
+          end
+
+          def set_cache_headers(connection, public_path)
+            mtime = File.mtime(public_path)
+            connection.set_header("age", (Time.now - mtime).to_i.to_s)
+            connection.set_header("cache-control", "public, max-age=31536000")
+            connection.set_header("vary", "accept-encoding")
+            connection.set_header("last-modified", mtime.httpdate)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pakyow/{assets → application}/behavior/assets.rb

@@ -5,7 +5,7 @@ require "pakyow/support/extension"
 require "pakyow/assets/asset"
 
 module Pakyow
-  module Assets
+  class Application
     module Behavior
       # Registers assets from the app's frontend/assets directory.
       #
@@ -27,7 +27,7 @@ module Pakyow
                     "/"
                   end
 
-                  self.class.asset << Asset.new_from_path(
+                  self.class.asset << Pakyow::Assets::Asset.new_from_path(
                     path,
                     config: config.assets,
                     source_location: assets_path,

data/lib/pakyow/application/behavior/assets/externals.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require "pakyow/support/extension"
+
+require "pakyow/assets/external"
+
+module Pakyow
+  class Application
+    module Behavior
+      module Assets
+        module Externals
+          extend Support::Extension
+
+          def external_script(name, version = nil, package: nil, files: nil)
+            assets_config = if is_a?(Plugin)
+              parent.config.assets
+            else
+              config.assets
+            end
+
+            assets_config.externals.scripts << Pakyow::Assets::External.new(
+              name, version: version, package: package, files: files, config: assets_config
+            )
+          end
+
+          apply_extension do
+            after "boot", "fetch.assets.externals" do
+              if config.assets.externals.pakyow
+                external_script :pakyow, "^1.0.0", package: "@pakyow/js", files: [
+                  "dist/pakyow.js",
+                  "dist/components/confirmable.js",
+                  "dist/components/form.js",
+                  "dist/components/freshener.js",
+                  "dist/components/navigator.js",
+                  "dist/components/socket.js",
+                  "dist/components/submittable.js"
+                ]
+              end
+
+              if config.assets.externals.fetch
+                fetched = false
+
+                config.assets.externals.scripts.each do |external_script|
+                  unless external_script.exist?
+                    external_script.fetch!
+                    fetched = true
+                  end
+                end
+
+                if fetched
+                  FileUtils.mkdir_p "./tmp"
+                  FileUtils.touch "./tmp/restart.txt"
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pakyow/application/behavior/assets/packs.rb

@@ -0,0 +1,164 @@
+# frozen_string_literal: true
+
+require "pakyow/support/extension"
+
+module Pakyow
+  class Application
+    module Behavior
+      module Assets
+        module Packs
+          extend Support::Extension
+
+          apply_extension do
+            after "initialize", "initialize.assets.packs", priority: :high do
+              config.assets.packs.paths.each do |packs_path|
+                Pathname.glob(File.join(packs_path, "*.*")).group_by { |path|
+                  File.join(File.dirname(path), File.basename(path, File.extname(path)))
+                }.to_a.sort { |pack_a, pack_b|
+                  pack_b[1] <=> pack_a[1]
+                }.uniq { |pack_path, _|
+                  accessible_pack_path(pack_path)
+                }.map { |pack_path, pack_asset_paths|
+                  [accessible_pack_path(pack_path), pack_asset_paths]
+                }.reverse.each do |pack_path, pack_asset_paths|
+                  prefix = if is_a?(Plugin)
+                    self.class.mount_path
+                  else
+                    "/"
+                  end
+
+                  asset_pack = Pakyow::Assets::Pack.new(File.basename(pack_path).to_sym, config.assets, prefix: prefix)
+
+                  pack_asset_paths.each do |pack_asset_path|
+                    if config.assets.extensions.include?(File.extname(pack_asset_path))
+                      asset_pack << Pakyow::Assets::Asset.new_from_path(
+                        pack_asset_path,
+                        config: config.assets,
+                        related: state(:asset)
+                      )
+                    end
+                  end
+
+                  self.pack << asset_pack.finalize
+                end
+              end
+
+              state(:templates).each do |template_store|
+                build_layout_packs(template_store)
+                build_page_packs(template_store)
+              end
+            end
+          end
+
+          def packs(view)
+            (autoloaded_packs + view_packs(view) + component_packs(view)).uniq.each_with_object([]) { |pack_name, packs|
+              if found_pack = state(:pack).find { |pack| pack.name == pack_name.to_sym }
+                packs << found_pack
+              end
+            }
+          end
+
+          private
+
+          def accessible_pack_path(pack_path)
+            pack_path_parts = pack_path.split("/")
+            pack_path_parts[-1] = if pack_path_parts[-1].include?("__")
+              pack_path_parts[-1].split("__", 2)[1]
+            elsif pack_path_parts[-1].include?("@")
+              pack_path_parts[-1].split("@", 2)[0]
+            else
+              pack_path_parts[-1]
+            end
+
+            pack_path_parts.join("/")
+          end
+
+          def autoloaded_packs
+            config.assets.packs.autoload
+          end
+
+          def view_packs(view)
+            view.info(:packs).to_a
+          end
+
+          def component_packs(view)
+            view.object.each_significant_node(:component, descend: true).flat_map { |node|
+              node.label(:components).map { |component|
+                component[:name]
+              }
+            }
+          end
+
+          def build_layout_packs(template_store)
+            template_store.layouts.each do |layout_name, layout|
+              layout_pack = Pakyow::Assets::Pack.new(:"layouts/#{layout_name}", config.assets)
+              register_pack_with_view(layout_pack, layout)
+
+              Pathname.glob(File.join(template_store.layouts_path, "#{layout_name}.*")) do |potential_asset_path|
+                next if template_store.template?(potential_asset_path)
+                layout_pack << Pakyow::Assets::Asset.new_from_path(
+                  potential_asset_path,
+                  config: config.assets,
+                  related: state(:asset)
+                )
+              end
+
+              self.pack << layout_pack.finalize
+            end
+          end
+
+          def build_page_packs(template_store)
+            template_store.paths.each do |view_path|
+              template_info = template_store.info(view_path)
+
+              page_pack = Pakyow::Assets::Pack.new(:"#{template_info[:page].logical_path[1..-1]}", config.assets)
+              register_pack_with_view(page_pack, template_info[:page])
+
+              # Find all partials used by the page.
+              #
+              partials = template_info[:page].container_views.each_with_object([]) { |page_container, page_container_partials|
+                page_container_partials.concat(page_container.find_partials(template_info[:partials]))
+              } + template_info[:layout].find_partials(template_info[:partials])
+
+              # Include assets for partials used by the page into the page pack.
+              #
+              partials.each do |partial_name|
+                if partial = template_info[:partials][partial_name]
+                  Pathname.glob(File.join(config.presenter.path, "#{partial.logical_path}.*")) do |potential_asset_path|
+                    next if template_store.template?(potential_asset_path)
+                    page_pack << Pakyow::Assets::Asset.new_from_path(
+                      potential_asset_path,
+                      config: config.assets,
+                      related: state(:asset)
+                    )
+                  end
+                end
+              end
+
+              # Include assets defined for the page itself.
+              #
+              Pathname.glob(File.join(template_info[:page].path.dirname, "#{template_info[:page].path.basename(template_info[:page].path.extname)}.*")) do |potential_asset_path|
+                next if template_store.template?(potential_asset_path)
+                page_pack << Pakyow::Assets::Asset.new_from_path(
+                  potential_asset_path,
+                  config: config.assets,
+                  related: state(:asset)
+                )
+              end
+
+              self.pack << page_pack.finalize
+            end
+          end
+
+          def register_pack_with_view(pack, view)
+            unless view.info(:packs)
+              view.add_info(packs: [])
+            end
+
+            view.info(:packs) << pack.name
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pakyow/application/behavior/assets/prelaunching.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require "pakyow/support/extension"
+
+module Pakyow
+  class Application
+    module Behavior
+      module Assets
+        module Prelaunching
+          extend Support::Extension
+
+          apply_extension do
+            on "configure" do
+              config.tasks.prelaunch << "assets:precompile"
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pakyow/application/behavior/assets/processing.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require "pakyow/support/extension"
+
+module Pakyow
+  class Application
+    module Behavior
+      module Assets
+        module Processing
+          extend Support::Extension
+
+          apply_extension do
+            on "load" do
+              if self.class.includes_framework?(:presenter)
+                self.class.processor :html do |content|
+                  state(:asset).each do |asset|
+                    content.gsub!(asset.logical_path, File.join(config.assets.host, asset.public_path))
+                  end
+
+                  content
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end