hyde-fonts 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: ef7f7a15334f4df1f96be84e4c34b6e5b63500170c559ec590e36379c03695f3
+  data.tar.gz: f3cfdf6988e1de02511abce55f29c39a940c4090140c323971fda3aa8ca2005d
+SHA512:
+  metadata.gz: 07d8d6fdd0a29e3d458d40ec1ccff14d4952b94891b3c5aee73405d626943e894e38b8a3b9182241e6b4e7e12d25dda210f5407e3b28fa196d9ada950f29c14f
+  data.tar.gz: 65ccfe4b9510c92d7a05b700f4dbb84ac1fe456fa2893f58637c9d2c87a72c30c1b52b8ef66909f78613be732705041f9c533c2d2d2b885dcb4ac0e19e8e05cc

data/lib/hyde_fonts/font_data.rb

@@ -0,0 +1,24 @@
+module Hyde
+  class FontData
+    attr_reader :faces
+
+    def initialize(data)
+      @data = data
+      @faces = []
+      @sizes = []
+
+      return unless @data
+
+      parse_faces
+    end
+
+    def parse_faces
+
+      for face in @data['faces'] do
+        faces.push(Hyde::FontFace.new(face))
+      end
+
+      return faces
+    end
+  end
+end

data/lib/hyde_fonts/font_face.rb

@@ -0,0 +1,38 @@
+module Hyde
+  class FontFace
+    attr_reader :provider
+    attr_accessor :css
+
+    def initialize(face)
+      @name = face['name']
+      @provider = face['provider']
+      @weights = face['weights']
+      @variants = parse_variants
+      @css = []
+    end
+
+    def sort_variants
+      @variants.sort do |a, b|
+        (a.italic == b.italic) ? a.weight <=> b.weight : a.italic <=> b.italic
+      end
+    end
+
+    def to_s
+      variants = sort_variants.map { |variant| variant.to_s }
+
+      @name + ':ital,wght@' + variants.join(';')
+    end
+
+  private
+
+    def parse_variants
+      variants = []
+
+      for variant in @weights
+        variants.push(Hyde::FontVariant.new(weight: variant['value'], italic: variant['italic']))
+      end
+
+      return variants
+    end
+  end
+end

data/lib/hyde_fonts/font_ruleset.rb

@@ -0,0 +1,28 @@
+module Hyde
+  class FontRuleset
+    attr_reader :filename, :char_set, :family, :style, :weight, :uri, :format, :ruleset, :local_rule_set
+
+    def initialize(raw_css_ruleset)
+      @ruleset = raw_css_ruleset
+
+      /\/\* (?'character_set'.*) \*\// =~ raw_css_ruleset
+      /^\s*font-family:\s'(?'family'[\w]*)';$/ =~ raw_css_ruleset
+      /^\s*font-style:\s(?'style'[\w]*);$/ =~ raw_css_ruleset
+      /^\s*font-weight:\s(?'weight'[\w]*);$/ =~ raw_css_ruleset
+      /\s\ssrc:\surl\((?'uri'.*)\)\s.*\('(?'format'.*)'\);$$/ =~ raw_css_ruleset
+
+      @char_set = character_set
+      @family = family
+      @style = style
+      @weight = weight
+      @uri = URI(uri)
+      @format = format
+
+      @filename = [@family, @style, @weight, @char_set + '.' + @format].join('_')
+    end
+
+    def local_ruleset(path)
+      @ruleset.gsub(/(?<=url\().*(?=\)\s)/, '/' + File.join(path, @filename))
+    end
+  end
+end

data/lib/hyde_fonts/font_variant.rb

@@ -0,0 +1,18 @@
+module Hyde
+  class FontVariant
+    attr_reader :italic, :weight
+
+    def initialize(weight:, italic:)
+      @weight = weight
+      @italic = 0
+
+      if italic == true
+        @italic = 1
+      end
+    end
+
+    def to_s
+      @italic.to_s + ',' + @weight.to_s
+    end
+  end
+end

data/lib/hyde_fonts/generated_css_file.rb

