datalog-theme 0.10.1 → 0.11.0

data/lib/datalog/social_cards/font.rb

@@ -0,0 +1,286 @@
+# frozen_string_literal: true
+
+require_relative "outline"
+
+module Datalog
+  module SocialCards
+    # A TrueType font, read with nothing but Ruby: the advance width of each
+    # glyph, to wrap a title, and its outline, to draw it. A card's text is
+    # drawn as paths, so neither ImageMagick nor the build machine needs the
+    # font installed, and no font lookup can pick a different one.
+    #
+    # Reads the tables a static TrueType font always has (head, hhea, maxp,
+    # hmtx, cmap, loca, glyf), simple and composite glyphs alike. Kerning and
+    # ligatures are left out: the text is set from advance widths alone.
+    class Font
+      class Error < StandardError; end
+
+      # Glyph flags, from the glyf table.
+      ON_CURVE = 0x01
+      X_SHORT = 0x02
+      Y_SHORT = 0x04
+      REPEAT = 0x08
+      X_SAME = 0x10
+      Y_SAME = 0x20
+
+      # Component flags of a composite glyph.
+      WORDS = 0x0001
+      XY_VALUES = 0x0002
+      SCALE = 0x0008
+      MORE = 0x0020
+      XY_SCALE = 0x0040
+      TWO_BY_TWO = 0x0080
+
+      IDENTITY = [1.0, 0.0, 0.0, 1.0].freeze
+
+      attr_reader :file, :units_per_em, :ascender, :descender
+
+      def initialize(file)
+        @file = file
+        @data = File.binread(file)
+        @tables = directory
+        read_head
+        read_hhea
+        @glyph_count = u16(table("maxp") + 4)
+        @advances = Array.new(@metric_count) { |index| u16(table("hmtx") + (index * 4)) }
+        @cmap = read_cmap
+        @loca = read_loca
+        @outlines = {}
+      rescue ArgumentError, TypeError, NoMethodError => e
+        raise Error, "#{file} is not a TrueType font this can read (#{e.message})"
+      end
+
+      # The glyph for a character, or 0 (.notdef) when the font has none.
+      def glyph_id(char)
+        @cmap.fetch(char.ord, 0)
+      end
+
+      def glyph?(char)
+        !glyph_id(char).zero?
+      end
+
+      def advance(glyph)
+        @advances.fetch(glyph) { @advances.last }
+      end
+
+      # The width of the text at a font size, in pixels.
+      def width(text, size)
+        text.each_char.sum { |char| advance(glyph_id(char)) } * size / units_per_em.to_f
+      end
+
+      # The text's outline as path data, from `left` along a baseline at a
+      # size, in SVG's path syntax, which ImageMagick's MVG shares. The y
+      # axis points down, as it does on the card.
+      def path(text, left, baseline, size)
+        scale = size / units_per_em.to_f
+        commands = []
+        text.each_char do |char|
+          glyph = glyph_id(char)
+          outline(glyph).each { |contour| commands << Outline.path(contour, left, baseline, scale) }
+          left += advance(glyph) * scale
+        end
+        commands.join(" ")
+      end
+
+      # Contours of [x, y, on_curve] points in font units, y up.
+      def outline(glyph, depth = 0)
+        @outlines[glyph] ||= begin
+          offset = @loca[glyph]
+          length = @loca[glyph + 1].to_i - offset.to_i
+          if offset.nil? || length <= 0 || depth > 8
+            []
+          else
+            start = table("glyf") + offset
+            contours = s16(start)
+            contours.negative? ? composite(start + 10, depth) : simple(start + 10, contours)
+          end
+        end
+      end
+
+      private
+
+      def directory
+        (0...u16(4)).to_h do |index|
+          record = 12 + (index * 16)
+          [@data.byteslice(record, 4), u32(record + 8)]
+        end
+      end
+
+      def table(tag)
+        @tables.fetch(tag) { raise Error, "#{file} has no #{tag} table" }
+      end
+
+      def read_head
+        head = table("head")
+        @units_per_em = u16(head + 18)
+        @long_offsets = s16(head + 50) == 1
+      end
+
+      def read_hhea
+        hhea = table("hhea")
+        @ascender = s16(hhea + 4)
+        @descender = s16(hhea + 6)
+        @metric_count = u16(hhea + 34)
+      end
+
+      # Unicode to glyph, from the format 12 subtable when there is one (all of
+      # Unicode), else format 4 (the Basic Multilingual Plane).
+      def read_cmap
+        cmap = table("cmap")
+        offsets = Array.new(u16(cmap + 2)) { |index| cmap + 4 + (index * 8) }.filter_map do |record|
+          platform = u16(record)
+          encoding = u16(record + 2)
+          cmap + u32(record + 4) if platform.zero? || (platform == 3 && [1, 10].include?(encoding))
+        end
+        full = offsets.find { |offset| u16(offset) == 12 }
+        return format12(full) if full
+
+        bmp = offsets.find { |offset| u16(offset) == 4 }
+        raise Error, "#{file} has no Unicode character map" unless bmp
+
+        format4(bmp)
+      end
+
+      def format12(offset)
+        Array.new(u32(offset + 12)) { |index| offset + 16 + (index * 12) }.each_with_object({}) do |group, map|
+          first = u32(group)
+          glyph = u32(group + 8)
+          (first..u32(group + 4)).each { |code| map[code] = glyph + code - first }
+        end
+      end
+
+      def format4(offset)
+        segments = u16(offset + 6) / 2
+        ends = offset + 14
+        starts = ends + (segments * 2) + 2
+        (0...segments).each_with_object({}) do |index, map|
+          first = u16(starts + (index * 2))
+          next if first == 0xFFFF
+
+          (first..u16(ends + (index * 2))).each do |code|
+            glyph = segment_glyph(starts + (segments * 2), segments, index, code, first)
+            map[code] = glyph unless glyph.zero?
+          end
+        end
+      end
+
+      # A code's glyph in a format 4 segment: its delta alone, or the delta
+      # added to an entry of the glyph array its range offset points into.
+      def segment_glyph(deltas, segments, index, code, first)
+        delta = s16(deltas + (index * 2))
+        range_at = deltas + (segments * 2) + (index * 2)
+        range = u16(range_at)
+        return (code + delta) & 0xFFFF if range.zero?
+
+        found = u16(range_at + range + ((code - first) * 2))
+        found.zero? ? 0 : (found + delta) & 0xFFFF
+      end
+
+      def read_loca
+        loca = table("loca")
+        Array.new(@glyph_count + 1) do |index|
+          @long_offsets ? u32(loca + (index * 4)) : u16(loca + (index * 2)) * 2
+        end
+      end
+
+      def simple(at, count)
+        ends = Array.new(count) { |index| u16(at + (index * 2)) }
+        at += (count * 2)
+        at += 2 + u16(at)
+        flags, at = read_flags(at, ends.empty? ? 0 : ends.last + 1)
+        xs, at = coordinates(flags, at, X_SHORT, X_SAME)
+        ys, = coordinates(flags, at, Y_SHORT, Y_SAME)
+        points = flags.each_with_index.map { |flag, index| [xs[index], ys[index], flag.anybits?(ON_CURVE)] }
+        starts = [0] + ends[0...-1].map(&:succ)
+        starts.zip(ends).map { |first, last| points[first..last] }
+      end
+
+      def read_flags(at, total)
+        flags = []
+        while flags.size < total
+          flag = @data.getbyte(at)
+          at += 1
+          flags << flag
+          next unless flag.anybits?(REPEAT)
+
+          @data.getbyte(at).times { flags << flag }
+          at += 1
+        end
+        [flags, at]
+      end
+
+      def coordinates(flags, at, short, same)
+        value = 0
+        values = flags.map do |flag|
+          if flag.anybits?(short)
+            step = @data.getbyte(at)
+            at += 1
+            value += flag.anybits?(same) ? step : -step
+          elsif flag.nobits?(same)
+            value += s16(at)
+            at += 2
+          end
+          value
+        end
+        [values, at]
+      end
+
+      # A glyph made of others, each placed by an offset and an optional
+      # scale or 2x2 transform: most accented letters.
+      def composite(at, depth)
+        contours = []
+        loop do
+          flags = u16(at)
+          component = u16(at + 2)
+          dx, dy, at = component_offset(flags, at + 4)
+          (a, b, c, d), at = component_transform(flags, at)
+          outline(component, depth + 1).each do |contour|
+            contours << contour.map { |x, y, on| [(a * x) + (c * y) + dx, (b * x) + (d * y) + dy, on] }
+          end
+          break unless flags.anybits?(MORE)
+        end
+        contours
+      end
+
+      def component_offset(flags, at)
+        if flags.anybits?(WORDS)
+          dx = s16(at)
+          dy = s16(at + 2)
+          at += 4
+        else
+          dx, dy = @data.byteslice(at, 2).unpack("cc")
+          at += 2
+        end
+        flags.anybits?(XY_VALUES) ? [dx, dy, at] : [0, 0, at]
+      end
+
+      def component_transform(flags, at)
+        if flags.anybits?(SCALE)
+          [[f2dot14(at), 0.0, 0.0, f2dot14(at)], at + 2]
+        elsif flags.anybits?(XY_SCALE)
+          [[f2dot14(at), 0.0, 0.0, f2dot14(at + 2)], at + 4]
+        elsif flags.anybits?(TWO_BY_TWO)
+          [[f2dot14(at), f2dot14(at + 2), f2dot14(at + 4), f2dot14(at + 6)], at + 8]
+        else
+          [IDENTITY, at]
+        end
+      end
+
+      def f2dot14(at)
+        s16(at) / 16_384.0
+      end
+
+      def u16(at)
+        @data.byteslice(at, 2).unpack1("n")
+      end
+
+      def s16(at)
+        @data.byteslice(at, 2).unpack1("s>")
+      end
+
+      def u32(at)
+        @data.byteslice(at, 4).unpack1("N")
+      end
+    end
+  end
+end

