boring_avatars 0.1.0

data/lib/boring_avatars/renderer.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+require_relative "identifier"
+require_relative "name_hash"
+require_relative "svg/serializer"
+require_relative "variants/bauhaus"
+require_relative "variants/beam"
+require_relative "variants/marble"
+require_relative "variants/pixel"
+require_relative "variants/ring"
+require_relative "variants/sunset"
+
+module BoringAvatars
+  module Renderer
+    VARIANTS = {
+      bauhaus: Variants::Bauhaus,
+      beam: Variants::Beam,
+      marble: Variants::Marble,
+      pixel: Variants::Pixel,
+      ring: Variants::Ring,
+      sunset: Variants::Sunset
+    }.freeze
+
+    module_function
+
+    def call(input)
+      prefix = Identifier.call(input)
+      ids = {
+        mask: "#{prefix}-mask",
+        filter: "#{prefix}-filter",
+        gradient_0: "#{prefix}-gradient-0",
+        gradient_1: "#{prefix}-gradient-1"
+      }.freeze
+      hash = NameHash.call(input.name)
+      result = VARIANTS.fetch(input.variant).render(input: input, hash: hash, ids: ids)
+
+      Svg::Serializer.call(root_element(input, result, ids))
+    end
+
+    def root_element(input, result, ids)
+      root_attributes = {
+        "viewBox" => "0 0 #{result.size} #{result.size}",
+        "fill" => "none",
+        "role" => "img",
+        "xmlns" => "http://www.w3.org/2000/svg",
+        "width" => input.size,
+        "height" => input.size
+      }.merge(input.attributes)
+
+      children = []
+      children << Svg::Element.new(name: "title", children: [input.name]) if input.title
+      children << mask_element(input, result, ids[:mask])
+      children << Svg::Element.new(
+        name: "g",
+        attributes: { "mask" => "url(##{ids[:mask]})" },
+        children: result.content
+      )
+      unless result.defs.empty?
+        children << Svg::Element.new(name: "defs", children: result.defs)
+      end
+
+      Svg::Element.new(name: "svg", attributes: root_attributes, children: children)
+    end
+    private_class_method :root_element
+
+    def mask_element(input, result, mask_id)
+      attributes = {
+        "id" => mask_id,
+        "maskUnits" => "userSpaceOnUse",
+        "x" => 0,
+        "y" => 0,
+        "width" => result.size,
+        "height" => result.size
+      }.merge(result.mask_attributes)
+      rectangle = Svg::Element.new(
+        name: "rect",
+        attributes: {
+          "width" => result.size,
+          "height" => result.size,
+          "rx" => input.square ? nil : result.size * 2,
+          "fill" => "#FFFFFF"
+        }
+      )
+
+      Svg::Element.new(name: "mask", attributes: attributes, children: [rectangle])
+    end
+    private_class_method :mask_element
+  end
+  private_constant :Renderer
+end
+

data/lib/boring_avatars/svg/element.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module BoringAvatars
+  module Svg
+    Element = Data.define(:name, :attributes, :children) do
+      def initialize(name:, attributes: {}, children: [])
+        super(
+          name: name.to_s.freeze,
+          attributes: attributes.reject { |_key, value| value.nil? }.freeze,
+          children: children.freeze
+        )
+      end
+    end
+  end
+end
+

