jekyll-favicon 0.2.9 → 1.0.0

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

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require "jekyll/favicon/configuration/defaults"
+
+module Jekyll
+  module Favicon
+    class StaticFile < Jekyll::StaticFile
+      # Add reference to a static file
+      module Referenceable
+        include Configuration::Defaults
+
+        def referenceable?
+          refer.any?
+        end
+
+        def refer
+          patch spec.fetch("refer", [])
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+require "jekyll/favicon/configuration/defaults"
+require "jekyll/favicon/utils"
+
+module Jekyll
+  module Favicon
+    class StaticFile < Jekyll::StaticFile
+      # Add source to a static file
+      module Sourceable
+        include Configuration::Defaults
+
+        def sourceable?
+          source.any? && File.file?(path)
+        end
+
+        def source
+          Utils.merge sourceable_defaults, source_site, source_asset
+        end
+
+        # overrides Jekyll::StaticFile method
+        def path
+          File.join(*[@base, source_relative_path].compact)
+        end
+
+        def source_relative_path
+          source_relative_pathname.to_s
+        end
+
+        def self.source_normalize(options)
+          case options
+          when String
+            source_dir, source_name = File.split options
+            {"dir" => source_dir, "name" => source_name}
+          when Hash
+            Utils.compact options
+          else {}
+          end
+        end
+
+        def self.source_filter(options)
+          options.fetch "source", {}
+        end
+
+        private
+
+        def source_relative_pathname
+          Pathname.new(source["dir"])
+            .join(source["name"])
+            .cleanpath
+        end
+
+        def source_defaults
+          sourceable_defaults
+        end
+
+        def source_site
+          site_config = Configuration.merged @site
+          config = Sourceable.source_filter site_config
+          Sourceable.source_normalize config
+        end
+
+        def source_spec
+          Sourceable.source_filter spec
+        end
+
+        def source_asset
+          Sourceable.source_normalize source_spec
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require "rexml/document"
+require "jekyll/favicon/configuration/defaults"
+require "jekyll/favicon/utils"
+
+module Jekyll
+  module Favicon
+    class StaticFile < Jekyll::StaticFile
+      # Add tags to favicon's static files
+      module Taggable
+        include Configuration::Defaults
+
+        def taggable?
+          tags.any?
+        end
+
+        def tags
+          tag_spec.collect do |options|
+            tag_name, tag_options = options.first
+            tag_defaults = taggable_defaults[tag_name]
+            tag_attributes = tag_defaults.merge tag_options
+            Utils.build_tag tag_name, patch(tag_attributes)
+          end
+        end
+
+        private
+
+        def tag_spec
+          spec.fetch "tag", []
+        end
+
+        def mimetype
+          mappings = {
+            ".ico" => "image/x-icon",
+            ".png" => "image/png",
+            ".svg" => "image/svg+xml"
+          }
+          mappings[extname]
+        end
+
+        def taggable_patch(configuration)
+          Favicon::Utils.patch configuration do |value|
+            case value
+            when :mime then mimetype
+            else value
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/jekyll/favicon/static_graphic_file.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require "jekyll/favicon/static_file"
+require "jekyll/favicon/static_file/convertible"
+
+module Jekyll
+  module Favicon
+    # Favicon::StaticFile subclass
+    class StaticGraphicFile < StaticFile
+      include StaticFile::Convertible
+
+      def generable?
+        super && convertible?
+      end
+
+      def patch(configuration)
+        convertible_patch super(configuration)
+      end
+    end
+  end
+end

data/lib/jekyll/favicon/tag.rb

@@ -1,26 +1,23 @@
+# frozen_string_literal: true
+
+require "liquid"
+require "jekyll/favicon/static_file"
+
 module Jekyll
   module Favicon
-    # New `favicon` tag for favicon include on templates
+    # New `favicon` tag include html tags on templates
     class Tag < Liquid::Tag
-      def initialize(tag_name, text, tokens)
-        super
-        @text = text
-      end
-
       def render(context)
-        site = context.registers[:site]
-        prepend_path = site.baseurl || ''
-        templates_dir = Favicon.templates
-        head = "<!-- Begin Jekyll Favicon tag v#{Favicon::VERSION} -->"
-        body = %w[classic safari chrome ie].collect do |template|
-          template_path = File.join templates_dir, "#{template}.html.erb"
-          ERB.new(File.read(template_path), nil, '-').result(binding).strip
-        end
-        foot = '<!-- End Jekyll Favicon tag -->'
-        [head, body.join("\n"), foot].join("\n")
+        context.registers[:site]
+          .static_files
+          .select { |static_file| static_file.is_a? StaticFile }
+          .select(&:taggable?)
+          .collect(&:tags)
+          .flatten
+          .join("\n")
       end
     end
   end
 end
 
-Liquid::Template.register_tag('favicon', Jekyll::Favicon::Tag)
+Liquid::Template.register_tag("favicon", Jekyll::Favicon::Tag)

