distorted-jekyll 0.6.0 → 0.7.0

data/lib/distorted-jekyll/the_setting_sun.rb

@@ -0,0 +1,179 @@
+require 'yaml'
+require 'jekyll'
+require 'set'
+
+require 'distorted/monkey_business/hash'
+require 'distorted/checking_you_out'
+
+
+module Jekyll; end
+module Jekyll::DistorteD
+
+  # Top-level config key (once stringified) for Jekyll and Default YAML.
+  CONFIG_ROOT_KEY = :distorted
+
+  # Filename for default config YAML. Should be a sibling of this file.
+  # Don't move this file or the YAML defaults without changing this.
+  DEFAULT_CONFIG_FILE_NAME = '_config_default.yml'.freeze
+  DEFAULT_CONFIG_PATH = File.join(File.dirname(__FILE__), DEFAULT_CONFIG_FILE_NAME).freeze
+
+  # Separator character for pretty-printing config hierarchy.
+  PP_SEPARATOR = "\u2B9E ".encode('utf-8').freeze
+
+  # Path separator is almost always '/' internally, but support
+  # ALT_SEPARATOR platforms too.
+  # On Lunix - Ruby 2.7:
+  # irb(main):003:0> File::ALT_SEPARATOR
+  # => nil
+  # irb(main):004:0> File::SEPARATOR
+  # => "/"
+  PATH_SEPARATOR = (File::ALT_SEPARATOR || File::SEPARATOR).freeze
+
+  # Any any attr value will get a to_sym if shorter than this
+  # totally arbitrary length, or if the attr key is in the plugged
+  # Molecule's set of attrs that take only a defined set of values.
+  # My chosen boundary length fits all of the outer-limit tag names I use,
+  # like 'medium'. It fits the longest value of Vips::Interesting too,
+  # though `crop` will be symbolized based on the other condition.
+  ARBITRARY_ATTR_SYMBOL_STRING_LENGTH_BOUNDARY = 13
+
+
+  # Memoization Hash for all settings data so we don't have to reprocess it for additional lookups.
+  def self.memories
+    @@memories ||= Hash.new
+  end
+
+  # Memoize the complete default-config to avoid touching the filesystem more than once.
+  def self.distorted_default_settings
+    @@distorted_default_settings ||= YAML.load(File.read(DEFAULT_CONFIG_PATH))
+  end
+
+  # Stores a given settings path/value to our memoization Hash
+  # after normalizing the values, so we can be less strict about
+  # the YAML formats we accept because YAML is easy to mess up.
+  def self.memories!(key_paths, sources)
+    # Avoid redundant memory transformations for keys we already have.
+    # NOTE: This assumes settings will never change over the execution lifetime
+    # of any single DistorteD instance.
+    return self.memories.dig(key_paths) if self.memories.has_key?(key_paths)
+    # Shorten long path members (any with underscores) so long log lines
+    # don't get misaligned easily.
+    # Don't log glob paths — those containing as asterisk (*).
+    log_key = key_paths.detect { |path| path.none?(:"*") }.map(&:to_s).map{ |component|
+      component.include?('_'.freeze) ? component.split('_'.freeze).map(&:chr).join('_'.freeze) : component
+    }.join(PP_SEPARATOR.to_s).freeze
+
+    # Try one one source Proc at a time, looking for every settings-path within it.
+    # If *any* config data is returned from a source we stop processing additional sources.
+    # This is to allow for default-config overriding because otherwise if we always
+    # use the default config it would be impossible to turn off any of that data.
+    memory = sources.reduce(nil) { |out, source|
+      key_paths.each { |key_path|
+        case new = source.call(key_path)
+        when [out, new].all? { |c| c&.respond_to?(:update) } then out.update(new)
+        when [out, new].all? { |c| c&.respond_to?(:merge)  } then out.merge(new)
+        when [out, new].all? { |c| c&.respond_to?(:concat) } then out.concat(new)
+        else out = new
+        end
+      }
+      Jekyll.logger.debug(log_key, out) unless out.nil?
+      break out unless out.nil?
+    }
+
+    # Most of our settings data comes from a YAML source,
+    # either Jekyll's config or our Gem's built-in defaults,
+    # so we should do some normalization before memoizing.
+    memory = case memory
+    when Array
+      # Transform Array members, then transform the Array itself to a Set to dedupe.
+      memory.map{ |array_member|
+        case array_member
+        # Symbolize Hash keys as well as String values if it has any.
+        when Hash then array_member.transform_keys!(&:to_sym).transform_values!{ |hash_value|
+          case hash_value
+          when String then (hash_value.length <= ARBITRARY_ATTR_SYMBOL_STRING_LENGTH_BOUNDARY) ? hash_value.to_sym : hash_value
+          else hash_value
+          end
+        }
+        # For sub-Arrays of our Array, Symbolize their keys
+        when Array then array_member.map(&:to_sym)
+        # Otherwise just pass it as it was loaded from YAML
+        else array_member
+        end
+      }.to_set
+    when Hash
+      # Ruby::YAML::load will parse YAML Sets (the `?` list-like syntax)
+      # as a Ruby Hash with all-nil values (the internal implementation of Set)
+      # unless we give our YAML files some sugar telling it what class we want:
+      # https://rhnh.net/2011/01/31/yaml-tutorial/
+      #
+      # I wouldn't mind maintaining the default-settings YAML file with those tags,
+      # but that would make it really tedious and error-prone in the Jekyll config
+      # if/when it comes time to override any defaults, so I em ignoring that capability
+      # and doing my own normalization here in this method.
+      memory.values.all?{|v| v.nil?} ? memory.keys.map(&:to_sym).to_set : memory.transform_keys(&:to_sym)
+    else memory
+    end
+    # Use the `key_paths` Array[Array[String] as the Hash key directly to avoid the complexity
+    # of trying to splat it and nest the keys in layers of other Hashes.
+    self.memories.store(key_paths, memory)
+  end
+
+  # Generic main config-loading function that will search, in order:
+  # - The memoized pre-transformed config data store in-memory.
+  # - Jekyll's Site config, for a passed-in site or for the default site.
+  # - DistorteD's Gem-internal default config YAML.
+  #
+  # Optionally provide a class to be used as a fallback for missing keys.
+  def self.the_setting_sun(*keys, site: Jekyll.sites.first, **kw)
+    return nil if keys.empty?
+
+    # Normalize given keys into an Array[Array[<whatever>] given these rules:
+    #
+    # - If all of our given keys are Arrays, assume each Array is a separate settings-path
+    #   and leave them alone, e.g. [['jekyll', 'destination']] would be passed unchanged.
+    #
+    # - If some of our given keys are Arrays and some are not, assume the Arrays are incomplete
+    #   settings-paths (suffixes) and assume the non-Arrays are prefixes that should be applied
+    #   to each suffix, e.g.
+    #   ['changes', ['image', '*'], ['image', 'jpeg']] becomes [['changes', 'image', 'jpeg'], ['changes', 'image', '*']]
+    #
+    # - If none of our given keys are an Array, assume the given keys make up
+    #   a single settings-path and wrap them in an Array, e.g.:
+    #   ['jekyll', 'destination'] becomes [['jekyll', 'destination']]
+    key_paths = case
+      when keys.all?(Array) then keys
+      when keys.any?(Array) then
+        keys.map.partition(&Array.method(:===)).yield_self.with_object(Array.new) { |(suffixes, prefix), combined_paths|
+          suffixes.each{ |suffix| combined_paths.push(suffix.unshift(*prefix)) }
+        }
+      when keys.none?(Array) then Array[keys]
+    end.map { |key_path|
+      # Now inspect the first key of each combined path and transform accordingly:
+      # - Opposite Day — :jekyll-prefixed paths get the prefix removed
+      #   because that key level doesn't exist in the Jekyll config.
+      # - If it already has out prefix, leave it alone.
+      # - Everything else gets our :distorted prefix added if missing
+      #   so I don't have to refer to the constant externally.
+      # Finally, Symbolize errething for Hash key consistency in memoization
+      # even though some config getters will map them back to Strings.
+      case key_path.first.to_sym
+      when :jekyll, :Jekyll then key_path.drop(1)
+      when CONFIG_ROOT_KEY then key_path.map(&:to_sym)
+      else key_path.unshift(CONFIG_ROOT_KEY).map(&:to_sym)
+      end
+    }
+
+    # Do The Thing
+    return memories!(key_paths, Array[
+      ->(key_path){ site.config.dig(*key_path.map(&:to_s))},
+      ->(key_path){ self::distorted_default_settings.dig(*key_path.map(&:to_s))},
+    ])
+  end  # self.the_setting_sun
+end  # module Jekyll::DistorteD
+
+
+module Jekyll::DistorteD::Setting
+  # Instance version of Setting entry-point.
+  def the_setting_sun(*a, **k, &b); Jekyll::DistorteD::the_setting_sun(*a, **k, &b); end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: distorted-jekyll
 version: !ruby/object:Gem::Version