data/lib/datalog/social_cards/fonts/OFL.txt

@@ -0,0 +1,92 @@
+Copyright © 2017 IBM Corp. with Reserved Font Name "Plex"
+
+This Font Software is licensed under the SIL Open Font License, Version 1.1.
+This license is copied below, and is also available with a FAQ at:
+http://scripts.sil.org/OFL
+
+-----------------------------------------------------------
+SIL OPEN FONT LICENSE Version 1.1 - 26 February 2007
+-----------------------------------------------------------
+
+PREAMBLE
+The goals of the Open Font License (OFL) are to stimulate worldwide
+development of collaborative font projects, to support the font creation
+efforts of academic and linguistic communities, and to provide a free and
+open framework in which fonts may be shared and improved in partnership
+with others.
+
+The OFL allows the licensed fonts to be used, studied, modified and
+redistributed freely as long as they are not sold by themselves. The
+fonts, including any derivative works, can be bundled, embedded, 
+redistributed and/or sold with any software provided that any reserved
+names are not used by derivative works. The fonts and derivatives,
+however, cannot be released under any other type of license. The
+requirement for fonts to remain under this license does not apply
+to any document created using the fonts or their derivatives.
+
+DEFINITIONS
+"Font Software" refers to the set of files released by the Copyright
+Holder(s) under this license and clearly marked as such. This may
+include source files, build scripts and documentation.
+
+"Reserved Font Name" refers to any names specified as such after the
+copyright statement(s).
+
+"Original Version" refers to the collection of Font Software components as
+distributed by the Copyright Holder(s).
+
+"Modified Version" refers to any derivative made by adding to, deleting,
+or substituting -- in part or in whole -- any of the components of the
+Original Version, by changing formats or by porting the Font Software to a
+new environment.
+
+"Author" refers to any designer, engineer, programmer, technical
+writer or other person who contributed to the Font Software.
+
+PERMISSION & CONDITIONS
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of the Font Software, to use, study, copy, merge, embed, modify,
+redistribute, and sell modified and unmodified copies of the Font
+Software, subject to the following conditions:
+
+1) Neither the Font Software nor any of its individual components,
+in Original or Modified Versions, may be sold by itself.
+
+2) Original or Modified Versions of the Font Software may be bundled,
+redistributed and/or sold with any software, provided that each copy
+contains the above copyright notice and this license. These can be
+included either as stand-alone text files, human-readable headers or
+in the appropriate machine-readable metadata fields within text or
+binary files as long as those fields can be easily viewed by the user.
+
+3) No Modified Version of the Font Software may use the Reserved Font
+Name(s) unless explicit written permission is granted by the corresponding
+Copyright Holder. This restriction only applies to the primary font name as
+presented to the users.
+
+4) The name(s) of the Copyright Holder(s) or the Author(s) of the Font
+Software shall not be used to promote, endorse or advertise any
+Modified Version, except to acknowledge the contribution(s) of the
+Copyright Holder(s) and the Author(s) or with their explicit written
+permission.
+
+5) The Font Software, modified or unmodified, in part or in whole,
+must be distributed entirely under this license, and must not be
+distributed under any other license. The requirement for fonts to
+remain under this license does not apply to any document created
+using the Font Software.
+
+TERMINATION
+This license becomes null and void if any of the above conditions are
+not met.
+
+DISCLAIMER
+THE FONT SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT
+OF COPYRIGHT, PATENT, TRADEMARK, OR OTHER RIGHT. IN NO EVENT SHALL THE
+COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+INCLUDING ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL
+DAMAGES, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM
+OTHER DEALINGS IN THE FONT SOFTWARE.

