jekyll-favicon 0.2.7 → 1.0.0.pre.3

data/lib/jekyll/favicon/configuration/defaults.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require "yaml"
+
+module Jekyll
+  module Favicon
+    ROOT = Pathname.new File.dirname(File.dirname(File.dirname(File.dirname(__dir__))))
+
+    module Configuration
+      # Create configurable for include
+      module Defaults
+        def self.included(base)
+          *modules, class_or_module_name = base_name_to_parts base.name
+          method_name = "#{class_or_module_name}_defaults"
+          define_defaults base, method_name do
+            Defaults.load_defaults(*modules, class_or_module_name)
+          end
+        end
+
+        def self.load_defaults(*parts)
+          load_file "config", *parts
+        end
+
+        def self.load_file(*parts)
+          path = Favicon::ROOT.join(*parts).to_s
+          path = "#{path}.yml"
+          YAML.load_file path
+        end
+
+        def self.define_defaults(base, method_name, &block)
+          base.define_singleton_method("defaults", &block)
+          define_method(method_name, &block)
+        end
+
+        def self.base_name_to_parts(name)
+          name.split("::").collect do |module_or_class|
+            camelcase_to_snakecase module_or_class
+          end
+        end
+
+        def self.camelcase_to_snakecase(camelcase)
+          camelcase.gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
+            .gsub(/([a-z\d])([A-Z])/, '\1_\2')
+            .downcase
+        end
+      end
+    end
+  end
+end

data/lib/jekyll/favicon/generator.rb

@@ -1,91 +1,17 @@
+# frozen_string_literal: true
+
+require "jekyll/plugin"
+require "jekyll/generator"
+require "jekyll/favicon"
+
 module Jekyll
   module Favicon
-    # Extended generator that creates all the stastic icons and metadata files
+    # New generator that creates all the stastic icons and metadata files
     class Generator < Jekyll::Generator
-      priority :high
-
-      attr_accessor :template
-
       def generate(site)
-        @site = site
-        if File.file? source_path Favicon.config['source']
-          @template = favicon_tempfile source_path Favicon.config['source']
-          generate_icons && generate_metadata
-        else
-          Jekyll.logger.warn 'Jekyll::Favicon: Missing ' \
-                             "#{Favicon.config['source']}, not generating " \
-                             'favicons.'
-        end
-      end
-
-      def clean
-        return unless @template
-        @template.close
-        @template.unlink
-      end
-
-      private
-
-      def source_path(path = nil)
-        File.join(*[@site.source, path].compact)
-      end
-
-      def favicon_tempfile(source)
-        tempfile = Tempfile.new(['favicon-template', '.png'])
-        options = { background: 'none' }
-        if source.svg?
-          options[:density] = Favicon.config['svg']['density']
-          options[:resize] = Favicon.config['svg']['dimensions']
-        elsif source.png?
-          options[:resize] = Favicon.config['png']['dimensions']
-        end
-        Image.convert source, tempfile.path, options
-        tempfile
-      end
-
-      def generate_icons
-        @site.static_files.push ico_icon
-        @site.static_files.push(*png_icons)
-        @site.static_files.push(*svg_icons)
-      end
-
-      def ico_icon
-        target = Favicon.config['ico']['target']
-        Icon.new @site, Favicon.config['source'], @template.path, target
-      end
-
-      def png_icons
-        Favicon.config.deep_find('sizes').uniq.collect do |size|
-          target = File.join Favicon.config['path'], "favicon-#{size}.png"
-          Icon.new @site, Favicon.config['source'], @template.path, target
-        end
-      end
-
-      def svg_icons
-        return [] unless Favicon.config['source'].svg?
-        source = Favicon.config['source']
-        %w[safari-pinned-tab.svg].collect do |name|
-          target = File.join Favicon.config['path'], name
-          Icon.new @site, source, source_path(source), target
-        end
-      end
-
-      def generate_metadata
-        @site.pages.push metadata Browserconfig.new,
-                                  Favicon.config['ie']['browserconfig']
-        @site.pages.push metadata Webmanifest.new,
-                                  Favicon.config['chrome']['manifest']
-      end
-
-      def metadata(document, config)
-        page = Metadata.new @site, @site.source,
-                            File.dirname(config['target']),
-                            File.basename(config['target'])
-        favicon_path = File.join (@site.baseurl || ''), Favicon.config['path']
-        document.load source_path(config['source']), config, favicon_path
-        page.content = document.dump
-        page.data = { 'layout' => nil }
-        page
+        Favicon.assets(site)
+          .select(&:generable?)
+          .each { |asset| site.static_files << asset }
       end
     end
   end

data/lib/jekyll/favicon/hooks.rb