-  version: 0.6.0
+  version: 0.7.0
 platform: ruby
 authors:
 - okeeblow
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-10-19 00:00:00.000000000 Z
+date: 2021-01-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -86,14 +86,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.6.0
+        version: 0.7.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.6.0
+        version: 0.7.0
 - !ruby/object:Gem::Dependency
   name: kramdown
   requirement: !ruby/object:Gem::Requirement
@@ -119,30 +119,35 @@ files:
 - LICENSE
 - README.md
 - lib/distorted-jekyll.rb
+- lib/distorted-jekyll/13th-style.css
 - lib/distorted-jekyll/13th-style.rb
 - lib/distorted-jekyll/_config_default.yml
 - lib/distorted-jekyll/blocks.rb
-- lib/distorted-jekyll/floor.rb
 - lib/distorted-jekyll/invoker.rb
+- lib/distorted-jekyll/liquid_liquid.rb
+- lib/distorted-jekyll/liquid_liquid/anchor.liquid
+- lib/distorted-jekyll/liquid_liquid/anchor_inline.liquid
+- lib/distorted-jekyll/liquid_liquid/embed.liquid
+- lib/distorted-jekyll/liquid_liquid/img.liquid
+- lib/distorted-jekyll/liquid_liquid/object.liquid
+- lib/distorted-jekyll/liquid_liquid/picture.liquid
+- lib/distorted-jekyll/liquid_liquid/picture.rb
+- lib/distorted-jekyll/liquid_liquid/picture_source.liquid
+- lib/distorted-jekyll/liquid_liquid/root.liquid
+- lib/distorted-jekyll/liquid_liquid/video.liquid
+- lib/distorted-jekyll/liquid_liquid/video_source.liquid
 - lib/distorted-jekyll/md_injection.rb