data/lib/datalog/social_cards/geometry.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Datalog
+  module SocialCards
+    # SVG's transforms as the six numbers of matrix(a b c d e f), which is
+    # also the order of MVG's `affine`.
+    module Geometry
+      IDENTITY_MATRIX = [1.0, 0.0, 0.0, 1.0, 0.0, 0.0].freeze
+      NUMBER = /-?(?:\d+\.?\d*|\.\d+)(?:e[-+]?\d+)?/i
+      # The arguments hold no parenthesis, so a run of unclosed ones fails
+      # at once rather than scanning to the end from each.
+      TRANSFORM = /(matrix|translate|scale|rotate)\s*\(([^()]*)\)/
+
+      module_function
+
+      # A `transform` attribute's list of operations, as one matrix.
+      def transform(value)
+        matrix = IDENTITY_MATRIX
+        value.to_s.scan(TRANSFORM) do |name, args|
+          matrix = multiply(matrix, operation(name, args.scan(NUMBER).map(&:to_f)))
+        end
+        matrix
+      end
+
+      def operation(name, values)
+        case name
+        when "matrix" then values.size == 6 ? values : IDENTITY_MATRIX
+        when "translate" then [1.0, 0.0, 0.0, 1.0, values[0].to_f, values[1].to_f]
+        when "scale" then [values[0] || 1.0, 0.0, 0.0, values[1] || values[0] || 1.0, 0.0, 0.0]
+        when "rotate" then rotation(*values)
+        end
+      end
+
+      def rotation(degrees = 0.0, center_x = 0.0, center_y = 0.0)
+        radians = degrees * Math::PI / 180
+        cos = Math.cos(radians)
+        sin = Math.sin(radians)
+        turn = [cos, sin, -sin, cos, 0.0, 0.0]
+        multiply(multiply([1.0, 0.0, 0.0, 1.0, center_x, center_y], turn), [1.0, 0.0, 0.0, 1.0, -center_x, -center_y])
+      end
+
+      # Two matrices composed: the result applies `inner` first.
+      def multiply(outer, inner)
+        a, b, c, d, e, f = outer
+        g, h, i, j, k, l = inner
+        [(a * g) + (c * h), (b * g) + (d * h), (a * i) + (c * j), (b * i) + (d * j),
+         (a * k) + (c * l) + e, (b * k) + (d * l) + f]
+      end
+    end
+  end
+end

