jekyll_picture_tag 1.12.0 → 2.0.1

data/lib/jekyll_picture_tag/instructions.rb

@@ -1,6 +1,70 @@
-require_relative './instructions/set'
-require_relative './instructions/configuration'
-require_relative './instructions/html_attributes'
-require_relative './instructions/preset'
-require_relative './instructions/tag_parser'
-require_relative './instructions/arg_splitter'
+module PictureTag
+  # Instructions obtain, validate, and typecast/coerce input values. These
+  # inputs are either taken directly from jekyll's inputs, or handled by parsers
+  # first.
+  #
+  # Logic which affects only a single setting belongs in Instructions, while
+  # logic which affects multiple settings belongs in Parsers.
+  #
+  # Since instruction classes are so small, we define several per file in the
+  # instructions directory to save on boilerplate. All fall under the
+  # Instructions module namespace.
+  module Instructions
+    # Generic instruction, meant to be inherited. Children of this class must
+    # override the source method, and likely want to override valid?, coerce,
+    # and error_message as applicable.
+    class Instruction
+      # Memoized value of the given instruction. This is the public API.
+      def value
+        return @value if defined?(@value)
+
+        raise ArgumentError, error_message unless valid?
+
+        @value = coerced
+      end
+
+      private
+
+      # Source(s) of truth - where does this setting come from? Logic does not
+      # belong here. If information comes from muliple places, return an array
+      # or a hash.
+      def source
+        raise NotImplementedError
+      end
+
+      # Determine whether or not the input(s) are valid.
+      def valid?
+        true
+      end
+
+      # Convert input(s) to output.
+      def coerce
+        source
+      end
+
+      # Message returned if validation fails. Override this with something more
+      # helpful.
+      def error_message
+        "JPT - #{setting_name} received an invalid argument: #{source}"
+      end
+
+      def coerced
+        return @coerced if defined?(@coerced)
+
+        @coerced = coerce
+      end
+
+      def setting_name
+        Utils.snakeize(self.class.to_s.split('::').last)
+      end
+    end
+  end
+end
+
+# Load Parents
+Dir[File.dirname(__FILE__) + '/instructions/parents/*.rb']
+  .sort.each { |file| require file }
+
+# Load children:
+Dir[File.dirname(__FILE__) + '/instructions/children/*.rb']
+  .sort.each { |file| require file }

data/lib/jekyll_picture_tag/instructions/children/config.rb

@@ -0,0 +1,128 @@
+module PictureTag
+  module Instructions
+    # PictureTag configuration in _config.yml
+    class Pconfig < Instruction
+      def source
+        PictureTag.config['picture']
+      end
+    end
+
+    # https://example.com/my-base-path/assets/generated-images/image.jpg
+    #                     ^^^^^^^^^^^^^
+    # |     domain       |  baseurl   |       directory       | filename
+    class Baseurl < Instruction
+      def source
+        {
+          ignore: PictureTag.pconfig['ignore_baseurl'],
+          key: PictureTag.pconfig['baseurl_key']
+        }
+      end
+
+      def coerce
+        return '' if source[:ignore]
+
+        PictureTag.config[source[:key]] || ''
+      end
+    end
+
+    # Whether to use relative or absolute URLs for images.
+    class RelativeUrl < EnvInstruction
+      def source
+        PictureTag.pconfig['relative_url']
+      end
+    end
+
+    # Image source directory
+    class SourceDir < Instruction
+      private
+
+      def source
+        [
+          PictureTag.site.source,
+          PictureTag.pconfig['source']
+        ]
+      end
+
+      def coerce
+        File.join(*source.map(&:to_s))
+      end
+
+      def setting_name
+        'source directory'
+      end
+    end
+
+    # Image output directory
+    class DestDir < Instruction
+      private
+
+      def source
+        [
+          PictureTag.site.config['destination'],
+          PictureTag.pconfig['output']
+        ]
+      end
+
+      def coerce
+        File.join(*source.map(&:to_s))
+      end
+    end
+
+    # Whether to continue if a source image is missing
+    class ContinueOnMissing < EnvInstruction
+      def source
+        PictureTag.pconfig['ignore_missing_images']
+      end
+    end
+
+    # Whether to use a CDN
+    class Cdn < EnvInstruction
+      def source
+        {
+          url: PictureTag.pconfig['cdn_url'],
+          setting: PictureTag.pconfig['cdn_environments']
+        }
+      end
+
+      def coerce
+        source[:url] && super
+      end
+    end
+
+    # CDN URL
+    class CdnUrl < Instruction
+      def source
+        PictureTag.pconfig['cdn_url']
+      end
+
+      def valid?
+        require 'uri'
+        uri = URI(source)
+
+        # If the URI library can't parse it, it's not valid.
+        uri.scheme && uri.host
+      end
+
+      def error_message
+        <<~HEREDOC
+          cdn_url must be a valid URI in the following format: https://example.com/
+          current setting: #{source}
+        HEREDOC
+      end
+    end
+
+    # Disable JPT?
+    class Disabled < EnvInstruction
+      def source
+        PictureTag.pconfig['disabled']
+      end
+    end
+
+    # Fast build?
+    class FastBuild < EnvInstruction
+      def source
+        PictureTag.pconfig['fast_build']
+      end
+    end
+  end
+end