@@ -0,0 +1,33 @@
+module Hyde
+  # Alternative class for jekyll's static files
+  # this allows the creation of files without a source file
+
+  class GeneratedCssFile < Jekyll::StaticFile
+    attr_accessor :file_contents
+    attr_reader :generator, :x
+
+    def initialize(site, dir, name)
+      @site = site
+      @dir  = dir
+      @name = name
+      @relative_path = File.join(*[@dir, @name].compact)
+      @extname = File.extname(@name)
+      @type = @collection&.label&.to_sym
+      @generator = 'hyde_fonts'
+    end
+
+    def write(dest)
+      dest_path = destination(dest)
+      return false if File.exist?(dest_path)
+
+      FileUtils.mkdir_p(File.dirname(dest_path))
+      FileUtils.rm(dest_path) if File.exist?(dest_path)
+
+      File.open(dest_path, 'w') do |output_file|
+        output_file << file_contents
+      end
+
+      true
+    end
+  end
+end

data/lib/hyde_fonts/generated_font_file.rb

@@ -0,0 +1,34 @@
+module Hyde
+  # Alternative class for jekyll's static files
+  # this allows the creation of files without a source file
+
+  class GeneratedFontFile < Jekyll::StaticFile
+    attr_accessor :file_contents
+    attr_reader :generator, :dest_path
+
+    def initialize(site, dir, name)
+      @site = site
+      @dir  = dir
+      @name = name
+      @relative_path = File.join(*[@dir, @name].compact)
+      @extname = File.extname(@name)
+      @type = @collection&.label&.to_sym
+      @generator = 'hyde_fonts'
+      @dest_path = ''
+    end
+
+    def write(dest)
+      return false if File.exist?(dest_path)
+
+      @dest_path = destination(dest)
+      FileUtils.mkdir_p(File.dirname(dest_path))
+      FileUtils.rm(dest_path) if File.exist?(dest_path)
+
+      File.open(dest_path, 'w') do |output_file|
+        output_file << file_contents
+      end
+
+      true
+    end
+  end
+end

data/lib/hyde_fonts/hyde_fonts.rb

@@ -0,0 +1,111 @@
+require 'jekyll'
+require_relative 'font_data.rb'
+require_relative 'font_face.rb'
+require_relative 'font_ruleset.rb'
+require_relative 'font_variant.rb'
+require_relative 'generated_css_file.rb'
+require_relative 'generated_font_file.rb'
+require_relative 'provider_google.rb'
+
+module Jekyll
+  class HydeFontsTag < Liquid::Tag
+    def initialize(tag_name, text, tokens)
+      super
+
+      @tag_name = tag_name
+      @text = text.strip
+      @tokens = tokens
+    end
+
+    def render(context)
+      config = context.registers[:site].config['hyde_fonts']
+      return unless config['enable'] == true
+
+      file = context.registers[:site].static_files.find { |file|
+        file.is_a?(Hyde::GeneratedCssFile)
+      }
+
+      if @text == 'inline'
+        file.file_contents
+      else
+        "<link href='" + file.relative_path + "' rel='stylesheet'>"
+      end
+    end
+  end
+
+  Liquid::Template.register_tag('hyde_fonts', Jekyll::HydeFontsTag)
+
+  class HydeFontsGenerator < Generator
+    def generate(site)
+      Hyde::Fonts.new(site).generate()
+    end
+  end
+end
+
+module Hyde
+  class Fonts
+    @@config = {
+      "data_path" => 'fonts',
+      "file_output_path" => 'assets/fonts',
+      "css_output_name" => 'fonts.css',
+      "css_minify" => true,
+      "enable" => true,
+      "fetch_fonts" => true,
+      "keep_files" => false
+    }
+
+    def initialize(site)
+      @site = site
+      @config = site.config.dig('hyde_fonts') || @@config
+
+      if config('keep_files') == true
+        @site.config['keep_files'].push(config('file_output_path'))
+      end
+
+      if site.config.dig('hyde_fonts').nil?
+        @site.config['hyde_fonts'] = @config
+      end
+    end
+
+    def generate
+      # get faces from jekyll data file
+      font_data = Hyde::FontData.new(data)
+
+      # handle font providers
+      for face in font_data.faces
+        case face.provider
+        when 'google'
+          Hyde::FontProviderGoogle.new(@site, @config).fetch(face)
+        when 'local'
+          # TODO handle local fonts
+          # Hyde::FontProviderLocal.new(@site, @config).fetch(face)
+        end
+      end
+
+      css = font_data.faces.map { |face| face.css }
+      # generate static file containing face css rulesets
+      css_file = Hyde::GeneratedCssFile.new(@site, config('file_output_path'), config('css_output_name'))
+      css_file.file_contents = minify(css.join("\n"))
+
+      @site.static_files << css_file
+    end
+
+  private
+
+    def config(*keys)
+      @config.dig(*keys)
+    end
+
+    def data
+      @site.data.dig(config('data_path'), 'fonts')
+    end
+
+    def minify(css)
+      return css if config('css_minify') == false
+
+      converter_config = { 'sass' => { 'style' => 'compressed' } }
+
+      Jekyll::Converters::Scss.new(converter_config).convert(css)
+    end
+  end
+end

