distorted-jekyll 0.5.6 → 0.5.7

data/lib/distorted-jekyll/molecule/abstract.rb

@@ -0,0 +1,238 @@
+require 'set'
+
+require 'distorted-jekyll/floor'
+
+require 'jekyll'
+require 'liquid/errors'
+require 'liquid/template'
+require 'mime/types'
+
+
+module Jekyll
+  module DistorteD
+    module Molecule
+      module Abstract
+
+        # This list should contain global attributes only, as symbols.
+        # The final attribute set will be this + the media-type-specific set.
+        # https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes
+        GLOBAL_ATTRS = Set[:title]
+
+
+        # Returns a Set of Arrays of search keys to try in config()
+        def search_keys(*keys)
+          # It's likely that we will get a default argument of [nil]
+          # here due to the output of attr_value(:whatever) for unset attrs.
+          keys = keys.compact
+          # If a search key path was given, construct one based
+          # on the MIME::Type union Set between the source media
+          # and the plugged MediaMolecule.
+          if keys.empty? or keys.all?{|k| k.nil?}
+            try_keys = @mime.map{ |t|
+              # Use only the first part of complex sub_types like 'svg+xml'
+              [t.media_type, t.sub_type.split('+').first].compact
+            }
+          else
+            # Or use a user-provided config path.
+            try_keys = Set[keys]
+          end
+        end
+
+        # Loads configuration data telling us how to open certain
+        # types of files.
+        def welcome(*keys)
+          # Try each set of keys until we find a match
+          for try in search_keys(*keys)
+            tried = Jekyll::DistorteD::Floor::config(
+              Jekyll::DistorteD::Floor::CONFIG_ROOT,
+              :welcome,
+              *try,
+            )
+            # Is the YAML config of the appropriate structure?
+            if tried.is_a?(Hash)
+              # Non-Hashes may not respond to `empty?`
+              unless tried.empty?
+                return tried
+              end
+            end
+          end
+        end
+
+        # Load configuration telling us what media-types to generate
+        # for any given media-type input.
+        def changes(*keys)
+          out = Set[]
+          # `changes` media-type[sub_type] config will contain information about
+          # what variations output format are desired for what input format,
+          # e.g. {:image => {:jpeg => Set['image/jpeg', 'image/webp']}}
+          # It is not automatically implied that the source format is also
+          # an output format!
+          for try in search_keys(*keys)
+            tried = Jekyll::DistorteD::Floor::config(
+            Jekyll::DistorteD::Floor::CONFIG_ROOT,
+              :changes,
+              *try,
+            )
+            if tried.is_a?(Enumerable) and tried.all?{|t| t.is_a?(String)} and not tried.empty?
+              tried.each{ |t|
+                # MIME::Type.new() won't give us a usable Type object:
+                #
+                # irb> MIME::Types['image/svg+xml'].first.preferred_extension
+                # => "svg"
+                # irb> MIME::Type.new('image/svg+xml').preferred_extension
+                # => nil
+                out.merge(MIME::Types[t])
+              }
+            end
+          end
+
+          # If the config didn't give us any MIME::Type changes
+          # then we will just output the same type we loaded.
+          if out.empty?
+            return @mime
+          else
+            return out
+          end
+        end
+
+        # Loads configuration telling us what variations to generate for any
+        # given type of file, or for an arbitrary key hierarchy.
+        def outer_limits(*keys)
+          out = Set[]
+          # See if any config data exists for each given key hierarchy,
+          # but under the root DistorteD config key.
+          for try in search_keys(*keys)
+            tried = Jekyll::DistorteD::Floor::config(
+              Jekyll::DistorteD::Floor::CONFIG_ROOT,
+              :outer_limits,
+              *try,
+            )
+
+            # Is the YAML config of the appropriate structure?
+            # Merge a shallow copy of it with the Liquid-given attrs.
+            # If we don't take a copy the attrs will be memoized into the config.
+            if tried.is_a?(Enumerable) and tried.all?{|t| t.is_a?(Hash)} and not tried.empty?
+              out.merge(tried.dup.map{ |d| d.merge(attrs) })
+            end
+          end
+
+          # We should output something if the config didn't give us anything.
+          # This is kind of a mess right now with redundancies in the call sites
+          # of things like Molecule::Image. I'll come up with a better general-
+          # purpose fallback solution at some point, but for now this will get
+          # non-Image StaticFiles working with no config :)
+          if out.empty?
+            out << {
+              :tag => :full,
+              :crop => :none,
+            }
+          end
+
+          return out
+        end
+
+        # Returns a Hash of any attribute provided to DD's Liquid tag and its value.
+        def attrs
+          # Value of every Molecule-defined attr will be nil if that attr
+          # is not provided to our Liquid tag.
+          @attrs.keep_if{|attr,val| val != nil}
+        end
+
+        # Returns the value for an attribute as given to the Liquid tag,
+        # the default value if the given value is not in the accepted Set,
+        # or nil for unset attrs with no default defined.
+        def attr_value(attribute)
+          # Set of all supported attributes:
+          # - Global output-element attributes
+          # - Molecule-specific output-element attributes
+          # - Filetype change and output-template config paths
+          accepted_attrs = self.singleton_class.const_get(:GLOBAL_ATTRS) + self.singleton_class.const_get(:ATTRS) + Set[:changes, :outer_limits]
+
+          # Set of acceptable values for the given attribute, e.g. Image::loading => Set[:eager, :lazy]
+          # Will be empty if this attribute takes freeform input (like `title` or `alt`)
+          accepted_vals = self.singleton_class.const_get(:ATTRS_VALUES)&.dig(attribute)
+
+          # The value, if any, provided to our Liquid tag for this attr.
+          liquid_val = attrs&.dig(attribute)
+
+          # Is the requested attribute name defined as an accepted attribute
+          # either globally or within the plugged MediaMolecule?
+          if accepted_attrs.include?(attribute.to_sym)
+
+            # Does this attr define a set of acceptable values?
+            if accepted_vals.is_a?(Set)
+              # Yes, it does. Is the Liquid-given value in that Set of acceptable values?
+              if accepted_vals.include?(liquid_val) or accepted_vals.include?(liquid_val&.to_sym) or accepted_vals.include?(liquid_val&.to_s)
+
+                # Yes, it is! Use it.
+                liquid_val.to_s
+              else
+                # No, it isn't. Warn and return the default.
+                unless liquid_val.nil?
+                  Jekyll.logger.warn('DistorteD', "#{liquid_val.to_s} is not an acceptable value for #{attribute.to_s}: #{accepted_vals}")
+                end
+                self.singleton_class.const_get(:ATTRS_DEFAULT)&.dig(attribute).to_s
+              end
+            elsif accepted_vals.is_a?(Regexp)
+              if accepted_vals =~ liquid_val.to_s
+                liquid_val.to_s
+              else
+                unless liquid_val.nil?
+                  Jekyll.logger.warn('DistorteD', "#{liquid_val.to_s} is not a Regexp match for #{attribute.to_s}: #{accepted_vals}")
+                end
+                self.singleton_class.const_get(:ATTRS_DEFAULT)&.dig(attribute)
+              end
+            else
+              # No, this attribute does not define a Set of acceptable values.
+              # The freeform Liquid-given value is fine, but if it's nil
+              # we can still try for a default.
+              if liquid_val.nil?
+                self.singleton_class.const_get(:ATTRS_DEFAULT)&.dig(attribute)
+              else
+                liquid_val
+              end
+            end
+          else
+            Jekyll.logger.error('DistorteD', "#{attribute.to_s} is not a supported attribute")
+            nil
+          end
+        end
+
+        # Returns a Hash keyed by MIME::Type objects with value as a Set of Hashes
+        # describing the media's output variations to be generated for each Type.
+        def variations
+          changes(attr_value(:changes)).map{ |t|
+            [t, outer_limits(attr_value(:outer_limits)).map{ |d|
+              d.merge({
+                # e.g. 'SomeImage-medium.jpg` but just `SomeImage.jpg` and not `SomeImage-full.jpg`
+                # for the full-resolution outputs.
+                # The default `.jpeg` preferred_extension is monkey-patched to `.jpg` because lol
+                :name => "#{File.basename(@name, '.*')}#{'-'.concat(d&.dig(:tag).to_s) if d&.dig(:tag) != :full}.#{t.preferred_extension}",
+              })
+            }]
+          }.to_h
+        end
+
+        # Returns a flat Set of Hashes that each describe one variant of
+        # media file output that should exist for a given input file.
+        def files
+          filez = Set[]
+          variations.each_pair{ |t,v|
+            # Merge the type in to each variation Hash since we will no longer
+            # have it as the key to this Set in its container Hash.
+            v.each{ |d| filez.add(d.merge({:type => t})) }
+          }
+          filez
+        end
+
+        # Returns a Set of just the String filenames we want for this media.
+        # This will be used by `modified?` among others.
+        def filenames
+          files.map{|f| f[:name]}.to_set
+        end
+
+
+      end  # Abstract
+    end  # Molecule
+  end  # DistorteD
+end  # Jekyll