data/lib/jekyll_picture_tag/instructions/children/context.rb

@@ -0,0 +1,24 @@
+module PictureTag
+  module Instructions
+    # Jekyll site info
+    class Site < Instruction
+      def source
+        PictureTag.context.registers[:site]
+      end
+    end
+
+    # Current page in jekyll site
+    class Page < Instruction
+      def source
+        PictureTag.context.registers[:page]
+      end
+    end
+
+    # Digs into jekyll context, returns current environment
+    class JekyllEnv < Instruction
+      def source
+        PictureTag.context.environments.first['jekyll']['environment']
+      end
+    end
+  end
+end

data/lib/jekyll_picture_tag/instructions/children/params.rb

@@ -0,0 +1,90 @@
+module PictureTag
+  module Instructions
+    # Builds instances of all source images.
+    class SourceImages < Instruction
+      def source
+        {
+          source_names: PictureTag.params.source_names,
+          media_presets: PictureTag.params.media_presets
+        }
+      end
+
+      def coerce
+        sources = [PictureTag::SourceImage.new(source[:source_names].shift)]
+
+        while source[:source_names].any?
+          sources << PictureTag::SourceImage.new(
+            source[:source_names].shift, source[:media_presets].shift
+          )
+        end
+
+        sources
+      end
+    end
+
+    # Which crop to use for a given media query. Can be given either in params
+    # or preset.
+    class Crop < ConditionalInstruction
+      def source
+        super.merge(
+          { params: PictureTag.params.crop }
+        )
+      end
+
+      def coerce(media = nil)
+        raise ArgumentError unless valid?
+
+        source[:params][media] || value_hash[media]
+      end
+
+      def setting_basename
+        'crop'
+      end
+
+      def setting_prefix
+        'media'
+      end
+
+      def acceptable_types
+        super + [String]
+      end
+    end
+
+    # Which vips interestingness setting to use for a given media query. Can be
+    # given either in params or preset.
+    class Keep < ConditionalInstruction
+      def source
+        super.merge(
+          { params: PictureTag.params.keep }
+        )
+      end
+
+      def coerce(media = nil)
+        raise ArgumentError unless valid?
+
+        lookup[source[:params][media] || super(media)]
+      end
+
+      def lookup
+        {
+          'center' => :centre,
+          'centre' => :centre,
+          'attention' => :attention,
+          'entropy' => :entropy
+        }
+      end
+
+      def setting_basename
+        'keep'
+      end
+
+      def setting_prefix
+        'media'
+      end
+
+      def acceptable_types
+        super + [String]
+      end
+    end
+  end
+end

data/lib/jekyll_picture_tag/instructions/children/parsers.rb

@@ -0,0 +1,48 @@
+module PictureTag
+  module Instructions
+    # PictureTag configuration
+    class Config < Instruction
+      def source
+        PictureTag::Parsers::Configuration.new
+      end
+    end
+
+    # Tag parameters
+    class Params < Instruction
+      def source
+        PictureTag::Parsers::TagParser.new PictureTag.raw_params
+      end
+    end
+
+    # Currently selected preset
+    class Preset < Instruction
+      def source
+        PictureTag::Parsers::Preset.new PictureTag.params.preset_name
+      end
+    end
+
+    # Handles non-image arguments to liquid tag and preset.
+    class HtmlAttributes < Instruction
+      def source
+        PictureTag::Parsers::HTMLAttributeSet.new PictureTag.params.leftovers
+      end
+    end
+
+    # TODO: rename to MediaQueries
+    # Returns user-defined media queries.
+    class MediaPresets < Instruction
+      def source
+        STOCK_MEDIA_QUERIES.merge(
+          PictureTag.site.data.dig('picture', 'media_queries') || {}
+        )
+      end
+    end
+
+    # Main job is to determine which backend should handle which image formats.
+    class Backend < Instruction
+      def source
+        PictureTag::Parsers::ImageBackend.new
+      end
+    end
+  end
+end

