distorted-jekyll 0.5.6 → 0.5.7

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

@@ -0,0 +1,59 @@
+require 'set'
+
+require 'distorted/svg'
+require 'distorted-jekyll/static/svg'
+
+module Jekyll
+  module DistorteD
+    module Molecule
+      module SVG
+
+        # Reference these instead of reassigning them. Consistency is mandatory.
+        MEDIA_TYPE = Cooltrainer::DistorteD::SVG::MEDIA_TYPE
+        SUB_TYPE = Cooltrainer::DistorteD::SVG::SUB_TYPE
+        MIME_TYPES = Cooltrainer::DistorteD::SVG::MIME_TYPES
+
+        ATTRS = Cooltrainer::DistorteD::SVG::ATTRS
+        ATTRS_DEFAULT = Cooltrainer::DistorteD::SVG::ATTRS_DEFAULT
+        ATTRS_VALUES = Cooltrainer::DistorteD::SVG::ATTRS_VALUES
+
+
+        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' => @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' => @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
+
+        def static_file(*args)
+          Jekyll::DistorteD::Static::SVG.new(*args)
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,74 @@
+require 'set'
+
+require 'distorted/text'
+require 'distorted-jekyll/static/text'
+
+module Jekyll
+  module DistorteD
+    module Molecule
+      module Text
+
+        DRIVER = Cooltrainer::DistorteD::Text
+
+        MEDIA_TYPE = DRIVER::MEDIA_TYPE
+        MIME_TYPES = DRIVER::MIME_TYPES
+
+        ATTRS = DRIVER::ATTRS
+        ATTRS_DEFAULT = DRIVER::ATTRS_DEFAULT
+        ATTRS_VALUES = DRIVER::ATTRS_VALUES
+
+
+        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' => @dd_dest,
+              'alt' => attr_value(:alt),
+              'title' => attr_value(: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
+
+        def static_file(*args)
+          Jekyll::DistorteD::Static::Text.new(*args)
+        end
+
+      end  # Text
+    end  # Molecule
+  end  # DistorteD
+end  # Jekyll

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

@@ -0,0 +1,43 @@
+require 'distorted/video'
+require 'distorted-jekyll/static/video'
+
+module Jekyll
+  module DistorteD
+    module Molecule
+      module Video
+
+        # Reference these instead of reassigning them. Consistency is mandatory.
+        MEDIA_TYPE = Cooltrainer::DistorteD::Video::MEDIA_TYPE
+        MIME_TYPES = Cooltrainer::DistorteD::Video::MIME_TYPES
+
+        ATTRS = Cooltrainer::DistorteD::Video::ATTRS
+        ATTRS_DEFAULT = Cooltrainer::DistorteD::Video::ATTRS_DEFAULT
+        ATTRS_VALUES = Cooltrainer::DistorteD::Video::ATTRS_VALUES
+
+        def render_to_output_buffer(context, output)
+          super
+          begin
+            output << parse_template.render({
+              'name' => @name,
+              'basename' => File.basename(@name, '.*'),
+              'path' => @url,
+              '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::Video.new(*args)
+        end
+
+      end
+    end
+  end
+end

data/lib/distorted-jekyll/monkey_business/jekyll/cleaner.rb

@@ -0,0 +1,54 @@
+require 'set'
+
+module Jekyll
+  # Handles the cleanup of a site's destination before it is built or re-built.
+  class Cleaner
+
+    # Private: The list of files to be created when site is built.
+    #
+    # Returns a Set with the file paths
+    #
+    # Monkey-patch this to look for DD's unique `destinations` which is similar
+    # to the original `destination` method except it returns a Set of destination
+    # paths instead of a single destination path.
+    # Do the patch with `define_method` instead of just `def` because the block's
+    # closure of the local scope lets it carry a binding to the original overriden
+    # method which I use to bail out iff the monkey-patch fails.
+    # This is an attempt to avoid breaking future Jekyll versions as much as
+    # possible, since any Exception in the monkey-patched code will just cause
+    # the original Jekyll implementation to be called instead.
+    # The new worst case scenario is slow site builds due to media variation generation!
+    #
+    # If a StaticFile responds to `destinations` then use it and merge the result.
+    # I'm defining my own separate method for multi-destinations for now,
+    # but I also considered just overriding `destination` to return the Set and
+    # then doing this as a one-liner that handles either case (single or
+    # multiple destinations) with `files.merge(Set[*(item.destination(site.dest))])`.
+    # This is the safer choice though since we avoid changing the outout type of the
+    # regular `:destination` method.
+    the_old_new_thing = instance_method(:new_files)
+    define_method(:new_files) do
+      begin
+        @new_files ||= Set.new.tap do |files|
+          site.each_site_file { |item|
+            if item.respond_to?(:destinations)
+              files.merge(item.destinations(site.dest))
+            elsif item.respond_to?(:destination)
+              files << item.destination(site.dest)
+            else
+              # Something unrelated has gone wrong for us to end up sending
+              # `destination` to something that doesn't respond to it.
+              # We should fall back to the original implementation of `new_files`
+              # in this case so the failure doesn't appear to be here.
+              the_old_new_thing.bind(self).()
+            end
+          }
+        end
+      rescue RuntimeError => e
+        Jekyll.logger.warn('DistorteD', "Monkey-patching Jekyll::Cleaner#new_files failed: #{e.message}")
+        Jekyll.logger.debug('DistorteD', "Monkey-patched Jekyll::Cleaner#new_files backtrace: #{e.backtrace}")
+        the_old_new_thing.bind(self).()
+      end
+    end
+  end  # Cleaner
+end  # Jekyll

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

@@ -0,0 +1,42 @@
+require 'fileutils'
+require 'set'
+
+require 'distorted/font'
+require 'distorted-jekyll/static/text'
+
+module Jekyll
+  module DistorteD
+    module Static
+      class Font < 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
+
+
+        # dest: String realpath to `_site` directory
+        def write(dest)
+          orig_dest = destination(dest)
+
+          return false if !modified?
+          self.class.mtimes[path] = mtime
+
+          @distorted = DRIVER.new(
+            path,
+            demo: attr_value(:title),
+          )
+          FileUtils.cp(path, File.join(dd_dest(dest), @name))
+
+          super
+
+        end
+
+      end  # Text
+    end  # Static
+  end  # DistorteD
+end  # Jekyll

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

@@ -0,0 +1,55 @@
+require 'fileutils'
+require 'set'
+
+require 'distorted/image'
+require 'distorted-jekyll/static/state'
+
+module Jekyll
+  module DistorteD
+    module Static
+      class Image < Jekyll::DistorteD::Static::State
+
+        DRIVER = Cooltrainer::DistorteD::Image
+
+        MEDIA_TYPE = DRIVER::MEDIA_TYPE
+        MIME_TYPES = DRIVER::MIME_TYPES
+
+        ATTRS = DRIVER::ATTRS
+        ATTRS_DEFAULT = DRIVER::ATTRS_DEFAULT
+        ATTRS_VALUES = DRIVER::ATTRS_VALUES
+
+
+        # dest: string realpath to `_site_` directory
+        def write(dest)
+          return false if File.exist?(path) && !modified?
+          self.class.mtimes[path] = mtime
+
+          # Create any directories to the depth of the intended destination.
+          FileUtils.mkdir_p(dd_dest(dest))
+
+          unless defined? @distorted
+            @distorted = DRIVER.new(path)
+          end
+
+          Jekyll.logger.debug(@tag_name, "Rotating #{@name} if tagged.")
+          @distorted.rotate(angle: :auto)
+
+          # Save every desired variation of this image.
+          # This will be a Set of Hashes each describing the name, type,
+          # dimensions, attributes, etc of each output variation we want.
+          # Full-size outputs will have the special tag `:full`.
+          for variation in files
+            if DRIVER::MIME_TYPES.include?(variation&.dig(:type))
+              filename = File.join(dd_dest(dest), variation&.dig(:name) || @name)
+              Jekyll.logger.debug('DistorteD Writing:', filename)
+              @distorted.save(filename, width: variation&.dig(:width), crop: variation&.dig(:crop))
+            end
+          end
+
+          true
+        end
+
+      end  # Image
+    end  # Static
+  end  # DistorteD
+end  # Jekyll

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

@@ -0,0 +1,28 @@
+require 'fileutils'
+require 'set'
+
+require 'distorted-jekyll/static/state'
+
+module Jekyll
+  module DistorteD
+    module Static
+      class LastResort < Jekyll::DistorteD::Static::State
+
+        # dest: string realpath to `_site_` directory
+        def write(dest)
+          return false if File.exist?(path) && !modified?
+          self.class.mtimes[path] = mtime
+
+          # Create any directories to the depth of the intended destination.
+          FileUtils.mkdir_p(dd_dest(dest))
+
+          Jekyll.logger.debug(@tag_name, "Copying #{@name} to #{dd_dest(dest)}")
+          FileUtils.cp(path, File.join(dd_dest(dest), @name))
+
+          true
+        end
+
+      end  # Image
+    end  # Static
+  end  # DistorteD
+end  # Jekyll

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

@@ -0,0 +1,53 @@
+require 'fileutils'
+require 'set'
+
+require 'distorted/pdf'
+require 'distorted-jekyll/static/pdf'
+
+
+module Jekyll
+  module DistorteD
+    module Static
+      class PDF < Jekyll::DistorteD::Static::State
+
+        DRIVER = Cooltrainer::DistorteD::PDF
+
+        MEDIA_TYPE = DRIVER::MEDIA_TYPE
+        SUB_TYPE = DRIVER::SUB_TYPE
+        MIME_TYPES = DRIVER::MIME_TYPES
+
+        ATTRS = DRIVER::ATTRS
+        ATTRS_DEFAULT = DRIVER::ATTRS_DEFAULT
+        ATTRS_VALUES = DRIVER::ATTRS_VALUES
+
+
+        # dest: string realpath to `_site_` directory
+        def write(dest)
+          return false if File.exist?(path) && !modified?
+          self.class.mtimes[path] = mtime
+
+          # Create any directories to the depth of the intended destination.
+          FileUtils.mkdir_p(dd_dest(dest))
+
+          for variation in files
+            if DRIVER::MIME_TYPES.include?(variation[:type])
+              pdf_dest_path = File.join(dd_dest(dest), variation[:name])
+
+              if true  # TODO: Make this configurable
+                Jekyll.logger.debug(@tag_name, "Optimizing #{@name} and copying to #{dd_dest(dest)}")
+                # TODO: Make optimizations/plugins configurable
+                DRIVER::optimize(path, pdf_dest_path)
+              else
+                Jekyll.logger.debug(@tag_name, "Copying #{@name} to #{dd_dest(dest)}")
+                FileUtils.cp(path, pdf_dest_path)
+              end
+            end
+          end
+
+          true
+        end
+
+      end  # PDF
+    end  # Static
+  end  # DistorteD
+end  # Jekyll

data/lib/distorted-jekyll/static/state.rb

@@ -0,0 +1,141 @@
+require 'set'
+
+require 'distorted-jekyll/molecule/abstract'
+
+
+module Jekyll
+  module DistorteD
+    module Static
+      class State < Jekyll::StaticFile
+
+      include Jekyll::DistorteD::Molecule::Abstract
+
+        def initialize(
+          site,
+          base,
+          dir,
+          name,
+          mime,
+          attrs,
+          dd_dest,
+          url,
+          collection: nil
+        )
+          # e.g. 'DistorteD::Static::Image' or 'DistorteD::Static::Video'
+          @tag_name = self.class.name.split('::').drop(1).join('::').to_sym.freeze
+
+          # String path to Jekyll site root
+          @base = base
+
+          # String container dir (under `base`) of original file
+          @dir = dir
+
+          # String filename of original file
+          @name = name
+
+          # Union Set of MIME::Types between the original media file
+          # and the plugged MediaMolecule.
+          @mime = mime
+
+          # Attributes provided to our Liquid tag
+          @attrs = attrs
+
+          # String path to media generation output dir
+          # under Site.dest (which is currently unknown)
+          @dd_dest = dd_dest
+
+          # String destination URL for the post/page on which the media appears.
+          @url = url
+
+          # Hello yes
+          Jekyll.logger.debug(@tag_name, "#{base}/#{dir}/#{name} -> #{url}})")
+
+          # Construct Jekyll::StaticFile with only the args it takes:
+          super(
+            site,
+            base,
+            dir,
+            name,
+          )
+        end
+
+        def basename
+          File.basename(@name, '.*')
+        end
+
+        def extname
+          File.extname(@name)
+        end
+
+        # Returns the to-be-written path of a single standard StaticFile.
+        # The value returned by this method is only the 'main' or 'original'
+        # (even if modified somehow) file and does not include the
+        # path/filenames of any variations.
+        # This method will be called by jekyll/lib/cleaner#new_files
+        # to generate the list of files that need to be build or rebuilt
+        # for a site. For this reason, this method shouldn't do any kind
+        # of checking the real filesystem, since e.g. its URL-based
+        # destdir might not exist yet if the Site.dest is completely blank.
+        def destination(dest)
+          File.join(dest, @dd_dest, @name)
+        end
+
+        # Return the absolute path to the top-level destination directory
+        # of the currently-working media. This will usually be the same path
+        # as the Jekyll post/page's generated HTML output.
+        def dd_dest(dest)
+          File.join(dest, @dd_dest)
+        end
+
+        # This method will be called by our monkey-patched Jekyll::Cleaner#new_files
+        # in place of the single-destination method usually used.
+        # This allows us to tell Jekyll about more than a single file
+        # that should be kept when regenerating the site.
+        # This makes DistorteD fast!
+        def destinations(dest)
+          # TODO: Make outputting the original file optional. Will need to change
+          # templates, `modified?`s, and `generate`s to do that.
+          filenames.map{|f| File.join(dd_dest(dest), f)} << destination(dest)
+        end
+
+        # HACK HACK HACK
+        # Jekyll does not pass this method a site.dest like it does write() and
+        # others, but I want to be able to short-circuit here if all the
+        # to-be-generated files already exist.
+        def modified?
+          # 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 = dd_dest(site_dest)
+            if Dir.exist?(dd_dest)
+
+              # TODO: Make outputting the original file conditional.
+              # Doing that will require changing the default href handling
+              # in the template, Jekyll::DistorteD::Static::State.destinations,
+              # as well as Cooltrainer::DistorteD::Image.generate
+              wanted_files = Set[@name].merge(filenames)
+              extant_files = Dir.entries(dd_dest).to_set
+
+              # TODO: Make this smarter. It's not enough that all the generated
+              # filenames should exist. Try a few more ways to detect subtler
+              # "changes to the source file since generation of variations.
+              if wanted_files.subset?(extant_files)
+                Jekyll.logger.debug(@name, "All variations present: #{wanted_files}")
+                modified = false
+              else
+                Jekyll.logger.debug(@name, "Missing variations: #{wanted_files - extant_files}")
+              end
+
+            end  # dd_dest.exists?
+          end  # site_dest.exists?
+          Jekyll.logger.debug("#{@name} modified?",  modified)
+          return modified
+        end
+
+      end  # state
+    end  # Static
+  end  # DistorteD
+end  # Jekyll