data/lib/distorted-jekyll/molecule/font.rb

@@ -0,0 +1,29 @@
+require 'set'
+
+require 'distorted-jekyll/molecule/text'
+require 'distorted-jekyll/static/font'
+
+module Jekyll
+  module DistorteD
+    module Molecule
+      module Font
+
+        include Text
+
+        DRIVER = Cooltrainer::DistorteD::Font
+
+        MEDIA_TYPE = DRIVER::MEDIA_TYPE
+        MIME_TYPES = DRIVER::MIME_TYPES
+
+        ATTRS = DRIVER::ATTRS
+        ATTRS_DEFAULT = DRIVER::ATTRS_DEFAULT
+        ATTRS_VALUES = DRIVER::ATTRS_VALUES
+
+
+        def static_file(*args)
+          Jekyll::DistorteD::Static::Font.new(*args)
+        end
+      end  # Font
+    end  # Molecule
+  end  # DistorteD
+end  # Jekyll

data/lib/distorted-jekyll/molecule/image.rb

@@ -0,0 +1,105 @@
+require 'set'
+
+require 'distorted/image'
+require 'distorted-jekyll/static/image'
+
+module Jekyll
+  module DistorteD
+    module Molecule
+      module Image
+
+        # Reference these instead of reassigning them. Consistency is mandatory.
+        MEDIA_TYPE = Cooltrainer::DistorteD::Image::MEDIA_TYPE
+        MIME_TYPES = Cooltrainer::DistorteD::Image::MIME_TYPES
+
+        ATTRS = Cooltrainer::DistorteD::Image::ATTRS
+        ATTRS_DEFAULT = Cooltrainer::DistorteD::Image::ATTRS_DEFAULT
+        ATTRS_VALUES = Cooltrainer::DistorteD::Image::ATTRS_VALUES
+
+
+        # Returns the filename we should use in the oldschool <img> tag
+        # as a fallback for <picture> sources. This file should be a cropped
+        # variation, the same MIME::Type as the input media, with the largest
+        # resolution possible.
+        # Failing that, use the filename of the original media.
+        # TODO: Handle situations when the input media_type is not in the
+        # Set of output media_types. We should pick the largest cropped variation
+        # of any type in that case.
+        def fallback_img
+          biggest_ver = nil
+
+          # Computes a Set of non-nil MIME::Type.sub_types for all MIME::Types
+          # detected for the original media file.
+          sub_types = @mime.keep_if{ |m|
+            m.media_type == self.singleton_class.const_get(:MEDIA_TYPE)
+          }.map { |m|
+            m.sub_type
+          }.compact.to_set
+          files.keep_if{|f| f.key?(:width) or f.key?(:height)}.each{ |f|
+            if sub_types.include?(f[:type]&.sub_type)
+              if biggest_ver
+                if f[:width] > biggest_ver[:width]
+                  biggest_ver = f
+                end
+              else
+                biggest_ver = f
+              end
+            end
+          }
+          # Return the filename of the biggest matched variation,
+          # otherwise use the original filename.
+          biggest_ver&.dig(:name) || @name
+        end
+
+        def outer_limits(*keys)
+          config = super
+          if config.empty?
+            Set[{
+              tag: :full,
+              crop: :none,
+            }]
+          else
+            config
+          end
+        end
+
+        def render_to_output_buffer(context, output)
+          super
+          begin
+            # Liquid doesn't seem able to reference symbolic keys,
+            # so convert everything to string for template.
+            # Remove full-size images from <sources> list before generating.
+            # Those should only be linked to, not displayed.
+            filez = files.keep_if{|f| f.key?(:width) or f.key?(:height)}.map{ |f|
+              f.transform_values(&:to_s).transform_keys(&:to_s)
+            }
+
+            output << parse_template.render({
+              'name' => @name,
+              'path' => @dd_dest,
+              'alt' => attr_value(:alt),
+              'title' => attr_value(:title),
+              'href' => attr_value(:href),
+              'caption' => attr_value(:caption),
+              'loading' => attr_value(:loading),
+              'sources' => filez,
+              'fallback_img' => fallback_img,
+            })
+          rescue Liquid::SyntaxError => l
+            unless Jekyll.env == 'production'.freeze
+              output << parse_template(name: 'error_code'.freeze).render({
+                'message' => l.message,
+              })
+            end
+          end
+          output
+        end
+
+        def static_file(*args)
+          Jekyll::DistorteD::Static::Image.new(*args)
+        end
+
+      end
+    end
+  end
+end