-- lib/distorted-jekyll/molecule/font.rb
-- lib/distorted-jekyll/molecule/image.rb
-- lib/distorted-jekyll/molecule/lastresort.rb
-- lib/distorted-jekyll/molecule/pdf.rb
-- lib/distorted-jekyll/molecule/svg.rb
-- lib/distorted-jekyll/molecule/text.rb
-- lib/distorted-jekyll/molecule/video.rb
+- lib/distorted-jekyll/media_molecule.rb
+- lib/distorted-jekyll/media_molecule/font.rb
+- lib/distorted-jekyll/media_molecule/image.rb
+- lib/distorted-jekyll/media_molecule/never_let_you_down.rb
+- lib/distorted-jekyll/media_molecule/pdf.rb
+- lib/distorted-jekyll/media_molecule/svg.rb
+- lib/distorted-jekyll/media_molecule/text.rb
+- lib/distorted-jekyll/media_molecule/video.rb
 - lib/distorted-jekyll/monkey_business/jekyll/cleaner.rb
 - lib/distorted-jekyll/static_state.rb
-- lib/distorted-jekyll/template/13th-style.css
-- lib/distorted-jekyll/template/error_code.liquid
-- lib/distorted-jekyll/template/font.liquid
-- lib/distorted-jekyll/template/image.liquid
-- lib/distorted-jekyll/template/lastresort.liquid
-- lib/distorted-jekyll/template/pdf.liquid
-- lib/distorted-jekyll/template/svg.liquid
-- lib/distorted-jekyll/template/text.liquid
-- lib/distorted-jekyll/template/video.liquid
+- lib/distorted-jekyll/the_setting_sun.rb
 homepage: https://cooltrainer.org
 licenses:
 - AGPL-3.0