data/lib/jekyll/favicon/utils.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require "jekyll/favicon/utils/configuration/compact"
+require "jekyll/favicon/utils/configuration/merge"
+require "jekyll/favicon/utils/configuration/patch"
+require "jekyll/favicon/utils/convert"
+require "jekyll/favicon/utils/tag"
+
+module Jekyll
+  module Favicon
+    # Favicon utils functions
+    module Utils
+      include Configuration::Compact
+      include Configuration::Merge
+      include Configuration::Patch
+      include Convert
+      include Tag
+
+      def self.except(hash, *keys)
+        hash.reject { |key, _| keys.include? key }
+      end
+
+      def self.define_to_size(define)
+        return unless define
+
+        define.split("=")
+          .last
+          .split(",")
+          .collect { |size| [size, size].join "x" }
+      end
+
+      def self.name_to_size(name)
+        size_in_name_regex = /^.*-(\d+x\d+)\..*$/
+        name.match size_in_name_regex
+      end
+
+      def self.slice_and_compact(hash, keys)
+        compactable = hash.slice(*keys)
+        Utils.compact compactable
+      end
+
+      def self.odd?(size, separator = "x")
+        size = size.split(separator) if size.is_a? String
+        size.uniq.size == 1
+      end
+    end
+  end
+end

data/lib/jekyll/favicon/utils/configuration/compact.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module Jekyll
+  module Favicon
+    module Utils
+      module Configuration
+        # Favicon configuration compact logic
+        module Compact
+          def self.included(klass)
+            klass.extend(ClassMethods)
+          end
+
+          def self.compact_deep(compactable)
+            case compactable
+            when Hash then compact_hash compactable
+            when Array then compact_array compactable
+            else compactable
+            end
+          end
+
+          def self.compact_hash(hash)
+            compacted_hash = hash.each_with_object({}) do |(key, value), memo|
+              next unless (compacted = compact_deep(value))
+
+              memo[key] = compacted
+            end
+            compact_shallow compacted_hash
+          end
+
+          def self.compact_array(array)
+            compacted_array = array.each_with_object([]) do |value, memo|
+              next unless (compacted = compact_deep(value))
+
+              memo << compacted
+            end
+            compact_shallow compacted_array
+          end
+
+          def self.compact_shallow(compactable)
+            compactable.empty? ? nil : compactable.compact
+          end
+
+          # Nil and empty remove from configurations
+          module ClassMethods
+            def compact(compactable)
+              case compactable
+              when Hash, Array
+                Compact.compact_deep(compactable) || compactable.class[]
+              else
+                compactable
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/jekyll/favicon/utils/configuration/merge.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module Jekyll
+  module Favicon
+    module Utils
+      module Configuration
+        # Favicon configuration merge logic
+        module Merge
+          def self.included(klass)
+            klass.extend(ClassMethods)
+          end
+
+          def self.merge_multiple(left = nil, *right_and_or_rest)
+            return left if right_and_or_rest.empty?
+
+            right, *rest = right_and_or_rest
+            merged = merge_pair left, right
+            return merged if rest.empty?
+
+            merge_multiple(merged, *rest)
+          end
+
+          def self.merge_pair(left, right)
+            return right if !left || !right || !left.instance_of?(right.class)
+
+            case right
+            when Hash then merge_pair_hash left, right
+            when Array then merge_pair_array left, right
+            else right
+            end
+          end
+
+          def self.merge_pair_hash(left_hash, right_hash)
+            left_hash.merge(right_hash) do |_, left_value, right_value|
+              merge_multiple left_value, right_value
+            end
+          end
+
+          def self.merge_pair_array(left_array, right_array)
+            joint_array = left_array + right_array
+            joint_array.group_by { |map| merge_group map }
+              .collect { |group, values| merge_collect group, values }
+              .flatten
+          end
+
+          def self.merge_group(map, keys = %w[name dir])
+            map.is_a?(Hash) ? map.values_at(*keys) : []
+          end
+
+          def self.merge_collect(group, values)
+            group.first ? merge_multiple(*values) : values
+          end
+
+          # Merge configurations
+          module ClassMethods
+            def merge(left = nil, *right_and_or_rest)
+              return left if right_and_or_rest.empty?
+
+              right, *rest = right_and_or_rest
+              merged = Merge.merge_pair left, right
+              return merged if rest.empty?
+
+              Merge.merge_multiple(merged, *rest)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/jekyll/favicon/utils/configuration/patch.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Jekyll
+  module Favicon
+    module Utils
+      module Configuration
+        # Favicon configuration patch logic
+        module Patch
+          def self.included(klass)
+            klass.extend(ClassMethods)
+          end
+
+          def self.patch_unknown(value_or_values, &block)
+            patch_method = case value_or_values
+                           when Array then :patch_array
+                           when Hash then :patch_hash
+                           when Symbol, String then :patch_value
+                           else return value_or_values
+            end
+            send patch_method, value_or_values, &block
+          end
+
+          def self.patch_array(values, &block)
+            values.collect { |value| patch_unknown value, &block }
+          end
+
+          def self.patch_hash(values, &block)
+            values.transform_values { |value| patch_unknown value, &block }
+          end
+
+          def self.patch_value(value, &block)
+            block.call patch_value_string_symbol(value)
+          end
+
+          def self.patch_value_string_symbol(value)
+            value.to_s.start_with?(":") ? value[1..].to_sym : value
+          end
+
+          # Patch configuration with the block provided
+          module ClassMethods
+            def patch(value_or_values, &block)
+              Patch.patch_unknown value_or_values, &block
+            end
+          end
+        end
+      end
+    end
+  end
+end