pakyow-assets 0.1.2 → 1.0.0.rc1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: c322853e853a355500e4b045b22acbcbec3c8925
-  data.tar.gz: 29ce5c954d0d4c71025efdd12dfe70548155a9be
+SHA256:
+  metadata.gz: bfdfa0ac5ee2f817f474ac114dc81491ff8dbaa4bbbc7a4a15b2020c5c102bd6
+  data.tar.gz: 57af0c11222e8c0ed16e6a3c18627f6d9971d395919cf199b5f13d4b348b0817
 SHA512:
-  metadata.gz: 3e8c251d6f988046ff36e19bfef1200d4d5eefdb3d5009eb1eca1e02652f519e7567d0284400212b1178c2b826fd9eae8febacdefed5a2afa30fc621746c5dba
-  data.tar.gz: 760555a99ee7ee4ba3078831066c40aec304b3ac455eb4228b56107cbd544a8d507e12a0e706df66f6186077e954caf51929d1b2fd67e127b6231a536f5bd7ca
+  metadata.gz: 293fbdf6b36ad59ff7c046374c899c9ba26aab45ff365175e90dc3f2ce8ddd385ae0d8c47909721efa16ddad9d66e9e5fae09884737258bfb167a3dd57ee2124
+  data.tar.gz: 443a19539eff33d4650568901ee1244453b2aa2e36b996202572846dd5fad51980fb567494f421b04de9405833a50a93ece963a18a3f3a842a8656395f256e82

data/LICENSE

@@ -1,20 +1,4 @@
-Copyright (c) 2015 Bryan Powell
+Copyright (c) Metabahn, LLC
 
-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.
+Pakyow Assets is an open-source project licensed under the terms of the LGPLv3 license.
+See <https://choosealicense.com/licenses/lgpl-3.0/> for license text.

data/lib/pakyow/assets.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require "pakyow/routing"
+require "pakyow/support"
+require "pakyow/presenter"
+
+require "pakyow/assets/framework"
+
+require "pakyow/assets/actions/process"
+require "pakyow/assets/actions/public"
+
+require "pakyow/assets/types/js"
+require "pakyow/assets/types/css"
+require "pakyow/assets/types/sass"
+require "pakyow/assets/types/scss"
+
+module Pakyow
+  config.tasks.paths << File.expand_path("../assets/tasks", __FILE__)
+end

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

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module Pakyow
+  module Assets
+    module Actions
+      # 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

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

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require "mini_mime"
+
+require "pakyow/support/core_refinements/string/normalization"
+
+module Pakyow
+  module Assets
+    module Actions
+      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

data/lib/pakyow/assets/asset.rb

