jekyll_picture_tag 1.2.0

data/lib/jekyll_picture_tag/instructions/configuration.rb

@@ -0,0 +1,82 @@
+module PictureTag
+  module Instructions
+    # Global config (big picture). loads jekyll data/config files, and the j-p-t
+    # defaults from included yml files.
+    class Configuration
+      def initialize
+        @content = build_config
+      end
+
+      def [](key)
+        @content[key]
+      end
+
+      # Site.source is the master jekyll source directory
+      # Source dir is the jekyll-picture-tag source directory.
+      def source_dir
+        File.join PictureTag.site.source, self['picture']['source']
+      end
+
+      # site.dest is the master jekyll destination directory
+      # source_dest is the jekyll-picture-tag destination directory. (generated
+      # file location setting.)
+      def dest_dir
+        File.join PictureTag.site.dest, self['picture']['output']
+      end
+
+      # Takes our config into account. Generated images, not source
+      def build_url(filename)
+        File.join url_prefix, self['picture']['output'], filename
+      end
+
+      # For linking source images
+      def build_source_url(filename)
+        File.join url_prefix, self['picture']['source'], filename
+      end
+
+      def nomarkdown?
+        Utils.markdown_page? && self['picture']['nomarkdown']
+      end
+
+      private
+
+      def build_config
+        YAML.safe_load(
+          # Jekyll Picture Tag Default settings
+          File.read(
+            File.join(ROOT_PATH, 'jekyll_picture_tag/defaults/global.yml')
+          )
+        ).merge(
+          # _config.yml defined settings
+          PictureTag.site.config
+        ) do |_key, jpt_default, site_value|
+          setting_merge(jpt_default, site_value)
+        end
+      end
+
+      def setting_merge(jpt_default, site_value)
+        if site_value.nil?
+          # Jekyll baseurl is nil if not configured, which breaks things.
+          # jpt_default is an empty string, which doesn't.
+          jpt_default
+        elsif site_value.is_a? Hash
+          # We'll merge hashes one level deep. If we need true deep merging,
+          # we'll import a gem or do something recursive.
+          jpt_default.merge site_value
+        else
+          site_value
+        end
+      end
+
+      # https://example.com/my-base-path/assets/generated-images/image.jpg
+      # ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+      # |     site url     | site path  |    j-p-t dest dir     |
+      def url_prefix
+        File.join(
+          self['picture']['relative_url'] ? '' : PictureTag.config['url'],
+          PictureTag.config['baseurl'],
+        )
+      end
+    end
+  end
+end

data/lib/jekyll_picture_tag/instructions/html_attributes.rb

@@ -0,0 +1,59 @@
+module PictureTag
+  module Instructions
+    # Handles HTML attributes, sourced from configuration and the liquid tag,
+    # sent to various elements.
+    # Stored as a hash, with string keys.
+    class HTMLAttributeSet
+      # Initialize with leftovers passed into the liquid tag
+      def initialize(params)
+        @content = load_preset
+
+        parse_params(params) if params
+        handle_url
+      end
+
+      def [](key)
+        @content[key]
+      end
+
+      private
+
+      def load_preset
+        PictureTag.preset['attributes'] || {}
+      end
+
+      # Syntax this function processes:
+      # class="old way" --picture class="new way" --alt Here's my alt text
+      def parse_params(params)
+        params_array = params.split(/\s+--/).map(&:strip)
+
+        # This allows the old tag syntax to work.
+        @content['implicit'] = params_array.shift unless params.strip =~ /^--/
+
+        # Split function above doesn't take the dashes off the first param.
+        params_array.first.delete_prefix! '--' if params_array.any?
+
+        params_array.each do |param|
+          # Splits on spaces, the first word will be our key.
+          a = param.split
+
+          # Supplied tag arguments will overwrite (not append) configured values
+          @content[a.shift] = a.join(' ')
+        end
+      end
+      # Handles anchor tag destination. Can come from 2 places in 2 formats:
+      # Can come from defaults, preset, or tag
+      # Default is false. Preset can specify either true or false
+      # Tag params can be a URL
+
+      # picture test.jpg --url http://example.com
+      def handle_url
+        return unless PictureTag.preset['link_source'] && !self['link']
+
+        @content['link'] = PictureTag.build_source_url(
+          Utils.biggest_source.shortname
+        )
+      end
+    end
+  end
+end

data/lib/jekyll_picture_tag/instructions/preset.rb

@@ -0,0 +1,61 @@
+module PictureTag
+  module Instructions
+    # Handles the specific tag image set to construct.
+    class Preset
+      attr_reader :name
+      def initialize
+        @name = PictureTag.preset_name
+        @content = build_preset
+      end
+
+      def [](key)
+        @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 fallback_format
+        PictureTag::Utils.process_format(@content['fallback_format'], nil)
+      end
+
+      def fallback_width
+        @content['fallback_width']
+      end
+
+      private
+
+      def build_preset
+        # The _data/picture.yml file is optional.
+        picture_data_file = grab_data_file
+
+        default_preset.merge picture_data_file
+      end
+
+      def default_preset
+        YAML.safe_load File.read(
+          File.join(ROOT_PATH, 'jekyll_picture_tag/defaults/presets.yml')
+        )
+      end
+
+      def grab_data_file
+        PictureTag.site
+                  .data
+                  .dig('picture', 'markup_presets', @name) || no_preset
+      end
+
+      def no_preset
+        Utils.warning(
+          " Preset \"#{@name}\" not found in _data/picture.yml under "\
+          'markup_presets key. Using default values.'
+        )
+
+        {}
+      end
+    end
+  end
+end

data/lib/jekyll_picture_tag/instructions/tag_parser.rb

