jekyll_picture_tag 1.6.0 → 1.7.0

data/lib/jekyll_picture_tag/instructions/tag_parser.rb

@@ -1,47 +1,104 @@
 module PictureTag
   module Instructions
-    # This class takes the string given to the jekyll tag, and extracts useful
-    # information from it.
+    # 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.
     class TagParser
-      attr_reader :preset_name, :source_images, :html_attributes_raw
+      attr_reader :preset_name, :source_names, :media_presets
       def initialize(raw_params)
-        @params = PictureTag::Utils.liquid_lookup(raw_params).split
+        build_params PictureTag::Utils.liquid_lookup(raw_params)
 
         @preset_name = grab_preset_name
 
-        # source_image keys are media queries, values are source images. The
-        # first param specified will be our base image, so it has no associated
-        # media query. Yes, nil can be a hash key.
-        source_image_names = { nil => @params.shift }
+        # The first param specified will be our base image, so it has no
+        # associated media query.
+        @media_presets = []
+        @source_names = [] << strip_quotes(@params.shift)
 
-        # Store source keys which fit a pattern in a hash.
-        while @params.first =~ /[\w\-]+:/
-          media_query = @params.shift[0..-2]
-          source_image_names[media_query] = @params.shift
-        end
-
-        @source_images = build_sources(source_image_names)
+        # Detect and store arguments of the format 'media_query: img.jpg' as
+        # keys and values.
+        add_media_source while @params.first =~ /[\w\-]+:$/
+      end
 
-        # Anything left will be html attributes
-        @html_attributes_raw = @params.join(' ')
+      def leftovers
+        @params
       end
 
       private
 
+      def add_media_source
+        @media_presets << @params.shift.delete_suffix(':')
+        @source_names << strip_quotes(@params.shift)
+      end
+
       # First param is the preset name, unless it's a filename.
       def grab_preset_name
-        if @params.first =~ %r{[\w./]+\.\w+}
+        if @params.first.include? '.'
           'default'
         else
           @params.shift
         end
       end
 
-      # Takes filenames relative to JPT source directory. SourceImage instances
-      # persist within a tag, allowing us to only perform some expensive File
-      # operations once.
-      def build_sources(names)
-        names.transform_values { |n| PictureTag::SourceImage.new n }
+      # 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
+
+        raw_params.each_char { |c| handle_char(c) }
+
+        add_word # We have to explicitly add the last one.
+      end
+
+      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 handle_special(char)
+        if char == '\\'
+          @escaped = true
+        elsif char == '"'
+          @in_quotes = !@in_quotes
+          @word << char
+        end
+      end
+
+      def add_word
+        return if @word.empty?
+
+        @params << @word
+        @word = ''
+      end
+
+      def close_escape(char)
+        @word << char
+        @escaped = false
+      end
+
+      def strip_quotes(name)
+        name.delete_prefix('"').delete_suffix('"')
       end
     end
   end

data/lib/jekyll_picture_tag/output_formats.rb

@@ -1,4 +1,4 @@
-require_relative 'output_formats/basics'
+require_relative 'output_formats/basic'
 require_relative 'output_formats/data_attributes'
 require_relative 'output_formats/auto'
 require_relative 'output_formats/img'

data/lib/jekyll_picture_tag/output_formats/{basics.rb → basic.rb}

@@ -3,7 +3,7 @@ module PictureTag
   # own option.
   module OutputFormats
     # Generic functions common to all output formats.
-    module Basics
+    class Basic
       include ObjectiveElements
 
       # Used for both the fallback image, and for the complete markup.
@@ -16,7 +16,7 @@ module PictureTag
 
         fallback = build_fallback_image
 
-        add_src(img, fallback.name)
+        add_src(img, fallback.uri)
 
         add_alt(img, attributes['alt'])
 
@@ -40,26 +40,17 @@ module PictureTag
       end
 
       # Media is the media query associated with the desired source image.
-      def build_srcset(media, format)
+      def build_srcset(source_image, format)
         if PictureTag.preset['pixel_ratios']
-          build_pixel_ratio_srcset(media, format)
+          Srcsets::PixelRatio.new(source_image, format)
         else
-          build_width_srcset(media, format)
+          Srcsets::Width.new(source_image, format)
         end
       end
 