data/lib/distorted-jekyll/molecule/last-resort.rb

@@ -0,0 +1,54 @@
+require 'set'
+
+require 'distorted-jekyll/static/lastresort'
+
+module Jekyll
+  module DistorteD
+    module Molecule
+      module LastResort
+
+        MEDIA_TYPE = 'lastresort'.freeze
+
+        # HACK HACK HACK
+        # Image Maps are a '90s Web relic, but I'm using this
+        # MIME::Type here to represent the generic fallback state.
+        # The MIME::Types library doesn't let me register custom
+        # types without shipping an entire custom type database,
+        # so I'm just going to use this since it will never
+        # be detected for a real file, and if it does then it will
+        # get an <img> tag anyway :)
+        MIME_TYPES = MIME::Types['application/x-imagemap'].to_set
+
+        ATTRS = Set[:alt, :title, :href, :caption]
+        ATTRS_DEFAULT = {}
+        ATTRS_VALUES = {}
+
+        def render_to_output_buffer(context, output)
+          super
+          begin
+            output << parse_template.render({
+              'name' => @name,
+              'basename' => File.basename(@name, '.*'),
+              'path' => @url,
+              'alt' => attr_value(:alt),
+              'title' => attr_value(:title),
+              'href' => attr_value(:href),
+              'caption' => attr_value(:caption),
+            })
+          rescue Liquid::SyntaxError => l
+            unless Jekyll.env == 'production'.freeze
+              output << parse_template(name: 'error_code'.freeze).render({
+                'message' => l.message,
+              })
+            end
+          end
+          output
+        end
+
+        def static_file(*args)
+          Jekyll::DistorteD::Static::LastResort.new(*args)
+        end
+      end
+    end
+  end
+end