data/lib/datalog/social_cards/outline.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Datalog
+  module SocialCards
+    # A TrueType contour as path commands. TrueType draws with quadratic
+    # curves, and two off-curve points in a row imply an on-curve point
+    # halfway between them.
+    module Outline
+      module_function
+
+      # The contour's [x, y, on_curve] points, in font units with y up,
+      # placed at `left` on a baseline and scaled: one closed subpath.
+      def path(points, left, baseline, scale)
+        return "" if points.empty?
+
+        start, rest = start_and_rest(points)
+        place = ->(point) { "#{number(left + (point[0] * scale))} #{number(baseline - (point[1] * scale))}" }
+        commands = ["M #{place.call(start)}"]
+        control = nil
+        (rest + [start]).each do |point|
+          commands << segment(point, control, place)
+          control = point[2] ? nil : point
+        end
+        commands.compact.push("Z").join(" ")
+      end
+
+      # Where the subpath starts: the first on-curve point, or, when every
+      # point is off the curve, halfway between the last and the first.
+      def start_and_rest(points)
+        on = points.index { |point| point[2] }
+        return [points[on], points.rotate(on).drop(1)] if on
+
+        first = points.first
+        last = points.last
+        [[(first[0] + last[0]) / 2.0, (first[1] + last[1]) / 2.0, true], points]
+      end
+
+      # The command that reaches `point`, given the pending control point.
+      def segment(point, control, place)
+        if point[2]
+          control ? "Q #{place.call(control)} #{place.call(point)}" : "L #{place.call(point)}"
+        elsif control
+          middle = [(control[0] + point[0]) / 2.0, (control[1] + point[1]) / 2.0]
+          "Q #{place.call(control)} #{place.call(middle)}"
+        end
+      end
+
+      def number(value)
+        rounded = value.round(2)
+        rounded == rounded.to_i ? rounded.to_i.to_s : rounded.to_s
+      end
+    end
+  end
+end