data/lib/jekyll_picture_tag/instructions/children/preset.rb

@@ -0,0 +1,182 @@
+require 'mime-types'
+
+module PictureTag
+  module Instructions
+    # Returns an instance of the correct markup format's corresponding class
+    class OutputClass < Instruction
+      private
+
+      def source
+        PictureTag.preset['markup']
+      end
+
+      def coerce
+        Object.const_get(class_name)
+      end
+
+      def class_name
+        'PictureTag::OutputFormats::' + Utils.titleize(source)
+      end
+
+      def valid?
+        source.is_a?(String) &&
+          !source.include?(' ') &&
+          Object.const_defined?(class_name)
+      end
+    end
+
+    # Image formats
+    class Formats < Instruction
+      private
+
+      def source
+        PictureTag.preset['formats']
+      end
+
+      def coerce
+        [source].flatten
+      end
+
+      def valid?
+        coerced.all? do |format|
+          types = MIME::Types.type_for(format)
+          format == 'original' ||
+            types.length == 1 && types.first.media_type == 'image'
+        end
+      end
+    end
+
+    # Fallback image format
+    class FallbackFormat < Instruction
+      private
+
+      def source
+        PictureTag.preset['fallback_format']
+      end
+
+      def valid?
+        types = MIME::Types.type_for(coerced)
+        coerced == 'original' ||
+          types.length == 1 && types.first.media_type == 'image'
+      end
+    end
+
+    # Fallback Image width
+    class FallbackWidth < Instruction
+      private
+
+      def source
+        PictureTag.preset['fallback_width']
+      end
+
+      def valid?
+        source.is_a? Integer
+      end
+
+      def error_message
+        <<~HEREDOC
+          fallback_width for preset '#{PictureTag.preset.name}' is invalid. It
+          should be a positive integer. You can use underscores as separators:
+            1200
+            1_200
+        HEREDOC
+      end
+    end
+
+    # Whether to add a {::nomarkdown} wrapper
+    class Nomarkdown < Instruction
+      private
+
+      def source
+        {
+          config: PictureTag.pconfig['nomarkdown'],
+          md_page: Utils.markdown_page?,
+          preset: PictureTag.preset['nomarkdown']
+        }
+      end
+
+      def valid?
+        source.fetch_values(:preset, :config).all? do |setting|
+          [true, false, nil].include? setting
+        end
+      end
+
+      def coerce
+        return source[:preset] unless source[:preset].nil?
+
+        source[:md_page] && source[:config]
+      end
+    end
+
+    # Returns widths for a given media query.
+    class Widths < ConditionalInstruction
+      private
+
+      def setting_name
+        'widths'
+      end
+
+      def setting_prefix
+        'media'
+      end
+
+      def acceptable_types
+        super + [Array]
+      end
+
+      def valid_hash?
+        hash = source[:hash]
+        return true if hash.nil?
+
+        hash.is_a?(Hash) && valid_hash_keys?(hash) && valid_hash_values?(hash)
+      end
+
+      def valid_hash_keys?(hash)
+        hash.keys.all? { |k| k.is_a? String }
+      end
+
+      def valid_hash_values?(hash)
+        hash.values.all? do |val|
+          val.is_a?(Array) && val.all? { |subval| subval.is_a? Integer }
+        end
+      end
+    end
+
+    # Returns quality for a given width.
+    class Quality < ConditionalInstruction
+      private
+
+      def setting_name
+        'quality'
+      end
+
+      def setting_prefix
+        'format'
+      end
+
+      def acceptable_types
+        super + [Integer, Hash]
+      end
+
+      def coerce(format = nil, width = nil)
+        setting = super(format)
+
+        return setting unless setting.is_a? Hash
+
+        parse_quality_hash(setting, width)
+      end
+
+      # Works out linearly interpolated quality settings.
+      def parse_quality_hash(points, width)
+        # The points can be given in any order.
+        low, high = *points.keys.map(&:to_i).sort
+
+        case width
+        when 0..low then points[low]
+        when low..high then Utils.interpolate(points.keys, points.values, width)
+        when high..999_999 then points[high]
+        end
+      end
+    end
+  end
+end