jekyll-minibundle 1.5.1 → 1.6.0

data/lib/jekyll/minibundle/asset_file_registry.rb

@@ -1,44 +1,80 @@
-require 'jekyll/minibundle/environment'
-require 'jekyll/minibundle/development_file_collection'
 require 'jekyll/minibundle/bundle_file'
+require 'jekyll/minibundle/development_file'
+require 'jekyll/minibundle/development_file_collection'
+require 'jekyll/minibundle/environment'
 require 'jekyll/minibundle/stamp_file'
 
 module Jekyll::Minibundle
   module AssetFileRegistry
     class << self
       def clear
-        @_instances = {}
+        @_files = {}
       end
 
-      def bundle_file(site, bundle_config)
-        asset_destination_path = "#{bundle_config.fetch('destination_path')}.#{bundle_config.fetch('type')}"
-        @_instances[asset_destination_path] ||= register_bundle_file(site, bundle_config)
+      def register_bundle_file(site, bundle_config)
+        register_file_for_bundle_block(BundleFile, site, bundle_config) { |file| [file] }
       end
 
-      def stamp_file(site, asset_source_path, asset_destination_path)
-        @_instances[asset_destination_path] ||= register_stamp_file(site, asset_source_path, asset_destination_path)
+      def register_development_file_collection(site, bundle_config)
+        register_file_for_bundle_block(DevelopmentFileCollection, site, bundle_config, &:files)
+      end
+
+      def register_stamp_file(site, asset_source_path, asset_destination_path)
+        register_file_for_stamp_tag(StampFile, site, asset_source_path, asset_destination_path)
+      end
+
+      def register_development_file(site, asset_source_path, asset_destination_path)
+        register_file_for_stamp_tag(DevelopmentFile, site, asset_source_path, asset_destination_path)
       end
 
       private
 
-      def register_bundle_file(site, bundle_config)
-        if Environment.development?(site)
-          DevelopmentFileCollection.new(site, bundle_config)
-        else
-          BundleFile.new(site, bundle_config)
+      def register_file_for_bundle_block(file_class, site, bundle_config, &get_files)
+        asset_destination_path = "#{bundle_config.fetch('destination_path')}.#{bundle_config.fetch('type')}"
+
+        cached = @_files[asset_destination_path]
+
+        if cached
+          raise "minibundle block has same destination path as a ministamp tag: #{asset_destination_path}" if cached.fetch(:type) != :bundle
+
+          cached_file = cached.fetch(:file)
+
+          if bundle_config == cached.fetch(:config)
+            get_files.call(cached_file).each do |file|
+              site.static_files << file unless site.static_files.include?(file)
+            end
+            return cached_file
+          else
+            get_files.call(cached_file).each { |file| site.static_files.delete(file) }
+          end
         end
-      end
 
-      def register_stamp_file(site, asset_source_path, asset_destination_path)
-        StampFile.new(site, asset_source_path, asset_destination_path, &get_stamp_file_basenamer(site))
+        new_file = file_class.new(site, bundle_config)
+        @_files[asset_destination_path] = {type: :bundle, file: new_file, config: bundle_config}
+        get_files.call(new_file).each { |file| site.static_files << file }
+        new_file
       end
 
-      def get_stamp_file_basenamer(site)
-        if Environment.development?(site)
-          ->(base, ext, _) { base + ext }
-        else
-          ->(base, ext, stamper) { "#{base}-#{stamper.call}#{ext}" }
+      def register_file_for_stamp_tag(file_class, site, asset_source_path, asset_destination_path)
+        cached = @_files[asset_destination_path]
+
+        if cached
+          raise "ministamp tag has same destination path as a minibundle block: #{asset_destination_path}" if cached.fetch(:type) != :stamp
+
+          cached_file = cached.fetch(:file)
+
+          if asset_source_path == cached.fetch(:config)
+            site.static_files << cached_file unless site.static_files.include?(cached_file)
+            return cached_file
+          else
+            site.static_files.delete(cached_file)
+          end
         end
+
+        new_file = file_class.new(site, asset_source_path, asset_destination_path)
+        @_files[asset_destination_path] = {type: :stamp, file: new_file, config: asset_source_path}
+        site.static_files << new_file
+        new_file
       end
     end
 

data/lib/jekyll/minibundle/asset_tag_markup.rb

@@ -3,14 +3,15 @@ require 'cgi'
 module Jekyll::Minibundle
   module AssetTagMarkup
     class << self