@@ -1,14 +1,16 @@
+# frozen_string_literal: true
+
+require "jekyll/hooks"
+
 Jekyll::Hooks.register :site, :after_init do |site|
-  Jekyll::Favicon.merge site.config['favicon']
-  favicon_config = Jekyll::Favicon.config
-  site.config['exclude'] << favicon_config['source']
-  site.config['exclude'] << favicon_config['chrome']['manifest']['source']
-  site.config['exclude'] << favicon_config['ie']['browserconfig']['source']
-end
+  static_files = Jekyll::Favicon.assets(site)
+    .uniq(&:path)
+  excludes = site.config["exclude"]
+  static_files.each do |static_file|
+    source = static_file.source_relative_path
+    excludes << source and next if static_file.generable?
 
-Jekyll::Hooks.register :site, :post_write do |site|
-  favicon_generators = site.generators.select do |generator|
-    generator.is_a? Jekyll::Favicon::Generator
+    Jekyll.logger.warn Jekyll::Favicon,
+      "Missing #{source}, not generating favicons."
   end
-  favicon_generators.each(&:clean)
 end

data/lib/jekyll/favicon/static_data_file.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require "jekyll/favicon/static_file"
+require "jekyll/favicon/static_file/mutable"
+
+module Jekyll
+  module Favicon
+    # StaticFile extension for data exchange formats
+    class StaticDataFile < StaticFile
+      include StaticFile::Mutable
+
+      def generable?
+        true
+      end
+    end
+  end
+end

data/lib/jekyll/favicon/static_file.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+require "pathname"
+require "forwardable"
+require "jekyll/static_file"
+require "jekyll/favicon/static_file/sourceable"
+require "jekyll/favicon/static_file/taggable"
+require "jekyll/favicon/static_file/referenceable"
+require "jekyll/favicon/utils"
+require "jekyll/favicon/configuration"
+
+module Jekyll
+  module Favicon
+    # Class for static files from with spec dictionary
+    # Modify source from spec source
+    # Enable tags from spec tags
+    # Enable refer
+    class StaticFile < Jekyll::StaticFile
+      include StaticFile::Sourceable
+      include StaticFile::Taggable
+      include StaticFile::Referenceable
+
+      attr_reader :spec, :site
+
+      def initialize(site, spec = {})
+        raise StandardError unless spec.include? "name"
+
+        @spec = spec
+        spec_dir, spec_name = File.split spec_relative_path
+        super site, site.source, spec_dir, spec_name
+      end
+
+      def generable?
+        sourceable?
+      end
+
+      def taggable?
+        generable? && super
+      end
+
+      def patch(configuration)
+        taggable_patch spec_patch configuration
+      end
+
+      def href
+        Pathname.new("/")
+          .join(*[site.baseurl, url].compact)
+          .to_s
+      end
+
+      private
+
+      def spec_patch(configuration)
+        Utils.patch configuration do |value|
+          case value
+          when :site_dir then site_dir
+          when :background then site_background
+          when :href then href
+          else value
+          end
+        end
+      end
+
+      def site_dir
+        site_configuration.fetch("dir", ".")
+      end
+
+      def site_background
+        site_configuration.fetch("background", "transparent")
+      end
+
+      def site_configuration
+        Configuration.merged site
+      end
+
+      def spec_relative_path
+        spec_relative_pathname.cleanpath
+      end
+
+      def spec_relative_pathname
+        return spec_pathname if spec_pathname.relative?
+
+        pathname.relative_path_from "/"
+      end
+
+      def spec_pathname
+        Pathname.new(site_dir)
+          .join(*spec_dir_name)
+      end
+
+      def spec_dir_name
+        spec.values_at("dir", "name")
+          .compact
+      end
+    end
+  end
+end

