distorted-jekyll 0.5.3 → 0.6.0

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

@@ -0,0 +1,62 @@
+require 'set'
+
+require 'distorted/molecule/font'
+
+
+module Jekyll
+  module DistorteD
+    module Molecule
+      module Font
+
+        include Cooltrainer::DistorteD::Font
+
+        def render_to_output_buffer(context, output)
+          super
+          begin
+            filez = files.keep_if{ |f|
+              # Strip out all non-displayable media-types, e.g. the actual text/whatever.
+              f.key?(:type) && f&.dig(:type)&.media_type == 'image'.freeze
+            }.keep_if{ |f|
+              # Strip out full-size images (will have `nil`) — only display thumbnail vers
+              f.key?(:width) or f.key?(:height)
+            }.map{ |f|
+              # Stringify to make Liquid happy
+              f.transform_values(&:to_s).transform_keys(&:to_s)
+            }
+            output << parse_template.render({
+              'name' => @name,
+              'path' => @relative_dest,
+              'alt' => abstract(:alt),
+              'title' => abstract(:title),
+              '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
+
+        # Return the filename of the most-compatible output image
+        # for use as the fallback <img> tag inside our <picture>.
+        def fallback_img
+          best_ver = nil
+          files.keep_if{|f| f.key?(:type) && f&.dig(:type)&.media_type == 'image'.freeze}.each{ |f|
+            # PNG > WebP
+            if f&.dig(:type)&.sub_type == 'png'.freeze || best_ver.nil?
+              best_ver = f
+            end
+          }
+          # Return the filename of the biggest matched variation,
+          # otherwise use the original filename.
+          best_ver&.dig(:name) || @name
+        end
+
+      end  # Font
+    end  # Molecule
+  end  # DistorteD
+end  # Jekyll

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

@@ -0,0 +1,94 @@
+require 'set'
+
+require 'distorted/molecule/image'
+
+
+module Jekyll
+  module DistorteD
+    module Molecule
+      module Image
+
+        include Cooltrainer::DistorteD::Image
+
+        # 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 = type_mars.keep_if{ |m|
+            m.media_type == 'image'.freeze
+          }.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' => @relative_dest,
+              'alt' => abstract(:alt),
+              'title' => abstract(:title),
+              'href' => abstract(:href),
+              'caption' => abstract(:caption),
+              'loading' => abstract(: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
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,51 @@
+require 'set'
+
+require 'distorted/checking_you_out'
+require 'distorted/injection_of_love'
+
+module Jekyll
+  module DistorteD
+    module Molecule
+      module LastResort
+
+
+        LOWER_WORLD = CHECKING::YOU::IN('application/x.distorted.last-resort')
+
+        ATTRIBUTES = Set[:alt, :title, :href, :caption]
+        ATTRIBUTES_DEFAULT = {}
+        ATTRIBUTES_VALUES = {}
+
+        # This is one of the few render methods that will be defined in JekyllLand.
+        define_method(CHECKING::YOU::IN('application/x.distorted.last-resort').first.distorted_method) { |*a, **k, &b|
+          copy_file(*a, **k, &b)
+        }
+
+        include Cooltrainer::DistorteD::InjectionOfLove
+
+
+        def render_to_output_buffer(context, output)
+          super
+          begin
+            output << parse_template.render({
+              'name' => @name,
+              'basename' => File.basename(@name, '.*'),
+              'path' => @relative_dest,
+              'alt' => abstract(:alt),
+              'title' => abstract(:title),
+              'href' => abstract(:href),
+              'caption' => abstract(: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
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,79 @@
+require 'set'
+
+require 'distorted/molecule/pdf'
+
+
+module Jekyll
+  module DistorteD
+    module Molecule
+      module PDF
+
+        include Cooltrainer::DistorteD::PDF
+
+
+        # 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
+        def pdf_open_params
+          PDF_OPEN_PARAMS.map{ |p|
+            if ATTRIBUTES_VALUES.dig(p) == BOOLEAN_ATTR_VALUES
+              # Support multiple ways people might want to express a boolean
+              if Set[0, '0'.freeze, false, 'false'.freeze].include?(abstract(p))
+                [p, '0'.freeze]
+              elsif Set[1, '1'.freeze, true, 'true'.freeze].include?(abstract(p))
+                [p, '1'.freeze]
+              end
+            else
+              [p, abstract(p)]
+            end
+          }.to_h
+        end
+
+        # 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.
+        def 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('&')
+        end
+
+        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.
+
+            output << parse_template.render({
+              'name' => @name,
+              'path' => @relative_dest,
+              'alt' => abstract(:alt),
+              'title' => abstract(:title),
+              'height' => abstract(:height),
+              'width' => abstract(:width),
+              'caption' => abstract(: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
+
+      end  # PDF
+    end  # Molecule
+  end  # DistorteD
+end  # Jekyll

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

@@ -0,0 +1,47 @@
+require 'set'
+
+require 'distorted/molecule/svg'
+
+
+module Jekyll
+  module DistorteD
+    module Molecule
+      module SVG
+
+        include Cooltrainer::DistorteD::SVG
+
+        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.
+            # Not stripping :full tags like Image because all of our
+            # SVG variations will be full-res for now.
+            filez = files.map{ |f|
+              f.transform_values(&:to_s).transform_keys(&:to_s)
+            }
+            output << parse_template.render({
+              'name' => @name,
+              'path' => @relative_dest,
+              'alt' => abstract(:alt),
+              'title' => abstract(:title),
+              'href' => abstract(:href),
+              'caption' => abstract(:caption),
+              'loading' => abstract(:loading),
+              'sources' => filez,
+              'fallback_img' => @name,
+            })
+          rescue Liquid::SyntaxError => l
+            unless Jekyll.env == 'production'.freeze
+              output << parse_template(name: 'error_code'.freeze).render({
+                'message' => l.message,
+              })
+            end
+          end
+          output
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,62 @@
+require 'set'
+
+require 'distorted/molecule/text'
+
+
+module Jekyll
+  module DistorteD
+    module Molecule
+      module Text
+
+        include Cooltrainer::DistorteD::Text
+
+        def render_to_output_buffer(context, output)
+          super
+          begin
+            filez = files.keep_if{ |f|
+              # Strip out all non-displayable media-types, e.g. the actual text/whatever.
+              f.key?(:type) && f&.dig(:type)&.media_type == 'image'.freeze
+            }.keep_if{ |f|
+              # Strip out full-size images (will have `nil`) — only display thumbnail vers
+              f.key?(:width) or f.key?(:height)
+            }.map{ |f|
+              # Stringify to make Liquid happy
+              f.transform_values(&:to_s).transform_keys(&:to_s)
+            }
+            output << parse_template.render({
+              'name' => @name,
+              'path' => @relative_dest,
+              'alt' => abstract(:alt),
+              'title' => abstract(:title),
+              '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
+
+        # Return the filename of the most-compatible output image
+        # for use as the fallback <img> tag inside our <picture>.
+        def fallback_img
+          best_ver = nil
+          files.keep_if{|f| f.key?(:type) && f&.dig(:type)&.media_type == 'image'.freeze}.each{ |f|
+            # PNG > WebP
+            if f&.dig(:type)&.sub_type == 'png'.freeze || best_ver.nil?
+              best_ver = f
+            end
+          }
+          # Return the filename of the biggest matched variation,
+          # otherwise use the original filename.
+          best_ver&.dig(:name) || @name
+        end
+
+      end  # Text
+    end  # Molecule
+  end  # DistorteD
+end  # Jekyll

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

@@ -0,0 +1,85 @@
+require 'distorted/molecule/video'
+
+
+module Jekyll
+  module DistorteD
+    module Molecule
+      module Video
+
+        include Cooltrainer::DistorteD::Video
+
+        def render_to_output_buffer(context, output)
+          super
+          begin
+            output << parse_template.render({
+              'name' => @name,
+              'basename' => File.basename(@name, '.*'),
+              'path' => @url,
+              'caption' => abstract(: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
+
+        # Return a Set of extant video variations due to inability/unwillingness
+        # to exactly predict GStreamer's HLS/DASH segment output naming
+        # even if we are controlling all variables like segment length etc.
+        # This implementation may give stale segments but will at least speed
+        # up site generation by not having to regenerate the video every time.
+        def destinations(dest)
+          wanted = Set[]
+          if Dir.exist?(File.join(dest, @relative_dest))
+            hls_dir = File.join(dest, @relative_dest, "#{basename}.hls")
+            if Dir.exist?(hls_dir)
+              wanted.merge(Dir.entries(hls_dir).to_set.map{|f| File.join(hls_dir, f)})
+            end
+          end
+          wanted
+        end
+
+        def modified?
+          # We can't use the standard Static::State#modified? here until
+          # I figure out how to cleanly get a duplicate of what would be
+          # the generated filenames from GStreamer's sink.
+          #
+          # For now for the sake of speeding up my site generation
+          # I'll assume not-modified that if the output variant (e.g. DASH/HLS)
+          # container dir exists and contains at least two files:
+          # the playlist and at least one segment.
+          #
+          # Hacky HLS-only right now until dashsink2 lands in upstream Gst.
+          #
+          # Assume modified for the sake of freshness :)
+          modified = true
+
+          site_dest = Jekyll::DistorteD::Floor::config(:destination).to_s
+          if Dir.exist?(site_dest)
+
+            dd_dest = File.join(site_dest, @relative_dest)
+            if Dir.exist?(dd_dest)
+
+              hls_dir = File.join(dd_dest, "#{basename}.hls")
+              if Dir.exist?(hls_dir)
+                need_filez = Set["#{basename}.m3u8"]
+                var_filez = Dir.entries(hls_dir).to_set
+                if need_filez.subset?(var_filez) and var_filez.count > 2
+                  modified = false
+                end
+              end
+
+            end
+          end
+          Jekyll.logger.debug("#{@name} modified?",  modified)
+          modified
+        end
+
+      end
+    end
+  end
+end