-      def make_markup(type, path, attributes)
+      def make_markup(type, baseurl, path, attributes)
+        url = make_url(baseurl, path)
         case type
         when :js
-          %{<script type="text/javascript" src="#{path}"#{make_attributes(attributes)}></script>}
+          %{<script type="text/javascript" src="#{url}"#{make_attributes(attributes)}></script>}
         when :css
-          %{<link rel="stylesheet" href="#{path}"#{make_attributes(attributes)}>}
+          %{<link rel="stylesheet" href="#{url}"#{make_attributes(attributes)}>}
         else
-          fail ArgumentError, "Unknown type for generating bundle markup: #{type}, #{path}"
+          raise ArgumentError, "Unknown type for generating bundle markup: #{type}, #{path}"
         end
       end
 
@@ -21,6 +22,14 @@ module Jekyll::Minibundle
       def make_attribute(name, value)
         %{ #{name}="#{CGI.escape_html(value)}"}
       end
+
+      def make_url(baseurl, path)
+        if baseurl.empty?
+          path
+        else
+          File.join(baseurl, path)
+        end
+      end
     end
   end
 end

data/lib/jekyll/minibundle/bundle_file.rb

@@ -2,7 +2,6 @@ require 'jekyll/minibundle/asset_bundle'
 require 'jekyll/minibundle/asset_file_operations'
 require 'jekyll/minibundle/asset_file_properties'
 require 'jekyll/minibundle/asset_stamp'
-require 'jekyll/minibundle/asset_tag_markup'
 
 module Jekyll::Minibundle
   class BundleFile
@@ -17,7 +16,6 @@ module Jekyll::Minibundle
       asset_source_dir = File.join(@site.source, config.fetch('source_dir'))
       @asset_paths = config.fetch('assets').map { |asset_path| File.join(asset_source_dir, "#{asset_path}.#{@type}") }
       @destination_path = config.fetch('destination_path')
-      @attributes = config.fetch('attributes')
       @minifier_cmd = config.fetch('minifier_cmd')
       @stamped_at = nil
       @is_modified = false
@@ -25,7 +23,8 @@ module Jekyll::Minibundle
 
     def destination_path_for_markup
       # we must rebundle here, if at all, in order to make sure the
-      # markup and generated file have the same fingerprint
+      # markup destination and generated file paths have the same
+      # fingerprint
       if modified?
         @stamped_at = mtime
         @is_modified = true
@@ -33,7 +32,7 @@ module Jekyll::Minibundle
         asset_bundle.make_bundle
       end
 
-      AssetTagMarkup.make_markup(@type, asset_destination_path, @attributes)
+      asset_destination_path
     end
 
     def path
@@ -48,8 +47,12 @@ module Jekyll::Minibundle
       "#{@destination_path}-#{asset_stamp}.#{@type}"
     end
 
-    def mtime
-      @asset_paths.map { |f| File.stat(f).mtime.to_i }.max
+    def extname
+      ".#{@type}"
+    end
+
+    def modified_time
+      @asset_paths.map { |f| File.stat(f).mtime }.max
     end
 
     # writes destination only after `destination_path_for_markup` has

data/lib/jekyll/minibundle/compatibility.rb

@@ -1,5 +1,7 @@
 module Jekyll::Minibundle
   module Compatibility
+    LOG_TOPIC = 'Minibundle:'.freeze
+
     class << self
       # SafeYAML.load is introduced in Jekyll 2.0.0
       if defined?(::SafeYAML) && ::SafeYAML.respond_to?(:load)
@@ -14,10 +16,18 @@ module Jekyll::Minibundle
 
       # Jekyll.logger is introduced in Jekyll 1.0.3
       if ::Jekyll.respond_to?(:logger)
+        def log_error(msg)
+          ::Jekyll.logger.error(LOG_TOPIC, msg)
+        end
+
         def log_info(msg)
-          ::Jekyll.logger.info('Minibundle:', msg)
+          ::Jekyll.logger.info(LOG_TOPIC, msg)
         end
       else
+        def log_error(msg)
+          $stderr.puts(msg)
+        end
+
         def log_info(msg)
           $stdout.puts(msg)
         end

data/lib/jekyll/minibundle/development_file.rb

@@ -16,6 +16,12 @@ module Jekyll::Minibundle
       @stamped_at = nil
     end
 
+    alias destination_path_for_markup asset_destination_path
+
+    def extname
+      File.extname(asset_destination_path)
+    end
+
     def write(site_destination_dir)
       if modified?
         @stamped_at = mtime

data/lib/jekyll/minibundle/development_file_collection.rb

@@ -1,10 +1,12 @@
-require 'jekyll/minibundle/asset_tag_markup'
 require 'jekyll/minibundle/development_file'
 
 module Jekyll::Minibundle
   class DevelopmentFileCollection
+    attr_reader :files
+
     def initialize(site, config)
       @type = config.fetch('type')
+
       asset_source_dir = File.join(site.source, config.fetch('source_dir'))
       destination_path = config.fetch('destination_path')
 
@@ -14,21 +16,6 @@ module Jekyll::Minibundle
         asset_destination = File.join(destination_path, asset_basename)
         DevelopmentFile.new(site, asset_source, asset_destination)
       end
-
-      @attributes = config.fetch('attributes')
-    end
-
-    def add_as_static_file_to(site)
-      # NOTE: We could optimize here by iterating over site's static
-      # files only once instead of per each of our file. Seems like a
-      # premature optimization for now, however.
-      @files.each { |f| f.add_as_static_file_to(site) }
-    end
-
-    def destination_path_for_markup
-      @files.
-        map { |f| AssetTagMarkup.make_markup(@type, f.asset_destination_path, @attributes) }.
-        join("\n")
     end
   end
 end

data/lib/jekyll/minibundle/environment.rb

@@ -1,3 +1,5 @@
+require 'jekyll/minibundle/hashes'
+
 module Jekyll::Minibundle
   module Environment
     class << self
@@ -7,23 +9,14 @@ module Jekyll::Minibundle
       end
 
       def development?(site)
-        mode = ENV['JEKYLL_MINIBUNDLE_MODE'] || Environment.find_site_config(site, ['minibundle', 'mode'], String)
+        mode = ENV['JEKYLL_MINIBUNDLE_MODE'] || Environment.find_site_config(site, %w{minibundle mode}, String)
         mode == 'development'
       end
 
       def find_site_config(site, keys, type)
-        value = traverse_keys(site.config, keys)
+        value = Hashes.dig(site.config, *keys)
         if value && !value.is_a?(type)
-          fail "Invalid site configuration for key #{keys.join('.')}; expecting type #{type}"
-        end
-        value
-      end
-
-      def traverse_keys(obj, keys)
-        value = obj
-        keys.each do |key|
-          return nil unless value
-          value = value[key]
+          raise "Invalid site configuration for key #{keys.join('.')}; expecting type #{type}"
         end
         value
       end

data/lib/jekyll/minibundle/files.rb

@@ -0,0 +1,18 @@
+module Jekyll::Minibundle
+  module Files
+    def self.read_last(path, max_size)
+      File.open(path, 'rb') do |file|
+        return '' if max_size < 1
+
+        file_size = file.stat.size
+
+        if file_size < max_size
+          file.read(file_size)
+        else
+          file.seek(file_size - max_size, ::IO::SEEK_SET)
+          file.read(max_size)
+        end
+      end
+    end
+  end
+end

data/lib/jekyll/minibundle/hashes.rb

@@ -0,0 +1,20 @@
+module Jekyll::Minibundle
+  module Hashes
+    class << self
+      def dig(obj, *keys)
+        value = obj
+        keys.each do |key|
+          return nil unless value
+          value = value[key]
+        end
+        value
+      end
+
+      def pick(hash, *keys)
+        keys.each_with_object({}) do |key, acc|
+          acc[key] = hash.fetch(key)
+        end
+      end
+    end
+  end
+end

data/lib/jekyll/minibundle/mini_bundle_block.rb

@@ -1,29 +1,33 @@
-require 'jekyll/minibundle/asset_file_registry'
+require 'jekyll/minibundle/hashes'
 require 'jekyll/minibundle/compatibility'
 require 'jekyll/minibundle/environment'
+require 'jekyll/minibundle/asset_file_registry'
+require 'jekyll/minibundle/asset_tag_markup'
 
 module Jekyll::Minibundle
   class MiniBundleBlock < Liquid::Block
     def initialize(tag_name, type, _tokens)
       super
       @type = type.strip.downcase.to_sym
-      if @type.empty?
-        fail ArgumentError, "No asset type for minibundle block; pass value such as 'css' or 'js' as the argument"
-      end
+      raise ArgumentError, "No asset type for minibundle block; pass value such as 'css' or 'js' as the argument" if @type.empty?
     end
 
     def render(context)
       site = context.registers.fetch(:site)
       bundle_config = get_current_bundle_config(Compatibility.load_yaml(super), site)
-      file = AssetFileRegistry.bundle_file(site, bundle_config)
-      file.add_as_static_file_to(site)
-      file.destination_path_for_markup
+      baseurl = bundle_config.fetch('baseurl')
+      attributes = bundle_config.fetch('attributes')
+
+      register_asset_files(site, bundle_config).map do |file|
+        AssetTagMarkup.make_markup(@type, baseurl, file.destination_path_for_markup, attributes)
+      end.join("\n")
     end
 
     def self.default_bundle_config
       {
         'source_dir'       => '_assets',
         'destination_path' => 'assets/site',
+        'baseurl'          => '',
         'assets'           => [],
         'attributes'       => {}
       }
@@ -32,14 +36,50 @@ module Jekyll::Minibundle
     private
 
     def get_current_bundle_config(local_bundle_config, site)
-      MiniBundleBlock.default_bundle_config.
-        merge(environment_bundle_config(site)).
-        merge(local_bundle_config).
-        merge('type' => @type)
+      config =
+        MiniBundleBlock
+        .default_bundle_config
+        .merge(environment_bundle_config(site))
+        .merge(local_bundle_config)
+        .merge('type' => @type)
+
+      baseurl, destination_path = normalize_baseurl_and_destination_path(config.fetch('baseurl'), config.fetch('destination_path'))
+
+      config.merge('baseurl' => baseurl, 'destination_path' => destination_path)
     end
 
     def environment_bundle_config(site)
-      { 'minifier_cmd' => Environment.minifier_command(site, @type) }
+      {'minifier_cmd' => Environment.minifier_command(site, @type)}
+    end
+
+    def normalize_baseurl_and_destination_path(baseurl, destination_path)
+      baseurl = '' if baseurl.nil?
+
+      unless destination_path.start_with?('/')
+        return [baseurl, destination_path]
+      end
+
+      normalized_baseurl = baseurl.empty? ? '/' : baseurl
+      normalized_destination_path = destination_path.sub(%r{\A/+}, '')
+
+      [normalized_baseurl, normalized_destination_path]
+    end
+
+    def register_asset_files(site, bundle_config)
+      registry_config = Hashes.pick(
+        bundle_config,
+        'type',
+        'source_dir',
+        'destination_path',
+        'assets',
+        'minifier_cmd'
+      )
+
+      if Environment.development?(site)
+        AssetFileRegistry.register_development_file_collection(site, registry_config).files
+      else
+        [AssetFileRegistry.register_bundle_file(site, registry_config)]
+      end
     end
   end
 end

data/lib/jekyll/minibundle/mini_stamp_tag.rb

@@ -4,20 +4,39 @@ module Jekyll::Minibundle
   class MiniStampTag < Liquid::Tag
     def initialize(tag_name, text, _tokens)
       super
-      @asset_source, @asset_destination = text.split(/\s+/, 3)[0, 2]
-      if !@asset_source || @asset_source.empty?
-        fail ArgumentError, "No asset source for ministamp tag; pass value such as '/_assets/site.css' as the first argument"
+
+      @source_path, destination_path = text.split(/\s+/, 3)[0, 2]
+
+      if !@source_path || @source_path.empty?
+        raise ArgumentError, "No asset source for ministamp tag; pass value such as '_assets/site.css' as the first argument"
       end
-      if !@asset_destination || @asset_destination.empty?
-        fail ArgumentError, "No asset destination for ministamp tag; pass value such as '/assets/site.css' as the second argument"
+
+      if !destination_path || destination_path.empty?
+        raise ArgumentError, "No asset destination for ministamp tag; pass value such as 'assets/site.css' as the second argument"
       end
+
+      @baseurl, @destination_path = normalize_destination_path(destination_path)
     end
 
     def render(context)
       site = context.registers.fetch(:site)
-      file = AssetFileRegistry.stamp_file(site, @asset_source, @asset_destination)
-      file.add_as_static_file_to(site)
-      file.destination_path_for_markup
+      file =
+        if Environment.development?(site)
+          AssetFileRegistry.register_development_file(site, @source_path, @destination_path)
+        else
+          AssetFileRegistry.register_stamp_file(site, @source_path, @destination_path)
+        end
+      @baseurl + file.destination_path_for_markup
+    end
+
+    private
+
+    def normalize_destination_path(destination_path)
+      if destination_path.start_with?('/')
+        ['/', destination_path.sub(%r{\A/+}, '')]
+      else
+        ['', destination_path]
+      end
     end
   end
 end