data/lib/jekyll/favicon/static_file/convertible.rb

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+require "jekyll/favicon/configuration/defaults"
+require "jekyll/favicon/utils"
+
+module Jekyll
+  module Favicon
+    class StaticFile < Jekyll::StaticFile
+      # Create static file based on a source file
+      module Convertible
+        include Configuration::Defaults
+
+        def convertible?
+          convert.any? || convert_allow_empty?
+        end
+
+        def convert
+          convert_defaults = convertible_defaults.dig File.extname(path), @extname
+          convert_normalized = convert_normalize convert_spec
+          convert_consolidated = Utils.merge convert_defaults, convert_normalized
+          patch convert_patch(convert_consolidated || {})
+        end
+
+        def convertible_patch(configuration)
+          Utils.patch configuration do |value|
+            case value
+            when :sizes then sizes.join " "
+            else value
+            end
+          end
+        end
+
+        def convert_odd_source?
+          img = MiniMagick::Image.open path
+          Utils.odd? img.dimensions
+        end
+
+        def convert_size(size, separator = "x")
+          return size unless convert_odd_source? || Utils.odd?(size)
+          min_dimension = size.split(separator).min
+          [min_dimension, min_dimension].join(separator)
+        end
+
+        def sizes
+          if (match = Utils.name_to_size(name)) then [match[1]]
+          elsif (define = Utils.define_to_size(convert_spec["define"])) then define
+          elsif (resize = convert_spec["resize"]) then [resize]
+          elsif (size = convert_spec["size"]) then [size]
+          end
+        end
+
+        # Jekyll::StaticFile method
+        # asks if dest mtime is older than source mtime after original modified?
+        def modified?
+          super || self.class.mtimes.fetch(href, -1) < mtime
+        end
+
+        # Jekyll::StaticFile method
+        # adds dest mtime to list after original write
+        def write(dest)
+          super(dest) && self.class.mtimes[href] = mtime
+        end
+
+        private
+
+        # Jekyll::StaticFile method
+        # add file creation instead of copying
+        def copy_file(dest_path)
+          case @extname
+          when ".svg" then super(dest_path)
+          when ".ico", ".png"
+            Utils.convert path, dest_path, convert
+          else Jekyll.logger.warn "Jekyll::Favicon: Can't generate " \
+                                  " #{dest_path}. Extension not supported."
+          end
+        end
+
+        def convert_allow_empty?
+          @extname == ".svg" && @extname == File.extname(path)
+        end
+
+        def convert_spec
+          spec.fetch "convert", {}
+        end
+
+        def convertible_keys
+          convertible_defaults["defaults"].keys
+        end
+
+        def convert_normalize(options)
+          return {} unless options
+
+          Utils.slice_and_compact options, convertible_keys
+        end
+
+        def convert_patch(options)
+          patched_options = convert_patch_options options
+          Utils.slice_and_compact patched_options, convertible_keys
+        end
+
+        def convert_patch_options(options)
+          %w[size extent].each_with_object(options) do |name, memo|
+            method = "convert_patch_option_#{name}".to_sym
+            memo[name] = send(method, options[name])
+          end
+        end
+
+        def convert_patch_option_size(size)
+          case size
+          when :auto
+            convert_size size if (size = sizes.first)
+          else size
+          end
+        end
+
+        def convert_patch_option_extent(extent)
+          case extent
+          when :auto
+            if (size = sizes.first)
+              width, height = size.split "x"
+              size if width != height
+            end
+          else extent
+          end
+        end
+      end
+    end
+  end
+end

data/lib/jekyll/favicon/static_file/mutable.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+require "rexml/document"
+require "jekyll/favicon/utils"
+require "jekyll/favicon/static_graphic_file"
+
+module Jekyll
+  module Favicon
+    class StaticFile < Jekyll::StaticFile
+      # Create static file based on a source file
+      module Mutable
+        def mutable?
+          mutation.any? || super
+        end
+
+        def mutation
+          refers = case @extname
+                   when ".xml"
+                     mutation_refers.select { |refer| refer.key? "browserconfig" }
+                   else
+                     mutation_refers.collect { |refer| refer["webmanifest"] }
+                       .compact
+          end
+          patch(Utils.merge(*refers) || {})
+        end
+
+        # overrides Jekyll::StaticFile method
+        def mtime
+          return super if File.file? path
+        end
+
+        private
+
+        # overrides Jekyll::StaticFile method
+        def copy_file(dest_path)
+          # return unless mutable?
+          # return super(dest_path) unless mutation.any?
+
+          File.write dest_path, mutated_content
+        end
+
+        def mutated_content
+          case @extname
+          when ".json", ".webmanifest", ".manifest" then mutated_content_json
+          when ".xml" then mutated_content_xml
+          end
+        end
+
+        def mutated_content_json
+          mutated = Jekyll::Utils.deep_merge_hashes (mutable || {}), mutation
+          JSON.pretty_generate mutated
+        end
+
+        def mutated_content_xml
+          mutated = Utils.mutate_element (mutable || REXML::Document.new), mutation
+          output = +""
+          mutated.write output
+          output
+        end
+
+        def mutable
+          return unless File.file? path
+
+          content = File.read path
+          case File.extname path
+          when ".xml" then REXML::Document.new content
+          else JSON.parse content
+          end
+        end
+
+        def mutation_refers
+          site.static_files
+            .select { |static_file| static_file.is_a? StaticFile }
+            .select(&:referenceable?)
+            .collect(&:refer)
+            .flatten
+        end
+      end
+    end
+  end
+end