data/lib/hyde_fonts/provider_google.rb

@@ -0,0 +1,71 @@
+require 'uri'
+require 'net/http'
+
+module Hyde
+  class FontProviderGoogle
+    def initialize(site, config)
+      @site = site
+      @config = config
+    end
+
+    def fetch(face)
+      @face = face
+
+      begin
+        uri_payload = Net::HTTP.get(face_uri, {
+          "User-Agent": 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:109.0) Gecko/20100101 Firefox/117.0'
+        })
+      rescue
+        Jekyll.logger.warn('Fonts Warning:', 'Unable to reach Google Fonts service.')
+        return
+      end
+
+      rulesets = parse_css_payload(uri_payload)
+
+      # TODO if @config['fetch_fonts'] is false, don't download the files
+
+      for ruleset in rulesets
+        fetch_font_from_ruleset(ruleset)
+        face.css.push(rewrite_ruleset_to_local(ruleset))
+      end
+    end
+
+  private
+
+    def face_uri
+      google_uri_base = 'https://fonts.googleapis.com/css2'
+      params = [['display', 'swap']]
+      params.push(['family', @face.to_s])
+
+      uri = google_uri_base + '?' + params.map { |param| param.join('=') }.join('&')
+
+      URI(uri)
+    end
+
+    def parse_css_payload(css)
+      css.scan(/\/\*[^}]*}/).map do |raw_ruleset|
+        Hyde::FontRuleset.new(raw_ruleset)
+      end
+    end
+
+    def fetch_font_from_ruleset(ruleset)
+      filename = ruleset.filename
+      file = Hyde::GeneratedFontFile.new(@site, @config['file_output_path'], filename)
+
+      destination_fname = file.destination('./')
+
+      if @config['keep_files'] == true
+        return if File.exist?(destination_fname)
+      end
+
+      font_uri_payload = Net::HTTP.get(ruleset.uri)
+      file.file_contents = font_uri_payload
+
+      @site.static_files << file
+    end
+
+    def rewrite_ruleset_to_local(ruleset)
+      ruleset.local_ruleset(@config['file_output_path'])
+    end
+  end
+end

data/lib/hyde_fonts.rb

@@ -0,0 +1,8 @@
+module Hyde
+  class Fonts
+    VERSION = "0.1.0"
+  end
+end
+
+require_relative './hyde_fonts/hyde_fonts.rb'
+

metadata

@@ -0,0 +1,72 @@
+--- !ruby/object:Gem::Specification
+name: hyde-fonts
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Gregory Daynes
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2023-12-04 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: jekyll
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+description: Hyde Fonts is a plugin for Jekyll to make adding Google fonts based on
+  configuration.
+email: email@gregdaynes.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/hyde_fonts.rb
+- lib/hyde_fonts/font_data.rb
+- lib/hyde_fonts/font_face.rb
+- lib/hyde_fonts/font_ruleset.rb
+- lib/hyde_fonts/font_variant.rb
+- lib/hyde_fonts/generated_css_file.rb
+- lib/hyde_fonts/generated_font_file.rb
+- lib/hyde_fonts/hyde_fonts.rb
+- lib/hyde_fonts/provider_google.rb
+homepage: https://gregdaynes.com
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.4.6
+signing_key:
+specification_version: 4
+summary: Plugin for jekyll to manage google fonts
+test_files: []