-      def build_pixel_ratio_srcset(media, format)
-        Srcsets::PixelRatio.new(media: media, format: format)
-      end
-
-      def build_width_srcset(media, format)
-        Srcsets::Width.new(media: media, format: format)
-      end
-
       # Extracting these functions to their own methods for easy overriding.
-      # They are destructive.
-      def add_src(element, name)
-        element.src = PictureTag.build_url name
+      def add_src(element, uri)
+        element.src = uri
       end
 
       def add_srcset(element, srcset)
@@ -81,9 +72,9 @@ module PictureTag
       # File, not HTML
       def build_fallback_image
         GeneratedImage.new(
-          source_file: PictureTag.source_images[nil],
+          source_file: PictureTag.source_images.first,
           format: PictureTag.fallback_format,
-          width: PictureTag.fallback_width
+          width: checked_fallback_width
         )
       end
 
@@ -93,7 +84,7 @@ module PictureTag
       # Kramdown is super picky about the {::nomarkdown} extension-- we have to
       # strip line breaks or nothing works.
       def nomarkdown_wrapper(content)
-        "{::nomarkdown}#{content.delete("\n")}{:/nomarkdown}"
+        "{::nomarkdown}#{content.delete("\n").gsub(/>  </, '><')}{:/nomarkdown}"
       end
 
       def anchor_tag(content)
@@ -103,6 +94,20 @@ module PictureTag
 
         content.add_parent anchor
       end
+
+      def checked_fallback_width
+        source = PictureTag.source_images.first
+        target = PictureTag.fallback_width
+
+        if target > source.width
+          Utils.warning "#{source.shortname} is smaller than the " \
+            "requested fallback width of #{target}px. Using #{source.width}" \
+            ' px instead.'
+          source.width
+        else
+          target
+        end
+      end
     end
   end
 end

data/lib/jekyll_picture_tag/output_formats/data_attributes.rb

@@ -9,8 +9,8 @@ module PictureTag
 
       private
 
-      def add_src(element, name)
-        element.attributes << { 'data-src' => PictureTag.build_url(name) }
+      def add_src(element, uri)
+        element.attributes << { 'data-src' => uri }
       end
 
       def add_srcset(element, srcset)

data/lib/jekyll_picture_tag/output_formats/direct_url.rb

@@ -2,9 +2,7 @@ module PictureTag
   module OutputFormats
     # Represents a bare url you can use in another context, such as a direct
     # link, but keep the resizing functionality
-    class DirectUrl
-      include PictureTag::OutputFormats::Basics
-
+    class DirectUrl < Basic
       def to_s
         build_base_img.src
       end

data/lib/jekyll_picture_tag/output_formats/img.rb

@@ -2,11 +2,11 @@ module PictureTag
   module OutputFormats
     # Represents a bare <img> tag with a srcset attribute.
     # Used when <picture> is unnecessary.
-    class Img
-      include PictureTag::OutputFormats::Basics
-
+    class Img < Basic
       def srcset
-        build_srcset(nil, PictureTag.preset['formats'].first)
+        @srcset ||= build_srcset(
+          PictureTag.source_images.first, PictureTag.formats.first
+        )
       end
 
       def base_markup

data/lib/jekyll_picture_tag/output_formats/naked_srcset.rb

@@ -1,11 +1,12 @@
 module PictureTag
   module OutputFormats
     # Returns only a srcset attribute, for more custom or complicated markup.
-    class NakedSrcset
-      include Basics
-
+    class NakedSrcset < Basic
       def to_s
-        build_srcset(nil, PictureTag.preset['formats'].first).to_s
+        image = PictureTag.source_images.first
+        format = PictureTag.formats.first
+
+        build_srcset(image, format).to_s
       end
     end
   end

data/lib/jekyll_picture_tag/output_formats/picture.rb

@@ -2,25 +2,15 @@ module PictureTag
   module OutputFormats
     # Represents a <picture> tag, enclosing at least 2 <source> tags and an
     # <img> tag.
-    class Picture
-      include Basics
-
+    class Picture < Basic
       def srcsets
+        formats = PictureTag.formats
+        # Source images are provided in reverse order and must be flipped:
+        images = PictureTag.source_images.reverse
         sets = []
 