data/lib/boring_avatars/svg/serializer.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+require_relative "element"
+require_relative "value"
+
+module BoringAvatars
+  module Svg
+    module Serializer
+      module_function
+
+      def call(element)
+        serialize_element(element).force_encoding(Encoding::UTF_8)
+      end
+
+      def valid_xml_string?(value)
+        value.valid_encoding? && value.codepoints.all? do |codepoint|
+          codepoint == 0x09 || codepoint == 0x0A || codepoint == 0x0D ||
+            codepoint.between?(0x20, 0xD7FF) ||
+            codepoint.between?(0xE000, 0xFFFD) ||
+            codepoint.between?(0x10000, 0x10FFFF)
+        end
+      end
+
+      def escape(value)
+        string = value.to_s
+        raise ArgumentError, "value contains characters forbidden by XML 1.0" unless valid_xml_string?(string)
+
+        string
+          .gsub("&", "&")
+          .gsub("<", "&lt;")
+          .gsub(">", "&gt;")
+          .gsub('"', "&quot;")
+          .gsub("'", "&apos;")
+      end
+
+      def serialize_element(element)
+        attributes = element.attributes.map do |name, value|
+          %(#{name}="#{escape(attribute_value(value))}")
+        end
+        opening = attributes.empty? ? "<#{element.name}" : "<#{element.name} #{attributes.join(' ')}"
+
+        return "#{opening}/>" if element.children.empty?
+
+        content = element.children.map do |child|
+          child.is_a?(Element) ? serialize_element(child) : escape(child)
+        end.join
+        "#{opening}>#{content}</#{element.name}>"
+      end
+      private_class_method :serialize_element
+
+      def attribute_value(value)
+        case value
+        when String
+          value
+        when Numeric
+          Value.number(value)
+        when true, false
+          value.to_s
+        else
+          raise ArgumentError, "unsupported SVG attribute value: #{value.class}"
+        end
+      end
+      private_class_method :attribute_value
+    end
+  end
+end
+

data/lib/boring_avatars/svg/value.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module BoringAvatars
+  module Svg
+    module Value
+      module_function
+
+      def number(value)
+        return "0" if value.zero?
+        return value.to_i.to_s if value.is_a?(Float) && value.finite? && value == value.to_i
+
+        value.to_s
+      end
+    end
+  end
+end
+

data/lib/boring_avatars/utilities.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module BoringAvatars
+  module Utilities
+    module_function
+
+    def digit(number, position)
+      (number / (10**position)).floor % 10
+    end
+
+    def boolean(number, position)
+      digit(number, position).even?
+    end
+
+    def unit(number, range, position = nil)
+      value = number % range
+      position && !position.zero? && digit(number, position).even? ? -value : value
+    end
+
+    def random_color(number, colors)
+      colors[number % colors.length]
+    end
+
+    def contrast(color)
+      red = color[1, 2].to_i(16)
+      green = color[3, 2].to_i(16)
+      blue = color[5, 2].to_i(16)
+      yiq = ((red * 299) + (green * 587) + (blue * 114)) / 1000.0
+
+      yiq >= 128 ? "#000000" : "#FFFFFF"
+    end
+  end
+end
+

data/lib/boring_avatars/variants/bauhaus.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+require_relative "../utilities"
+require_relative "../variants"
+
+module BoringAvatars
+  module Variants
+    module Bauhaus
+      extend VariantHelpers
+
+      SIZE = 80
+      ELEMENTS = 4
+
+      module_function
+
+      def render(input:, hash:, ids:)
+        properties = Array.new(ELEMENTS) do |index|
+          multiplier = index + 1
+          {
+            color: Utilities.random_color(hash + index, input.colors),
+            translate_x: Utilities.unit(hash * multiplier, (SIZE / 2) - (index + 17), 1),
+            translate_y: Utilities.unit(hash * multiplier, (SIZE / 2) - (index + 17), 2),
+            rotate: Utilities.unit(hash * multiplier, 360),
+            square: Utilities.boolean(hash, 2)
+          }
+        end
+
+        content = [
+          element("rect", { "width" => SIZE, "height" => SIZE, "fill" => properties[0][:color] }),
+          element(
+            "rect",
+            {
+              "x" => (SIZE - 60) / 2,
+              "y" => (SIZE - 20) / 2,
+              "width" => SIZE,
+              "height" => properties[1][:square] ? SIZE : SIZE / 8,
+              "fill" => properties[1][:color],
+              "transform" => transform(properties[1])
+            }
+          ),
+          element(
+            "circle",
+            {
+              "cx" => SIZE / 2,
+              "cy" => SIZE / 2,
+              "fill" => properties[2][:color],
+              "r" => SIZE / 5,
+              "transform" => "translate(#{number(properties[2][:translate_x])} #{number(properties[2][:translate_y])})"
+            }
+          ),
+          element(
+            "line",
+            {
+              "x1" => 0,
+              "y1" => SIZE / 2,
+              "x2" => SIZE,
+              "y2" => SIZE / 2,
+              "stroke-width" => 2,
+              "stroke" => properties[3][:color],
+              "transform" => transform(properties[3])
+            }
+          )
+        ]
+
+        VariantResult.new(size: SIZE, content: content)
+      end
+
+      def transform(property)
+        "translate(#{number(property[:translate_x])} #{number(property[:translate_y])}) " \
+          "rotate(#{number(property[:rotate])} #{SIZE / 2} #{SIZE / 2})"
+      end
+      private_class_method :transform
+    end
+  end
+end
+

data/lib/boring_avatars/variants/beam.rb

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+require_relative "../utilities"
+require_relative "../variants"
+
+module BoringAvatars
+  module Variants
+    module Beam
+      extend VariantHelpers
+
+      SIZE = 36
+
+      module_function
+
+      def render(input:, hash:, ids:)
+        data = generate_data(hash, input.colors)
+        content = [
+          element("rect", { "width" => SIZE, "height" => SIZE, "fill" => data[:background_color] }),
+          element(
+            "rect",
+            {
+              "x" => 0,
+              "y" => 0,
+              "width" => SIZE,
+              "height" => SIZE,
+              "transform" => wrapper_transform(data),
+              "fill" => data[:wrapper_color],
+              "rx" => data[:is_circle] ? SIZE : SIZE / 6
+            }
+          ),
+          element("g", { "transform" => face_transform(data) }, face_elements(data))
+        ]
+
+        VariantResult.new(size: SIZE, content: content)
+      end
+
+      def generate_data(hash, colors)
+        wrapper_color = Utilities.random_color(hash, colors)
+        pre_translate_x = Utilities.unit(hash, 10, 1)
+        wrapper_translate_x = pre_translate_x < 5 ? pre_translate_x + (SIZE / 9) : pre_translate_x
+        pre_translate_y = Utilities.unit(hash, 10, 2)
+        wrapper_translate_y = pre_translate_y < 5 ? pre_translate_y + (SIZE / 9) : pre_translate_y
+
+        {
+          wrapper_color: wrapper_color,
+          face_color: Utilities.contrast(wrapper_color),
+          background_color: Utilities.random_color(hash + 13, colors),
+          wrapper_translate_x: wrapper_translate_x,
+          wrapper_translate_y: wrapper_translate_y,
+          wrapper_rotate: Utilities.unit(hash, 360),
+          wrapper_scale: 1 + (Utilities.unit(hash, SIZE / 12) / 10.0),
+          is_mouth_open: Utilities.boolean(hash, 2),
+          is_circle: Utilities.boolean(hash, 1),
+          eye_spread: Utilities.unit(hash, 5),
+          mouth_spread: Utilities.unit(hash, 3),
+          face_rotate: Utilities.unit(hash, 10, 3),
+          face_translate_x: wrapper_translate_x > SIZE / 6 ? wrapper_translate_x / 2.0 : Utilities.unit(hash, 8, 1),
+          face_translate_y: wrapper_translate_y > SIZE / 6 ? wrapper_translate_y / 2.0 : Utilities.unit(hash, 7, 2)
+        }
+      end
+      private_class_method :generate_data
+
+      def wrapper_transform(data)
+        "translate(#{number(data[:wrapper_translate_x])} #{number(data[:wrapper_translate_y])}) " \
+          "rotate(#{number(data[:wrapper_rotate])} #{SIZE / 2} #{SIZE / 2}) " \
+          "scale(#{number(data[:wrapper_scale])})"
+      end
+      private_class_method :wrapper_transform
+
+      def face_transform(data)
+        "translate(#{number(data[:face_translate_x])} #{number(data[:face_translate_y])}) " \
+          "rotate(#{number(data[:face_rotate])} #{SIZE / 2} #{SIZE / 2})"
+      end
+      private_class_method :face_transform
+
+      def face_elements(data)
+        mouth_y = 19 + data[:mouth_spread]
+        mouth = if data[:is_mouth_open]
+                  element(
+                    "path",
+                    {
+                      "d" => "M15 #{number(mouth_y)}c2 1 4 1 6 0",
+                      "stroke" => data[:face_color],
+                      "fill" => "none",
+                      "stroke-linecap" => "round"
+                    }
+                  )
+                else
+                  element(
+                    "path",
+                    {
+                      "d" => "M13,#{number(mouth_y)} a1,0.75 0 0,0 10,0",
+                      "fill" => data[:face_color]
+                    }
+                  )
+                end
+
+        [
+          mouth,
+          element(
+            "rect",
+            {
+              "x" => 14 - data[:eye_spread],
+              "y" => 14,
+              "width" => 1.5,
+              "height" => 2,
+              "rx" => 1,
+              "stroke" => "none",
+              "fill" => data[:face_color]
+            }
+          ),
+          element(
+            "rect",
+            {
+              "x" => 20 + data[:eye_spread],
+              "y" => 14,
+              "width" => 1.5,
+              "height" => 2,
+              "rx" => 1,
+              "stroke" => "none",
+              "fill" => data[:face_color]
+            }
+          )
+        ]
+      end
+      private_class_method :face_elements
+    end
+  end
+end
+

data/lib/boring_avatars/variants/marble.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+require_relative "../utilities"
+require_relative "../variants"
+
+module BoringAvatars
+  module Variants
+    module Marble
+      extend VariantHelpers
+
+      SIZE = 80
+      ELEMENTS = 3
+      FIRST_PATH = "M32.414 59.35L50.376 70.5H72.5v-71H33.728L26.5 13.381l19.057 27.08L32.414 59.35z"
+      SECOND_PATH = "M22.216 24L0 46.75l14.108 38.129L78 86l-3.081-59.276-22.378 4.005 12.972 20.186-23.35 27.395L22.215 24z"
+
+      module_function
+
+      def render(input:, hash:, ids:)
+        properties = Array.new(ELEMENTS) do |index|
+          multiplier = index + 1
+          {
+            color: Utilities.random_color(hash + index, input.colors),
+            translate_x: Utilities.unit(hash * multiplier, SIZE / 10, 1),
+            translate_y: Utilities.unit(hash * multiplier, SIZE / 10, 2),
+            scale: 1.2 + (Utilities.unit(hash * multiplier, SIZE / 20) / 10.0),
+            rotate: Utilities.unit(hash * multiplier, 360, 1)
+          }
+        end
+
+        content = [
+          element("rect", { "width" => SIZE, "height" => SIZE, "fill" => properties[0][:color] }),
+          element(
+            "path",
+            {
+              "filter" => "url(##{ids[:filter]})",
+              "d" => FIRST_PATH,
+              "fill" => properties[1][:color],
+              "transform" => transform(properties[1], properties[2][:scale])
+            }
+          ),
+          element(
+            "path",
+            {
+              "filter" => "url(##{ids[:filter]})",
+              "style" => "mix-blend-mode:overlay",
+              "d" => SECOND_PATH,
+              "fill" => properties[2][:color],
+              "transform" => transform(properties[2], properties[2][:scale])
+            }
+          )
+        ]
+
+        filter = element(
+          "filter",
+          {
+            "id" => ids[:filter],
+            "filterUnits" => "userSpaceOnUse",
+            "color-interpolation-filters" => "sRGB"
+          },
+          [
+            element("feFlood", { "flood-opacity" => 0, "result" => "BackgroundImageFix" }),
+            element(
+              "feBlend",
+              { "in" => "SourceGraphic", "in2" => "BackgroundImageFix", "result" => "shape" }
+            ),
+            element(
+              "feGaussianBlur",
+              { "stdDeviation" => 7, "result" => "effect1_foregroundBlur" }
+            )
+          ]
+        )
+
+        VariantResult.new(size: SIZE, content: content, defs: [filter])
+      end
+
+      def transform(property, scale)
+        "translate(#{number(property[:translate_x])} #{number(property[:translate_y])}) " \
+          "rotate(#{number(property[:rotate])} #{SIZE / 2} #{SIZE / 2}) " \
+          "scale(#{number(scale)})"
+      end
+      private_class_method :transform
+    end
+  end
+end
+

data/lib/boring_avatars/variants/pixel.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require_relative "../utilities"
+require_relative "../variants"
+
+module BoringAvatars
+  module Variants
+    module Pixel
+      extend VariantHelpers
+
+      SIZE = 80
+      ELEMENTS = 64
+      TOP_ROW_X = [0, 20, 40, 60, 10, 30, 50, 70].freeze
+      COLUMN_X = [0, 20, 40, 60, 10, 30, 50, 70].freeze
+      Y_COORDINATES = (10..70).step(10).to_a.freeze
+      COORDINATES = (
+        TOP_ROW_X.map { |x| [x, 0] } +
+        COLUMN_X.flat_map { |x| Y_COORDINATES.map { |y| [x, y] } }
+      ).freeze
+
+      module_function
+
+      def render(input:, hash:, ids:)
+        colors = Array.new(ELEMENTS) do |index|
+          Utilities.random_color(hash % (index + 1), input.colors)
+        end
+        content = COORDINATES.each_with_index.map do |(x, y), index|
+          element(
+            "rect",
+            {
+              "x" => x.zero? ? nil : x,
+              "y" => y.zero? ? nil : y,
+              "width" => 10,
+              "height" => 10,
+              "fill" => colors[index]
+            }
+          )
+        end
+
+        VariantResult.new(
+          size: SIZE,
+          content: content,
+          mask_attributes: { "mask-type" => "alpha" }
+        )
+      end
+    end
+  end
+end
+

data/lib/boring_avatars/variants/ring.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require_relative "../utilities"
+require_relative "../variants"
+
+module BoringAvatars
+  module Variants
+    module Ring
+      extend VariantHelpers
+
+      SIZE = 90
+      COLORS = 5
+      PATHS = [
+        "M0 0h90v45H0z",
+        "M0 45h90v45H0z",
+        "M83 45a38 38 0 00-76 0h76z",
+        "M83 45a38 38 0 01-76 0h76z",
+        "M77 45a32 32 0 10-64 0h64z",
+        "M77 45a32 32 0 11-64 0h64z",
+        "M71 45a26 26 0 00-52 0h52z",
+        "M71 45a26 26 0 01-52 0h52z"
+      ].freeze
+
+      module_function
+
+      def render(input:, hash:, ids:)
+        shuffled = Array.new(COLORS) { |index| Utilities.random_color(hash + index, input.colors) }
+        colors = [
+          shuffled[0], shuffled[1], shuffled[1], shuffled[2], shuffled[2],
+          shuffled[3], shuffled[3], shuffled[0], shuffled[4]
+        ]
+        content = PATHS.each_with_index.map do |path, index|
+          element("path", { "d" => path, "fill" => colors[index] })
+        end
+        content << element("circle", { "cx" => 45, "cy" => 45, "r" => 23, "fill" => colors[8] })
+
+        VariantResult.new(size: SIZE, content: content)
+      end
+    end
+  end
+end
+

data/lib/boring_avatars/variants/sunset.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require_relative "../utilities"
+require_relative "../variants"
+
+module BoringAvatars
+  module Variants
+    module Sunset
+      extend VariantHelpers
+
+      SIZE = 80
+      ELEMENTS = 4
+
+      module_function
+
+      def render(input:, hash:, ids:)
+        colors = Array.new(ELEMENTS) { |index| Utilities.random_color(hash + index, input.colors) }
+        content = [
+          element(
+            "path",
+            { "fill" => "url(##{ids[:gradient_0]})", "d" => "M0 0h80v40H0z" }
+          ),
+          element(
+            "path",
+            { "fill" => "url(##{ids[:gradient_1]})", "d" => "M0 40h80v40H0z" }
+          )
+        ]
+        defs = [
+          gradient(ids[:gradient_0], 0, SIZE / 2, colors[0], colors[1]),
+          gradient(ids[:gradient_1], SIZE / 2, SIZE, colors[2], colors[3])
+        ]
+
+        VariantResult.new(size: SIZE, content: content, defs: defs)
+      end
+
+      def gradient(id, y1, y2, start_color, end_color)
+        element(
+          "linearGradient",
+          {
+            "id" => id,
+            "x1" => SIZE / 2,
+            "y1" => y1,
+            "x2" => SIZE / 2,
+            "y2" => y2,
+            "gradientUnits" => "userSpaceOnUse"
+          },
+          [
+            element("stop", { "stop-color" => start_color }),
+            element("stop", { "offset" => 1, "stop-color" => end_color })
+          ]
+        )
+      end
+      private_class_method :gradient
+    end
+  end
+end
+