data/lib/distorted-jekyll/molecule/pdf.rb

@@ -0,0 +1,88 @@
+require 'set'
+
+require 'distorted/pdf'
+require 'distorted-jekyll/static/pdf'
+
+module Jekyll
+  module DistorteD
+    module Molecule
+      module PDF
+
+        # Reference these instead of reassigning them. Consistency is mandatory.
+        MEDIA_TYPE = Cooltrainer::DistorteD::PDF::MEDIA_TYPE
+        SUB_TYPE = Cooltrainer::DistorteD::PDF::SUB_TYPE
+        MIME_TYPES = Cooltrainer::DistorteD::PDF::MIME_TYPES
+
+        PDF_OPEN_PARAMS = Cooltrainer::DistorteD::PDF::PDF_OPEN_PARAMS
+        ATTRS = Cooltrainer::DistorteD::PDF::ATTRS
+        ATTRS_DEFAULT = Cooltrainer::DistorteD::PDF::ATTRS_DEFAULT
+        ATTRS_VALUES = Cooltrainer::DistorteD::PDF::ATTRS_VALUES
+
+
+        def render_to_output_buffer(context, output)
+          super
+          begin
+            # TODO: iOS treats our <object> like an <img>,
+            # showing only the first page with transparency and stretched to the
+            # size of the container element.
+            # We will need something like PDF.js in an <iframe> to handle this.
+
+            # Generate a Hash of our PDF Open Params based on any given to the Liquid tag
+            # and any loaded from the defaults.
+            # https://www.adobe.com/content/dam/acom/en/devnet/acrobat/pdfs/pdf_open_parameters.pdf
+            pdf_open_params = PDF_OPEN_PARAMS.map{ |p|
+              if ATTRS_VALUES.dig(p) == Cooltrainer::DistorteD::PDF::BOOLEAN_SET
+                # Support multiple ways people might want to express a boolean
+                if Set[0, '0'.freeze, false, 'false'.freeze].include?(attr_value(p))
+                  [p, '0'.freeze]
+                elsif Set[1, '1'.freeze, true, 'true'.freeze].include?(attr_value(p))
+                  [p, '1'.freeze]
+                end
+              else
+                [p, attr_value(p)]
+              end
+            }.to_h
+
+            # Generate the URL fragment version of the PDF Open Params.
+            # This would be difficult / impossible to construct within Liquid
+            # from the individual variables, so let's just do it out here.
+            pdf_open_params_url = pdf_open_params.keep_if{ |p,v|
+              v != nil && v != ""
+            }.map{ |k,v|
+              # The PDF Open Params docs specify `search` should be quoted.
+              if k == :search
+                "#{k}=\"#{v}\""
+              else
+                "#{k}=#{v}"
+              end
+            }.join('&')
+            Jekyll.logger.debug("#{@name} PDF Open Params:", "#{pdf_open_params} #{"\u21e8".encode('utf-8').freeze} #{pdf_open_params_url}")
+
+            output << parse_template.render({
+              'name' => @name,
+              'path' => @dd_dest,
+              'alt' => attr_value(:alt),
+              'title' => attr_value(:title),
+              'height' => attr_value(:height),
+              'width' => attr_value(:width),
+              'caption' => attr_value(:caption),
+              'pdf_open_params' => pdf_open_params_url,
+            })
+          rescue Liquid::SyntaxError => l
+            unless Jekyll.env == 'production'.freeze
+              output << parse_template(name: 'error_code'.freeze).render({
+                'message' => l.message,
+              })
+            end
+          end
+          output
+        end
+
+        def static_file(*args)
+          Jekyll::DistorteD::Static::PDF.new(*args)
+        end
+
+      end  # PDF
+    end  # Molecule
+  end  # DistorteD
+end  # Jekyll