-        PictureTag.preset['formats'].each do |format|
-          # We have 2 dimensions here: formats, and source images. Formats are
-          # provided in the order they must be returned, source images are
-          # provided in the reverse (least to most preferable) and must be
-          # flipped. We'll use an intermediate value to accomplish this.
-          format_set = []
-
-          # Source images are defined in the tag params, and associated with
-          # media queries. The base (first provided) image has a key of nil.
-          PictureTag.source_images.each_key do |media|
-            format_set << build_srcset(media, format)
-          end
-          sets.concat format_set.reverse
+        formats.each do |format|
+          images.each { |image| sets << build_srcset(image, format) }
         end
 
         sets

data/lib/jekyll_picture_tag/output_formats/readme.md

@@ -1,16 +1,9 @@
 # Writing Output Formats
 
-
 ## Naming and Instantiating
 
-Names from the configuration wiAn output format is instantiated will be
-converted from snake case to title case (I'm not sure what it's called.) And
-instantiated. 
-
-Example:
-
-In `_data/picture.yml`: `markup: example_format` will cause the plugin to use
-an instance of `ExampleFormat` (with no arguments.)
+In the relevant `_data/picture.yml` preset, `markup: example_format` will cause
+the plugin to use an instance of `ExampleFormat` (with no arguments.)
 
 You'll need to add an appropriate `require_relative` statement to
 `../output_formats.rb`
@@ -24,13 +17,13 @@ it this way because information flow was getting arduous; I was passing a lot
 of information to classes which only needed it to pass on to classes they
 instantiate.
 
-`PictureTag.source_images` returns a hash of the source images provided in the
-liquid tag. This relies on 2 properties of ruby hashes: They maintain their
-order, and `nil` is a perfectly good key. The first image (unqualified) is
-stored under `PictureTag.source_images[nil]`, and the rest of the keys are
-media queries named in `_data/picture.yml`.
+`PictureTag.source_images` returns an array of the source images provided in
+the liquid tag. The first one is the base image, the rest that follow are
+associated with media queries. Check out `source_image.rb` to see what they
+offer.
 
-There's a lot of information available, dig around in `../instructions.rb`. Output formats should only consume this information, never modify it.
+There's a lot of information available, dig around in `../router.rb`.
+Output formats should only consume this information, never modify it.
 
 ## Producing output
 

data/lib/jekyll_picture_tag/router.rb

@@ -0,0 +1,98 @@
+module PictureTag
+  # The rest of the application doesn't care where the instruction logic
+  # resides. The following module 'routes' method calls to the right place, so
+  # the rest of the application can just call 'PictureTag.(some method)'
+
+  # At first I thought I'd do some sweet dynamic metaprogramming here, but it
+  # ended up complicated and clever, rather than convenient and understandable.
+  # This way is not strictly DRY, but it's straightforward and readable. If it
+  # gets big, I'll refactor.
+  module Router
+    attr_accessor :instructions, :context
+    # Context forwarding
+
+    # Global site data
+    def site
+      @context.registers[:site]
+    end
+
+    # Page which tag is called from
+    def page
+      @context.registers[:page]
+    end
+
+    # Instructions forwarding
+
+    def config
+      @instructions.config
+    end
+
+    def preset
+      @instructions.preset
+    end
+
+    def media_presets
+      @instructions.media_presets
+    end
+
+    def html_attributes
+      @instructions.html_attributes
+    end
+
+    def output_class
+      @instructions.output_class
+    end
+
+    def source_images
+      @instructions.source_images
+    end
+
+    # Config Forwarding
+
+    def source_dir
+      config.source_dir
+    end
+
+    def dest_dir
+      config.dest_dir
+    end
+
+    def continue_on_missing?
+      config.continue_on_missing?
+    end
+
+    def cdn?
+      config.cdn?
+    end
+
+    def pconfig
+      config.pconfig
+    end
+
+    # Preset forwarding
+
+    def widths(media)
+      preset.widths(media)
+    end
+
+    def formats
+      preset.formats
+    end
+
+    def fallback_format
+      preset.fallback_format
+    end
+
+    def fallback_width
+      preset.fallback_width
+    end
+
+    def nomarkdown?
+      preset.nomarkdown?
+    end
+
+    def quality(format)
+      preset.quality(format)
+    end
+  end
+end