jekyll_picture_tag 1.9.0 → 1.12.0

data/lib/jekyll_picture_tag/cache/generated.rb

@@ -0,0 +1,20 @@
+module PictureTag
+  module Cache
+    # Caches generated image details, so we can skip expensive operations whenever
+    # possible.
+    # Stored width and height are values for the source image, after cropping.
+    class Generated
+      include Base
+
+      private
+
+      def cache_dir
+        'generated'
+      end
+
+      def template
+        { width: nil, height: nil }
+      end
+    end
+  end
+end

data/lib/jekyll_picture_tag/cache/source.rb

@@ -0,0 +1,19 @@
+module PictureTag
+  module Cache
+    # Caches source image details, so we can skip expensive operations whenever
+    # possible.
+    class Source
+      include Base
+
+      private
+
+      def template
+        { digest: nil, width: nil, height: nil }
+      end
+
+      def cache_dir
+        'source'
+      end
+    end
+  end
+end

data/lib/jekyll_picture_tag/defaults/presets.yml

@@ -7,3 +7,5 @@ noscript: false
 link_source: false
 quality: 75
 data_sizes: true
+gravity: center
+dimension_attributes: false

data/lib/jekyll_picture_tag/generated_image.rb

@@ -4,12 +4,15 @@ module PictureTag
   # Represents a generated image file.
   class GeneratedImage
     attr_reader :width, :format
+
     include MiniMagick
 
-    def initialize(source_file:, width:, format:)
+    def initialize(source_file:, width:, format:, crop: nil, gravity: '')
       @source = source_file
       @width  = width
       @format = process_format format
+      @crop = crop
+      @gravity = gravity
     end
 
     def exists?
@@ -29,7 +32,7 @@ module PictureTag
     # /home/dave/my_blog/_site/generated/somefolder/myimage-100-123abc.jpg
     #                                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
     def name
-      name_left + digest + name_right
+      @name ||= "#{@source.base_name}-#{@width}-#{id}.#{@format}"
     end
 
     # https://example.com/assets/images/myimage-100-123abc.jpg
@@ -38,54 +41,64 @@ module PictureTag
       ImgURI.new(name).to_s
     end
 
-    private
+    # Post crop
+    def source_width
+      update_cache unless cache[:width]
 
-    # /home/dave/my_blog/_site/generated/somefolder/myimage-100-123abc.jpg
-    #                                    ^^^^^^^^^^^^^^^^^^^^^^^
-    def name_left
-      "#{@source.base_name}-#{@width}-"
+      cache[:width]
     end
 
-    # /home/dave/my_blog/_site/generated/somefolder/myimage-100-123abc.jpg
-    #                                                           ^^^^^^
-    def digest
-      guess_digest if !@source.digest_guess && PictureTag.fast_build?
+    # Post crop
+    def source_height
+      update_cache unless cache[:height]
 
-      @source.digest
+      cache[:height]
     end
 
-    # /home/dave/my_blog/_site/generated/somefolder/myimage-100-123abc.jpg
-    #                                                                 ^^^^
-    def name_right
-      '.' + @format
+    private
+
+    # We exclude width and format from the cache name, since it isn't specific to them.
+    def cache
+      @cache ||= Cache::Generated.new("#{@source.base_name}-#{id}")
     end
 
-    # Used for the fast build option: look for a file which matches everything
-    # we know about the destination file without calculating a digest on the
-    # source file, and if it exists we assume it's the right one.
-    def guess_digest
-      matches = dest_glob
-      return unless matches.length == 1
+    def update_cache
+      return if @source.missing
 
-      # Start and finish of the destination image's hash value
-      finish = -name_right.length
-      start = finish - 6
+      # Ensure it's generated:
+      image
 
-      # The source image keeps track of this guess, so we hand it off:
-      @source.digest_guess = matches.first[start...finish]
+      cache[:width] = @source_dimensions[:width]
+      cache[:height] = @source_dimensions[:height]
+
+      cache.write
     end
 
-    # Returns a list of images which are probably correct.
-    def dest_glob
-      Dir.glob File.join(PictureTag.dest_dir, name_left + '?' * 6 + name_right)
+    # Hash all inputs and truncate, so we know when they change without getting too long.
+    # /home/dave/my_blog/_site/generated/somefolder/myimage-100-1234abcde.jpg
+    #                                                           ^^^^^^^^^
+    def id
+      @id ||= Digest::MD5.hexdigest([@source.digest, @crop, @gravity, quality].join)[0..8]
     end
 
