jekyll_picture_tag 1.8.0 → 1.11.0

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?
@@ -38,28 +38,64 @@ module PictureTag
       end
 
       def continue_on_missing?
-        setting = pconfig['ignore_missing_images']
-
-        # Config setting can be a string, an array, or a boolean
-        if setting.is_a? Array
-          setting.include? jekyll_env
-        elsif setting.is_a? String
-          setting == jekyll_env
-        else
-          setting
-        end
+        env_check pconfig['ignore_missing_images']
+      rescue ArgumentError
+        raise ArgumentError,
+              <<~HEREDOC
+                continue_on_missing setting invalid. Must be either a boolean
+                (true/false), an environment name, or an array of environment
+                names.
+              HEREDOC
       end
 
       def cdn?
         pconfig['cdn_url'] && pconfig['cdn_environments'].include?(jekyll_env)
       end
 
+      def disabled?
+        env_check pconfig['disabled']
+      rescue ArgumentError
+        raise ArgumentError,
+              <<~HEREDOC
+                "disabled" setting invalid. Must be either a boolean
+                (true/false), an environment name, or an array of environment
+                names.
+              HEREDOC
+      end
+
+      def fast_build?
+        env_check pconfig['fast_build']
+      rescue ArgumentError
+        raise ArgumentError,
+              <<~HEREDOC
+                "fast_build" setting invalid. Must be either a boolean
+                (true/false), an environment name, or an array of environment
+                names.
+              HEREDOC
+      end
+
       private
 
       def content
         @content ||= setting_merge(defaults, PictureTag.site.config)
       end
 
+      # There are a few config settings which can either be booleans,
+      # environment names, or arrays of environment names. This method works it
+      # out and returns a boolean.
+      def env_check(setting)
+        if setting.is_a? Array
+          setting.include? jekyll_env
+        elsif setting.is_a? String
+          setting == jekyll_env
+        elsif [true, false].include? setting
+          setting
+        else
+          raise ArgumentError,
+                "#{setting} must either be a string, an array, or a boolean."
+        end
+      end
+
       def setting_merge(default, jekyll)
         jekyll.merge default do |_key, config_setting, default_setting|
           if default_setting.respond_to? :merge

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
 
-        qualities[format]
+      # Gravity setting (for imagemagick cropping)
+      def gravity(media = nil)
+        setting_lookup('gravity', 'media', media)
+      end
+
+      # 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
@@ -70,10 +87,14 @@ module PictureTag
       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

@@ -34,6 +34,24 @@ module PictureTag
         @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 build_source_images
         source_names = params.source_names
         media_presets = params.media_presets
@@ -48,14 +66,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