@@ -0,0 +1,238 @@
+# frozen_string_literal: true
+
+require "digest/md5"
+
+require "pakyow/support/class_state"
+require "pakyow/support/core_refinements/string/normalization"
+
+require "pakyow/assets/source_map"
+
+module Pakyow
+  module Assets
+    # Represents an asset.
+    #
+    # Instances are created when booting in all environments, meaning the app
+    # is guaranteed access to these objects. Contents are loaded and processed
+    # eagerly. This is expected to happen under two scenarios:
+    #
+    #   1. In development, an asset is loaded and processed when it's requested.
+    #   2. In production, when assets are precompiled during a deployment.
+    #
+    class Asset
+      using Support::Refinements::String::Normalization
+
+      extend Support::ClassState
+      class_state :__types, default: []
+      class_state :__emits, default: nil
+      class_state :__extensions, default: [], inheritable: true
+      class_state :__minifiable, default: false, inheritable: true
+
+      class << self
+        def new_from_path(path, config:, source_location: "", prefix: "/", related: [])
+          asset_class = @__types.find { |type|
+            type.__extensions.include?(File.extname(path))
+          } || self
+
+          asset_class.load; asset_class.new(
+            local_path: path,
+            source_location: source_location,
+            config: config,
+            prefix: prefix,
+            related: related
+          )
+        end
+
+        # Implemented by subclasses to load any libraries they need.
+        #
+        def load
+          # intentionally empty
+        end
+
+        # @api private
+        def inherited(asset_class)
+          @__types << asset_class
+          super
+        end
+
+        # @api private
+        def update_path_for_emitted_type(path)
+          if @__emits
+            path.sub(File.extname(path), @__emits)
+          else
+            path
+          end
+        end
+
+        private
+
+        # Registers +extension+ for this asset.
+        #
+        def extension(extension)
+          extensions(extension)
+        end
+
+        # Registers multiple extensions for this asset.
+        #
+        def extensions(*extensions)
+          extensions.each do |extension|
+            @__extensions << ".#{extension}"
+          end
+        end
+
+        # Defines the emitted asset type (e.g. +sass+ emits +css+).
+        #
+        def emits(type)
+          @__emits = ".#{type}"
+        end
+      end
+
+      attr_reader :logical_path, :mime_type, :mime_suffix, :dependencies
+
+      def initialize(local_path:, config:, dependencies: [], source_location: "", prefix: "/", related: [])
+        @local_path, @config, @source_location, @dependencies, @related = local_path, config, source_location, dependencies, related
+
+        @logical_path = self.class.update_path_for_emitted_type(
+          String.normalize_path(
+            File.join(prefix, local_path.sub(source_location, ""))
+          )
+        )
+
+        @public_path = String.normalize_path(
+          File.join(config.prefix, @logical_path)
+        )
+
+        @mime_type = case File.extname(@public_path)
+        when ".js"
+          # Resolves an issue with mini_mime returning `application/ecmascript`
+          #
+          "application/javascript"
+        else
+          MiniMime.lookup_by_filename(@public_path)&.content_type.to_s
+        end
+
+        @mime_prefix, @mime_suffix = @mime_type.split("/", 2)
+
+        @source_map_enabled = config.source_maps
+
+        @mutex = Mutex.new
+      end
+
+      # Overriding and freezing after content is set lets us eagerly process the
+      # content rather than incurring that cost on boot.
+      #
+      def freeze
+        super if instance_variable_defined?(:@content)
+      end
+
+      def each(&block)
+        ensure_content do |content|
+          StringIO.new(post_process(content)).each(&block)
+        end
+      end
+
+      def read
+        String.new.tap do |asset|
+          each do |content|
+            asset << content
+          end
+        end
+      end
+
+      def bytesize
+        ensure_content(&:bytesize)
+      end
+
+      def fingerprint
+        [@local_path].concat(dependencies).each_with_object(Digest::MD5.new) { |path, digest|
+          digest.update(Digest::MD5.file(path).hexdigest)
+        }.hexdigest
+      end
+
+      def fingerprinted_filename
+        extension = File.extname(@public_path)
+        File.basename(@public_path, extension) + "__" + fingerprint + extension
+      end
+
+      def public_path
+        if @config.fingerprint
+          File.join(
+            File.dirname(@public_path),
+            fingerprinted_filename
+          )
+        else
+          @public_path
+        end
+      end
+
+      def source_map?
+        respond_to?(:source_map_content)
+      end
+
+      def source_map
+        if source_map?
+          SourceMap.new(
+            source_map_content,
+            file: File.basename(public_path)
+          )
+        else
+          nil
+        end
+      end
+
+      def disable_source_map
+        tap do
+          @source_map_enabled = false
+        end
+      end
+
+      private
+
+      def ensure_content
+        @mutex.synchronize do
+          unless frozen? || instance_variable_defined?(:@content)
+            @content = load_content; freeze
+          end
+        end
+
+        yield @content if block_given?
+      end
+
+      def load_content
+        content = process(File.read(@local_path)).to_s
+
+        if mime_suffix == "css" || mime_suffix == "javascript"
+          # Update references to related assets with prefixed path, fingerprints.
+          # Do this here rather than in post-processing so that the source maps reflect the changes.
+          #
+          @related.each do |asset|
+            if asset != self && content.include?(asset.logical_path)
+              content.gsub!(asset.logical_path, asset.public_path)
+            end
+          end
+        end
+
+        content
+      end
+
+      def process(content)
+        content
+      end
+
+      def post_process(content)
+        if @source_map_enabled && source_map?
+          embed_mapping_url(content)
+        else
+          content
+        end
+      end
+
+      def embed_mapping_url(content)
+        content + SourceMap.mapping_url(path: public_path, type: @mime_suffix)
+      end
+
+      def external?
+        File.dirname(@local_path) == @config.externals.path
+      end
+    end
+  end
+end

data/lib/pakyow/assets/babel.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require "mini_racer"
+require "execjs"
+
+require "pakyow/support/inflector"
+
+module Pakyow
+  module Assets
+    class Babel
+      def self.transform(content, **options)
+        context.call("Babel.transform", content, camelize_keys(options))
+      end
+
+      private
+
+      def self.context
+        @context ||= ExecJS.compile(
+          File.read(
+            File.expand_path("../../../../src/@babel/standalone@7.4.5/babel.min.js", __FILE__)
+          )
+        )
+      end
+
+      def self.camelize_keys(options)
+        Hash[options.map { |key, value|
+          key = Support.inflector.camelize(key)
+          key = key[0, 1].downcase + key[1..-1]
+          [key, value]
+        }]
+      end
+    end
+  end
+end