@@ -0,0 +1,48 @@
+module PictureTag
+  module Instructions
+    # This class takes the string given to the jekyll tag, and extracts useful
+    # information from it.
+    class TagParser
+      attr_reader :preset_name, :source_images, :html_attributes_raw
+      def initialize(raw_params)
+        @params = PictureTag::Utils.liquid_lookup(raw_params).split
+
+        @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 }
+
+        # 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)
+
+        # Anything left will be html attributes
+        @html_attributes_raw = @params.join(' ')
+      end
+
+      private
+
+      # First param is the preset name, unless it's a filename.
+      def grab_preset_name
+        if @params.first =~ %r{[\w./]+\.\w+}
+          '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 }
+      end
+    end
+  end
+end

data/lib/jekyll_picture_tag/output_formats.rb

@@ -0,0 +1,9 @@
+require_relative 'output_formats/basics'
+require_relative 'output_formats/data_attributes'
+require_relative 'output_formats/auto'
+require_relative 'output_formats/img'
+require_relative 'output_formats/picture'
+require_relative 'output_formats/data_auto'
+require_relative 'output_formats/data_picture'
+require_relative 'output_formats/data_img'
+require_relative 'output_formats/direct_url'

data/lib/jekyll_picture_tag/output_formats/auto.rb

@@ -0,0 +1,15 @@
+module PictureTag
+  module OutputFormats
+    # This is an odd class, which never returns itself. It selects the most
+    # appropriate format, and returns an instance of that class.
+    class Auto
+      def self.new
+        if PictureTag::Utils.count_srcsets > 1
+          Picture.new
+        else
+          Img.new
+        end
+      end
+    end
+  end
+end

data/lib/jekyll_picture_tag/output_formats/basics.rb

@@ -0,0 +1,105 @@
+module PictureTag
+  # Contains all possible HTML output format options. Auto is considered its
+  # own option.
+  module OutputFormats
+    # Generic functions common to all output formats.
+    module Basics
+      include ObjectiveElements
+
+      # Used for both the fallback image, and for the complete markup.
+      def build_base_img
+        img = SingleTag.new 'img'
+        attributes = PictureTag.html_attributes
+
+        img.attributes << attributes['img']
+        img.attributes << attributes['implicit']
+
+        fallback = build_fallback_image
+
+        add_src(img, fallback.name)
+
+        add_alt(img, attributes['alt'])
+
+        img
+      end
+
+      def to_s
+        wrap(base_markup).to_s
+      end
+
+      private
+
+      # Handles various wrappers around basic markup
+      def wrap(markup)
+        markup = anchor_tag(markup) if PictureTag.html_attributes['link']
+        markup = nomarkdown_wrapper(markup.to_s) if PictureTag.nomarkdown?
+
+        markup
+      end
+
+      def build_srcset(media, format)
+        if PictureTag.preset['pixel_ratios']
+          build_pixel_ratio_srcset(media, format)
+        else
+          build_width_srcset(media, 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
+      end
+
+      def add_srcset(element, srcset)
+        element.srcset = srcset.to_s
+      end
+
+      def add_sizes(element, srcset)
+        element.sizes = srcset.sizes if srcset.sizes
+      end
+
+      def add_alt(element, alt)
+        element.alt = alt if alt
+      end
+
+      def add_media(element, srcset)
+        element.media = srcset.media_attribute if srcset.media
+      end
+
+      # File, not HTML
+      def build_fallback_image
+        GeneratedImage.new(
+          source_file: PictureTag.source_images[nil],
+          format: PictureTag.fallback_format,
+          width: PictureTag.fallback_width
+        )
+      end
+
+      # Stops kramdown from molesting our output
+      # Must be given a string.
+      #
+      # 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}"
+      end
+
+      def anchor_tag(content)
+        anchor = DoubleTag.new 'a'
+        anchor.attributes << PictureTag.html_attributes['a']
+        anchor.href = PictureTag.html_attributes['link']
+
+        content.add_parent anchor
+      end
+    end
+  end
+end

data/lib/jekyll_picture_tag/output_formats/data_attributes.rb

@@ -0,0 +1,44 @@
+module PictureTag
+  module OutputFormats
+    # This is not an output format, it's a module for use in others. It allows
+    # us to create JavaScript Library friendly markup, for things like LazyLoad
+    module DataAttributes
+      def base_markup
+        build_noscript(super)
+      end
+
+      private
+
+      def add_src(element, name)
+        element.attributes << { 'data-src' => PictureTag.build_url(name) }
+      end
+
+      def add_srcset(element, srcset)
+        element.attributes << { 'data-srcset' => srcset.to_s }
+      end
+
+      def add_sizes(element, srcset)
+        element.attributes << { 'data-sizes' => srcset.sizes } if srcset.sizes
+      end
+
+      def build_noscript(base_content)
+        return base_content unless PictureTag.preset['noscript']
+
+        noscript = DoubleTag.new(
+          'noscript',
+          content: Img.new.build_base_img,
+
+          # Markdown fix requires removal of line breaks:
+          oneline: PictureTag.nomarkdown?
+        ).to_s
+
+        ShelfTag.new(
+          content: [base_content, noscript],
+
+          # Markdown fix requires removal of line breaks:
+          oneline: PictureTag.nomarkdown?
+        )
+      end
+    end
+  end
+end

data/lib/jekyll_picture_tag/output_formats/data_auto.rb

@@ -0,0 +1,14 @@
+module PictureTag
+  module OutputFormats
+    # Similar to Auto, but sets data-src (and so on) instead of src
+    class DataAuto < Auto
+      def self.new
+        if PictureTag::Utils.count_srcsets > 1
+          DataPicture.new
+        else
+          DataImg.new
+        end
+      end
+    end
+  end
+end