data/lib/distorted-jekyll/floor.rb

@@ -1,266 +0,0 @@
-require 'yaml'
-require 'jekyll'
-require 'set'
-
-require 'distorted/monkey_business/hash'
-require 'distorted/checking_you_out'
-
-
-module Jekyll
-  module DistorteD
-    module Floor
-
-      ATTRIBUTES = Set[:lower_world, :changes, :outer_limits]
-
-      # Top-level config key (once stringified) for Jekyll and Default YAML.
-      CONFIG_ROOT = :distorted
-
-      # Filename for default config YAML. Should be a sibling of this file.
-      # Don't move this file or the YAML defaults without changing this.
-      DEFAULT_CONFIG_FILE_NAME = '_config_default.yml'.freeze
-      DEFAULT_CONFIG_PATH = File.join(File.dirname(__FILE__), DEFAULT_CONFIG_FILE_NAME).freeze
-
-      # Separator character for pretty-printing config hierarchy.
-      PP_SEPARATOR = "\u21e2 ".encode('utf-8').freeze
-
-      # Path separator is almost always '/' internally, but support
-      # ALT_SEPARATOR platforms too.
-      # On Lunix - Ruby 2.7:
-      # irb(main):003:0> File::ALT_SEPARATOR
-      # => nil
-      # irb(main):004:0> File::SEPARATOR
-      # => "/"
-      PATH_SEPARATOR = (File::ALT_SEPARATOR || File::SEPARATOR).freeze
-
-
-      # Generic main config-loading function that will search, in order:
-      # - The memoized pre-transformed config data store in-memory.
-      # - Jekyll's Site config, for a passed-in site or for the default site.
-      # - DistorteD's Gem-internal default config YAML.
-      #
-      # Optionally provide a class to be used as a fallback for missing keys.
-      def self.config(*keys, **kw)
-        # Symbolize for our internal representation of the config path.
-        # The Jekyll config and default config are both YAML, so we want string
-        # keys for them. Go ahead and prepend the top-level search key here too.
-        memo_keys = keys.compact.map(&:to_sym).to_set
-        search_keys = keys.compact.map(&:to_s).map(&:freeze)
-        # Pretty print the config path for logging.
-        log_key = search_keys.join(PP_SEPARATOR.to_s).freeze
-        # Initialize memoization class variable as a Hash that will return nil
-        # for any key access that doesn't already contain something.
-        @@memories ||= Hash.new { |h,k| h[k] = h.class.new(&h.default_proc) }
-        # Try to load a memoized config if we can, to skip any filesystem
-        # access and data transformation steps.
-        config = @@memories&.dig(*memo_keys)
-        unless config.nil?
-          if config.is_a?(TrueClass) || config.is_a?(FalseClass)
-            return config
-          elsif config.is_a?(Enumerable)
-            unless config.empty?
-              # Can't check this at the top level because True/FalseClass
-              # don't respond to this message.
-              return config
-            end
-          end
-        end
-
-        # The key isn't memoized. Look for it first in Jekyll's Site config.
-        # Is it even possible to have more than one Site? Support being passed
-        # a `site` object just in case, but taking the first one should be fine.
-        site = kw[:site] || Jekyll.sites.first
-        # Get the config, or nil if the queried config path doesn't exist.
-        loaded_config = site.config.dig(*search_keys)
-        if loaded_config.nil?
-          # The wanted config key didn't exist in the Site config, so let's
-          # try our defaults!
-          # This file will always be small enough for a one-shot read.
-          default_config = YAML.load(File.read(DEFAULT_CONFIG_PATH))
-          loaded_config = default_config.dig(*search_keys)
-          unless loaded_config.nil?
-            Jekyll.logger.debug(['Default', log_key].join(PP_SEPARATOR.to_s).concat(':'.freeze), loaded_config)
-          end
-        else  # else Jekyll _config is not nil
-          Jekyll.logger.debug(['_config', log_key].join(PP_SEPARATOR.to_s).concat(':'.freeze), loaded_config)
-        end
-        # Was the desired config key found in the Gem defaults?
-        if loaded_config.nil?
-          # Nope.
-          return nil
-        else
-          # Symbolize any output keys and values, and convert Arrays and Ruby::YAML
-          # Sets-as-Hashes to Ruby stdlib Sets.
-          # Returning a Set instead of an Array should be fine since none of our
-          # configs can (read: should) contain duplicate values for any reason.
-          loaded_config = symbolic(set_me_free(loaded_config))
-        end
-        # Memoize any of our own config, but just return anything outside our tree.
-        if keys.first == CONFIG_ROOT
-          @@memories.bury(*memo_keys, loaded_config)
-          Jekyll.logger.debug(log_key, "Memoizing config: #{@@memories.dig(*memo_keys)}")
-          # And return a config to the caller. Don't return the `new`ly fetched
-          # data directly to ensure consistency between this first fetch and
-          # subsequent memoized fetches, and to let callers take advantage of
-          # the memo Hash's `default_proc` setup.
-          return @@memories.dig(*memo_keys)
-        else
-          return loaded_config
-        end
-      end
-
-      # AFAICT Ruby::YAML will not give me a Ruby Set[] for a YAML Set,
-      # just a Hash with all-nil-values which is what it is internally.
-      # distorted⇢ image Trying Jekyll _config key: {"(max-width: 400px)"=>nil, "(min-width: 800px)"=>nil, "(min-width: 1500px)"=>nil}
-      # It is possible with some sugar in the YAML files, but I don't
-      # want to ask anyone to do that :)
-      # https://rhnh.net/2011/01/31/yaml-tutorial/
-      def self.set_me_free(dunno)
-        if dunno.class == Array
-          return dunno&.to_set.map{|d| set_me_free(d)}
-        elsif dunno.class == Hash
-          if dunno&.values.all?{|v| v.nil?}
-            return dunno&.keys.to_set
-          else
-            return dunno&.transform_values!{|v| set_me_free(v)}
-          end
-        end
-        return dunno
-      end
-
-      # Transform arbitrary configuration data structure keys from
-      # strings to symbols before memoization.
-      # https://stackoverflow.com/a/8189435
-      def self.symbolic(dunno)
-        # Check message-handling responses to gauge emptiness since classes that
-        # don't respond to `:empty?` might not respond to `:method_exists?` either.
-        if dunno.nil?
-          return dunno
-        elsif dunno.class == Hash
-          return dunno.transform_keys!(&:to_sym).transform_values!{|v| symbolic(v)}
-        elsif dunno.class == Array
-          return dunno.map{|r| symbolic(r)}
-        elsif dunno.respond_to?(:to_sym)
-          # Plain types
-          return dunno.to_sym
-        elsif dunno.respond_to?(:to_str)
-          # Freeze string config values.
-          # Specifically :to_str, not :to_s. Usually implemented by actual Strings.
-          return dunno.to_str.freeze
-        end
-        return dunno
-      end
-
-      # 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 abstract(: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 = type_mars.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 lower_world(*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(CHECKING::YOU::IN(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 type_mars
-        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(@liquid_liquid) })
-          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,
-          }
-        end
-
-        return out
-      end
-
-    end
-  end
-end