jekyll_picture_tag 1.14.0 → 2.0.0pre1

data/lib/jekyll_picture_tag/instructions/parents/conditional_instruction.rb

@@ -0,0 +1,69 @@
+module PictureTag
+  module Instructions
+    # Many inputs take a common format: a generic setting which applies all of
+    # the time, or more specific versions of that setting for specific
+    # circumstances. For example, quality can be set globally, or per image
+    # format. This instruction class handles those cases.
+    #
+    # To use, you must at minimum define setting_basename, setting_prefix, and
+    # add to the acceptable_types (or write your own validation).
+    class ConditionalInstruction < Instruction
+      def value(*args)
+        coerce(*args)
+      end
+
+      private
+
+      def setting_basename
+        raise NotImplementedError
+      end
+
+      # Special condition for setting; media, crop, etc
+      def setting_prefix
+        raise NotImplementedError
+      end
+
+      def acceptable_types
+        [NilClass]
+      end
+
+      def coerce(arg)
+        raise ArgumentError unless valid?
+
+        value_hash[arg]
+      end
+
+      def source
+        {
+          hash: PictureTag.preset[setting_prefix + '_' + setting_name],
+          default: PictureTag.preset[setting_name]
+        }
+      end
+
+      def value_hash
+        vals = source[:hash] || {}
+        vals.default = source[:default]
+
+        vals
+      end
+
+      def valid?
+        valid_hash? && valid_default?
+      end
+
+      def acceptable_type?(value)
+        acceptable_types.any? { |type| value.is_a? type }
+      end
+
+      def valid_hash?
+        source[:hash].nil? || source[:hash].values.all? do |v|
+          acceptable_type?(v)
+        end
+      end
+
+      def valid_default?
+        acceptable_type? source[:default]
+      end
+    end
+  end
+end

data/lib/jekyll_picture_tag/instructions/parents/env_instruction.rb

@@ -0,0 +1,29 @@
+module PictureTag
+  module Instructions
+    # There are a few config settings which are environment dependent, and can
+    # either be booleans, environment names, or arrays of environment names.
+    # This class works it out and returns a boolean.
+    class EnvInstruction < Instruction
+      private
+
+      def coerce
+        get_bool(source)
+      end
+
+      def get_bool(value)
+        case value
+        when true, false, nil then value
+        when String then value == PictureTag.jekyll_env
+        when Array then value.include? PictureTag.jekyll_env
+        when Hash then get_bool(value[:setting])
+        else raise ArgumentError, error_message
+        end
+      end
+
+      def error_message
+        "JPT - #{setting_name} must be a boolean, an environment name," \
+          ' or an array of environment names.'
+      end
+    end
+  end
+end

data/lib/jekyll_picture_tag/output_formats/basic.rb

@@ -76,9 +76,7 @@ module PictureTag
         image = GeneratedImage.new(
           source_file: PictureTag.source_images.first,
           format: PictureTag.fallback_format,
-          width: checked_fallback_width,
-          crop: PictureTag.crop,
-          gravity: PictureTag.gravity
+          width: checked_fallback_width
         )
 
         image.generate
@@ -92,9 +90,7 @@ module PictureTag
         @fallback_candidate ||= GeneratedImage.new(
           source_file: PictureTag.source_images.first,
           format: PictureTag.fallback_format,
-          width: PictureTag.fallback_width,
-          crop: PictureTag.crop,
-          gravity: PictureTag.gravity
+          width: PictureTag.fallback_width
         )
       end
 
@@ -119,22 +115,14 @@ module PictureTag
         PictureTag.source_images.first
       end
 
-      def source_width
-        if PictureTag.crop
-          fallback_candidate.source_width
-        else
-          source.width
-        end
-      end
-
       def checked_fallback_width
         target = PictureTag.fallback_width
 
-        if target > source_width
+        if target > source.width
           Utils.warning "#{source.shortname} is smaller than the " \
-            "requested fallback width of #{target}px. Using #{source_width}" \
+            "requested fallback width of #{target}px. Using #{source.width}" \
             ' px instead.'
-          source_width
+          source.width
         else
           target
         end

data/lib/jekyll_picture_tag/parsers.rb

@@ -0,0 +1,5 @@
+require_relative 'parsers/arg_splitter'
+require_relative 'parsers/configuration'
+require_relative 'parsers/html_attributes'
+require_relative 'parsers/preset'
+require_relative 'parsers/tag_parser'

data/lib/jekyll_picture_tag/{instructions → parsers}/arg_splitter.rb

@@ -1,5 +1,5 @@
 module PictureTag
-  module Instructions
+  module Parsers
     # This class takes in the arguments passed to the liquid tag, and splits it
     # up into 'words' (correctly handling quotes and backslash escapes.)
     #

data/lib/jekyll_picture_tag/parsers/configuration.rb

@@ -0,0 +1,28 @@
+module PictureTag
+  module Parsers
+    # Global config (big picture). loads jekyll data/config files, and the j-p-t
+    # defaults from included yml files.
+    class Configuration
+      # returns jekyll's configuration (picture is a subset)
+      def [](key)
+        content[key]
+      end
+
+      private
+
+      def content
+        @content ||= setting_merge(DEFAULT_CONFIG, PictureTag.site.config)
+      end
+
+      def setting_merge(default, jekyll)
+        jekyll.merge default do |_key, config_setting, default_setting|
+          if default_setting.respond_to? :merge
+            setting_merge(default_setting, config_setting)
+          else
+            config_setting
+          end
+        end
+      end
+    end
+  end
+end