+    # Post crop, before resizing and reformatting
     def image
-      @image ||= Image.open(@source.name)
+      @image ||= open_image
     end
 
-    def dest_dir
-      File.dirname absolute_filename
+    def open_image
+      image_base = Image.open(@source.name)
+      image_base.combine_options do |i|
+        i.auto_orient
+        if @crop
+          i.gravity @gravity
+          i.crop @crop
+        end
+      end
+
+      @source_dimensions = { width: image_base.width, height: image_base.height }
+
+      image_base
     end
 
     def generate_image
@@ -94,30 +107,28 @@ module PictureTag
       write_image
     end
 
+    def quality
+      PictureTag.quality(@format)
+    end
+
     def process_image
       image.combine_options do |i|
         i.resize "#{@width}x"
-        i.auto_orient
         i.strip
       end
 
       image.format @format
-      image.quality PictureTag.quality(@format)
+      image.quality quality
     end
 
     def write_image
-      check_dest_dir
+      FileUtils.mkdir_p(File.dirname(absolute_filename))
 
       image.write absolute_filename
 
       FileUtils.chmod(0o644, absolute_filename)
     end
 
-    # Make sure destination directory exists
-    def check_dest_dir
-      FileUtils.mkdir_p(dest_dir) unless Dir.exist?(dest_dir)
-    end
-
     def process_format(format)
       if format.casecmp('original').zero?
         @source.ext

data/lib/jekyll_picture_tag/img_uri.rb

@@ -8,6 +8,7 @@ module PictureTag
   # image. Call to_s on it to get the link.
   class ImgURI
     attr_reader :filename, :source_image
+
     def initialize(filename, source_image: false)
       @source_image = source_image
       @filename = filename

data/lib/jekyll_picture_tag/instructions.rb

@@ -3,3 +3,4 @@ require_relative './instructions/configuration'
 require_relative './instructions/html_attributes'
 require_relative './instructions/preset'
 require_relative './instructions/tag_parser'
+require_relative './instructions/arg_splitter'

data/lib/jekyll_picture_tag/instructions/arg_splitter.rb