data/lib/jekyll_picture_tag/{instructions → parsers}/html_attributes.rb

@@ -1,5 +1,5 @@
 module PictureTag
-  module Instructions
+  module Parsers
     # Handles HTML attributes, sourced from configuration and the liquid tag,
     # sent to various elements.
     # Stored as a hash, with string keys.

data/lib/jekyll_picture_tag/parsers/preset.rb

@@ -0,0 +1,43 @@
+module PictureTag
+  module Parsers
+    # Handles the specific tag image set to construct.
+    class Preset
+      attr_reader :name
+
+      def initialize(name)
+        @name = name
+      end
+
+      def [](key)
+        content[key]
+      end
+
+      protected
+
+      def content
+        @content ||= DEFAULT_PRESET.merge settings
+      end
+
+      private
+
+      def settings
+        PictureTag.site.data.dig('picture', 'presets', name) ||
+          STOCK_PRESETS[name] ||
+          no_preset
+      end
+
+      def no_preset
+        unless name == 'default'
+          Utils.warning(
+            <<~HEREDOC
+              Preset "#{name}" not found in #{PictureTag.config['data_dir']}/picture.yml
+              under 'presets' key, or in stock presets. Using default values."
+            HEREDOC
+          )
+        end
+
+        {}
+      end
+    end
+  end
+end

data/lib/jekyll_picture_tag/{instructions → parsers}/tag_parser.rb

@@ -1,5 +1,5 @@
 module PictureTag
-  module Instructions
+  module Parsers
     # Tag Parsing Responsibilities:
     #
     #  {% picture mypreset a.jpg 3:2 mobile: b.jpg --alt "Alt" --link "/" %}
@@ -9,17 +9,16 @@ module PictureTag
     # 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
+    # crop and keep. 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
+    # orders. Crop settings 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, :gravities,
-                  :geometries, :leftovers
+      attr_reader :preset_name, :source_names, :media_presets, :keep,
+                  :crop, :leftovers
 
       def initialize(raw_params)
         @raw_params = raw_params
@@ -27,8 +26,8 @@ module PictureTag
 
         @media_presets = []
         @source_names = []
-        @geometries = {}
-        @gravities = {}
+        @keep = {}
+        @crop = {}
 
         parse_params
       end
@@ -51,14 +50,18 @@ module PictureTag
       end
 
       def parse_param(param)
+        # Media query, i.e. 'mobile:'
         if param.match?(/[\w\-]+:$/)
           add_media_source
 
-        elsif Utils::GRAVITIES.include?(param.downcase)
-          @gravities[@media_presets.last] = @params.shift
+        # Smartcrop interestingness setting. We label it 'keep', since it
+        # determines what to keep when cropping.
+        elsif %w[none centre center entropy attention].include?(param.downcase)
+          @keep[@media_presets.last] = @params.shift
 
-        elsif param.match?(Utils::GEOMETRY_REGEX)
-          @geometries[@media_presets.last] = @params.shift
+        # Aspect ratio, i.e. '16:9'
+        elsif param.match?(/\A\d+:\d+\z/)
+          @crop[@media_presets.last] = @params.shift
 
         else
           raise_error(param)

data/lib/jekyll_picture_tag/router.rb

@@ -1,115 +1,57 @@
 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.
+  # resides. This module 'routes' method calls to the right place, so
+  # information consumers can just call 'PictureTag.(some method)'
+  #
+  # This is accomplished with a bit of metaprogramming, which is hopefully not
+  # unnecessarily clever or complicated. Missing methods are converted to class
+  # names, which are looked up under the Instructions module namespace.
+  #
+  # Instantiated Instructions are stored in a hash, keyed by method name.
   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
+    # These two attributes encompass everything passed in by Jekyll.
+    attr_accessor :raw_params, :context
 
-    def source_images
-      @instructions.source_images
+    def method_missing(method_name, *args)
+      if instruction_exists?(method_name)
+        instruction(method_name).value(*args)
+      else
+        super
+      end
     end
 
-    def crop(media = nil)
-      @instructions.crop(media)
+    def respond_to_missing?(method_name, *args)
+      instruction_exists?(method_name) || super
     end
 
-    def gravity(media = nil)
-      @instructions.gravity(media)
+    # Required at least for testing; instructions are persisted between tags
+    # otherwise.
+    def clear_instructions
+      instructions.clear
     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
-
-    def disabled?
-      config.disabled?
-    end
-
-    def fast_build?
-      config.fast_build?
-    end
-
-    # Preset forwarding
-
-    def widths(media)
-      preset.widths(media)
-    end
+    private
 
-    def formats
-      preset.formats
+    def instruction(method_name)
+      instructions[method_name] ||= instruction_class(method_name).new
     end
 
-    def fallback_format
-      preset.fallback_format
+    def instructions
+      @instructions ||= {}
     end
 
-    def fallback_width
-      preset.fallback_width
+    def instruction_exists?(method_name)
+      Object.const_defined? instruction_class_name(method_name.to_sym)
     end
 
-    def nomarkdown?
-      preset.nomarkdown?
+    # Class names can't contain question marks, so we strip them.
+    def instruction_class(method_name)
+      Object.const_get instruction_class_name(method_name)
     end
 
-    def quality(format, width)
-      preset.quality(format, width)
+    def instruction_class_name(method_name)
+      'PictureTag::Instructions::' +
+        Utils.titleize(method_name.to_s.delete_suffix('?'))
     end
   end
 end