@@ -0,0 +1,69 @@
+module PictureTag
+  module Instructions
+    # This class takes in the arguments passed to the liquid tag, and splits it
+    # up into 'words' (correctly handling quotes and backslash escapes.)
+    #
+    # To handle quotes and backslash escaping, we have to parse the string by
+    # characters to break it up correctly. I'm sure there's a library to do
+    # this, but it's not that much code honestly. If this starts getting big,
+    # we'll pull in a new dependency.
+    #
+    class ArgSplitter
+      attr_reader :words
+
+      def initialize(raw_params)
+        @words = []
+        @word = ''
+        @in_quotes = false
+        @escaped = false
+
+        raw_params.each_char { |c| handle_char(c) }
+
+        add_word # We have to explicitly add the last one.
+      end
+
+      private
+
+      def handle_char(char)
+        # last character was a backslash:
+        if @escaped
+          close_escape char
+
+        # char is a backslash or a quote:
+        elsif char.match?(/["\\]/)
+          handle_special char
+
+        # Character isn't whitespace, or it's inside double quotes:
+        elsif @in_quotes || char.match(/\S/)
+          @word << char
+
+        # Character is whitespace outside of double quotes:
+        else
+          add_word
+        end
+      end
+
+      def add_word
+        return if @word.empty?
+
+        @words << @word
+        @word = ''
+      end
+
+      def handle_special(char)
+        case char
+        when '\\'
+          @escaped = true
+        when '"'
+          @in_quotes = !@in_quotes
+          @word << char
+        end
+      end
+
+      def close_escape(char)
+        @word << char
+        @escaped = false
+      end
+    end
+  end
+end

data/lib/jekyll_picture_tag/instructions/configuration.rb

@@ -30,7 +30,7 @@ module PictureTag
       # source_dest is the jekyll-picture-tag destination directory. (generated
       # file location setting.)
       def dest_dir
-        File.join PictureTag.site.dest, pconfig['output']
+        File.join PictureTag.site.config['destination'], pconfig['output']
       end
 
       def nomarkdown?

data/lib/jekyll_picture_tag/instructions/preset.rb

@@ -3,6 +3,7 @@ module PictureTag
     # Handles the specific tag image set to construct.
     class Preset
       attr_reader :name
+
       def initialize(name)
         @name = name
         @content = build_preset
@@ -12,13 +13,6 @@ module PictureTag
         @content[key]
       end
 
-      # Returns the set of widths to use for a given media query.
-      def widths(media)
-        width_hash = self['media_widths'] || {}
-        width_hash.default = self['widths']
-        width_hash[media]
-      end
-
       def formats
         @content['formats']
       end
@@ -41,15 +35,38 @@ module PictureTag
         end
       end
 
+      # Image widths to generate for a given media query.
+      def widths(media = nil)
+        setting_lookup('widths', 'media', media)
+      end
+
+      # Image quality setting, possibly dependent on format.
       def quality(format = nil)
-        qualities = @content['format_quality'] || {}
-        qualities.default = @content['quality']
+        setting_lookup('quality', 'format', format)
+      end
+
+      # Gravity setting (for imagemagick cropping)
+      def gravity(media = nil)
+        setting_lookup('gravity', 'media', media)
+      end
 
-        qualities[format]
+      # Crop value
+      def crop(media = nil)
+        setting_lookup('crop', 'media', media)
       end
 
       private
 
+      # Return arbitrary setting values, taking their defaults into account.
+      # Ex: quality can be set for all image formats, or individually per
+      # format. Per-format settings should override the general setting.
+      def setting_lookup(setting, prefix, lookup)
+        media_values = @content[prefix + '_' + setting] || {}
+        media_values.default = @content[setting]
+
+        media_values[lookup]
+      end
+
       def build_preset
         # The _data/picture.yml file is optional.
         picture_data_file = grab_data_file
@@ -64,16 +81,24 @@ module PictureTag
       end
 
       def grab_data_file
+        search_data('presets') || search_data('markup_presets') || no_preset
+      end
+
+      def search_data(key)
         PictureTag.site
                   .data
-                  .dig('picture', 'markup_presets', @name) || no_preset
+                  .dig('picture', key, @name)
       end
 
       def no_preset
-        Utils.warning(
-          " Preset \"#{@name}\" not found in #{PictureTag.config['data_dir']}/"\
-          + 'picture.yml under markup_presets key. Using default values.'
-        )
+        unless @name == 'default'
+          Utils.warning(
+            <<~HEREDOC
+              Preset "#{@name}" not found in {PictureTag.config['data_dir']}/picture.yml
+              under markup_presets key. Using default values."
+            HEREDOC
+          )
+        end
 
         {}
       end

data/lib/jekyll_picture_tag/instructions/set.rb

@@ -27,13 +27,35 @@ module PictureTag
       # These are our Media Query presets. It's really just a hash, and there
       # are no default values, so extracting this to its own class is overkill.
       def media_presets
-        PictureTag.site.data.dig('picture', 'media_presets') || {}
+        search_data('media_queries') || search_data('media_presets') || {}
       end
 
       def source_images
         @source_images ||= build_source_images
       end
 
+      def crop(media = nil)
+        params.geometries[media] || preset.crop(media)
+      end
+
+      def gravity(media = nil)
+        params.gravities[media] || preset.gravity(media)
+      end
+
+      # Returns a class constant for the selected output format, which is used
+      # to dynamically instantiate it.
+      def output_class
+        Object.const_get(
+          'PictureTag::OutputFormats::' + Utils.titleize(preset['markup'])
+        )
+      end
+
+      private
+
+      def search_data(key)
+        PictureTag.site.data.dig('picture', key)
+      end
+
       def build_source_images
         source_names = params.source_names
         media_presets = params.media_presets
@@ -48,14 +70,6 @@ module PictureTag
 
         sources
       end
-
-      # Returns a class constant for the selected output format, which is used
-      # to dynamically instantiate it.
-      def output_class
-        Object.const_get(
-          'PictureTag::OutputFormats::' + Utils.titleize(preset['markup'])
-        )
-      end
     end
   end
 end

data/lib/jekyll_picture_tag/instructions/tag_parser.rb

@@ -1,105 +1,95 @@
 module PictureTag
   module Instructions
-    # This tag takes the arguments handed to the liquid tag, and extracts the
-    # preset name (if present), source image name(s), and associated media
-    # queries (if present). The leftovers (html attributes) are handed off to
-    # its respective class.
+    # Tag Parsing Responsibilities:
+    #
+    #  {% picture mypreset a.jpg 3:2 mobile: b.jpg --alt "Alt" --link "/" %}
+    # |  Jekyll  |           TagParser            |    HTMLAttributes    |
+    #
+    # This class takes the arguments handed to the liquid tag (given as a simple
+    # string), hands them to ArgSplitter (which breaks them up into an array of
+    # words), extracts the preset name (if present), source image name(s),
+    # associated media queries (if present), and image-related arguments such as
+    # crop and gravity. HTML attributes are handed off to its respective class
+    # (as 'leftovers')
+    #
+    # Media presets and source names are stored as arrays in their correct
+    # orders. Gravities and geometries are stored in a hash, keyed by their
+    # relevant media presets. Note that the base image will have a media preset
+    # of nil, which is a perfectly fine hash key.
+    #
     class TagParser
-      attr_reader :preset_name, :source_names, :media_presets
-      def initialize(raw_params)
-        build_params PictureTag::Utils.liquid_lookup(raw_params)
+      attr_reader :preset_name, :source_names, :media_presets, :gravities,
+                  :geometries, :leftovers
 
-        @preset_name = grab_preset_name
+      def initialize(raw_params)
+        @raw_params = raw_params
+        @params = split_params
 
-        # The first param specified will be our base image, so it has no
-        # associated media query.
         @media_presets = []
-        @source_names = [] << strip_quotes(@params.shift)
+        @source_names = []
+        @geometries = {}
+        @gravities = {}
 
-        # Detect and store arguments of the format 'media_query: img.jpg' as
-        # keys and values.
-        add_media_source while @params.first =~ /[\w\-]+:$/
-      end
-
-      def leftovers
-        @params
+        parse_params
       end
 
       private
 
-      def add_media_source
-        @media_presets << @params.shift.delete_suffix(':')
-        @source_names << strip_quotes(@params.shift)
+      def split_params
+        ArgSplitter
+          .new(Utils.liquid_lookup(@raw_params))
+          .words
       end
 
-      # First param is the preset name, unless it's a filename.
-      def grab_preset_name
-        if @params.first.include? '.'
-          'default'
-        else
-          @params.shift
-        end
-      end
-
-      # Originally separating arguments was just handled by splitting the raw
-      # params on spaces. To handle quotes and backslash escaping, we have to
-      # parse the string by characters to break it up correctly. I'm sure
-      # there's a library to do this, but it's not that much code honestly. If
-      # this starts getting big, we'll pull in a new dependency.
-      def build_params(raw_params)
-        @params = []
-        @word = ''
-        @in_quotes = false
-        @escaped = false
+      def parse_params
+        @preset_name = determine_preset_name
+        @source_names << strip_quotes(@params.shift)
 
-        raw_params.each_char { |c| handle_char(c) }
+        parse_param(@params.first) until stop_here? @params.first
 
-        add_word # We have to explicitly add the last one.
+        @leftovers = @params
       end
 
-      def handle_char(char)
-        # last character was a backslash:
-        if @escaped
-          close_escape char
+      def parse_param(param)
+        if param.match?(/[\w\-]+:$/)
+          add_media_source
 
-        # char is a backslash or a quote:
-        elsif char.match(/["\\]/)
-          handle_special char
+        elsif Utils::GRAVITIES.include?(param.downcase)
+          @gravities[@media_presets.last] = @params.shift
 
-        # Character isn't whitespace, or it's inside double quotes:
-        elsif @in_quotes || char.match(/\S/)
-          @word << char
+        elsif param.match?(Utils::GEOMETRY_REGEX)
+          @geometries[@media_presets.last] = @params.shift
 
-        # Character is whitespace outside of double quotes:
         else
-          add_word
+          raise_error(param)
         end
       end
 
-      def handle_special(char)
-        if char == '\\'
-          @escaped = true
-        elsif char == '"'
-          @in_quotes = !@in_quotes
-          @word << char
-        end
+      # HTML attributes are handled by its own class; once we encounter them
+      # we are finished here.
+      def stop_here?(param)
+        # No param    Explicit HTML attribute   Implicit HTML attribute
+        param.nil? || param.match?(/^--\S*/) || param.match?(/^\w*="/)
       end
 
-      def add_word
-        return if @word.empty?
-
-        @params << @word
-        @word = ''
+      def add_media_source
+        @media_presets << @params.shift.delete_suffix(':')
+        @source_names << strip_quotes(@params.shift)
       end
 
-      def close_escape(char)
-        @word << char
-        @escaped = false
+      # The first param is the preset name, unless it's a filename.
+      def determine_preset_name
+        @params.first.include?('.') ? 'default' : @params.shift
       end
 
       def strip_quotes(name)
         name.delete_prefix('"').delete_suffix('"')
       end
+
+      def raise_error(param)
+        raise ArgumentError, "Could not parse '#{param}' in the following "\
+          "tag: \n  {% picture #{@raw_params} %}"
+      end
     end
   end
 end