model.py

# Copyright 2022 The Chromium Authors
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.

import re
import collections
from style_variable_generator.color import ColorRGB, ParseColor, ColorBlend, ColorRGBVar, ColorVar
from style_variable_generator.opacity import Opacity
from abc import ABC, abstractmethod


def full_token_name(name, context):
    namespace = context['token_namespace']
    if namespace:
        return f'{namespace}.{name}'
    return name


class Modes:
    LIGHT = 'light'
    DARK = 'dark'
    DEBUG = 'debug'
    # The mode that colors will fallback to when not specified in a
    # non-default mode. An error will be raised if a color in any mode is
    # not specified in the default mode.
    DEFAULT = LIGHT
    ALL = [LIGHT, DARK, DEBUG]


class VariableType:
    COLOR = 'color'
    OPACITY = 'opacity'
    UNTYPED_CSS = 'untyped_css'
    TYPEFACE = 'typeface'
    FONT_FAMILY = 'font_family'
    FONT_FACE = 'font_face'
    LEGACY_MAPPING = 'legacy_mappings'


class StyleVariable(object):
    '''An intermediate representation of a single variable that the generator
       knows about.

       Some JSON entries will generate multiple StyleVariables (e.g when
       generate_per_mode is true), and different Generators may create multiple
       per-platform variables (e.g CSS generates an var and var-rgb).
    '''

    def __init__(self, variable_type, name, json_value, context):
        if not re.match(r'^[a-z0-9_\.\-]+$', name):
            raise ValueError(name + ' is not a valid variable name ' +
                             '(lower case, 0-9, _)')
        self.variable_type = variable_type
        self.name = name
        self.json_value = json_value
        self.context = context or {}


class Submodel(ABC):
    '''Abstract Base Class for all Submodels.'''

    @abstractmethod
    def Add(self, name, value_obj, context):
        '''Adds the a variable represented by |value_obj| to the submodel.
        Returns a list of |StyleVariable| objects representing the variables
        added.
        '''
        assert False

    # Submodels are expected to provide dict-like interfaces.
    @abstractmethod
    def keys(self):
        assert False

    @abstractmethod
    def items(self):
        assert False

    @abstractmethod
    def __getitem__(self, key):
        assert False


class ModeKeyedModel(collections.OrderedDict, Submodel):
    def __init__(self):
        # A map of all variables to their |StyleVariable| object.
        self.variable_map = dict()

    def Add(self, name, value_obj, context):
        if name not in self:
            self[name] = {}

        if isinstance(value_obj, dict):
            for mode in value_obj:
                value = self._CreateValue(value_obj[mode])
                if mode == 'default':
                    mode = Modes.DEFAULT
                assert mode in Modes.ALL, f"Invalid mode '{mode}' used in' \
                    'definition for '{name}'"

                assert mode not in self[
                    name], f"{mode} mode for '{name}' defined multiple times"
                self[name][mode] = value
        else:
            self[name][Modes.DEFAULT] = self._CreateValue(value_obj)

        variable = StyleVariable(self.variable_type, name, value_obj, context)
        self.variable_map[name] = variable
        return [variable]

    # Returns the value that |name| will have in |mode|. Resolves to the default
    # mode's value if the a value for |mode| isn't specified. Always returns a
    # value.
    def Resolve(self, name, mode):
        if mode in self[name]:
            return self[name][mode]

        return self[name][Modes.DEFAULT]

    def Flatten(self, resolve_missing=False):
        '''Builds a name to variable dictionary for each mode.
        If |resolve_missing| is true, colors that aren't specified in |mode|
        will be resolved to their default mode value.'''
        flattened = {}
        for mode in Modes.ALL:
            variables = collections.OrderedDict()
            for name, mode_values in self.items():
                if resolve_missing:
                    variables[name] = self.Resolve(name, mode)
                else:
                    if mode in mode_values:
                        variables[name] = mode_values[mode]
            flattened[mode] = variables

        return flattened


class OpacityModel(ModeKeyedModel):
    '''A dictionary of opacity names to their values in each mode.
       e.g OpacityModel['disabled_opacity'][Modes.LIGHT] = Opacity(...)
    '''

    def __init__(self):
        super().__init__()
        self.variable_type = VariableType.OPACITY

    def Add(self, name, value_obj, context):
        name = full_token_name(name, context)
        return super().Add(name, value_obj, context)

    # Returns a float from 0-1 representing the concrete value of |opacity|.
    def ResolveOpacity(self, opacity, mode):
        if opacity.a != -1:
            return opacity

        return self.ResolveOpacity(self.Resolve(opacity.var, mode), mode)

    def _CreateValue(self, value):
        return Opacity(value)


class ColorModel(ModeKeyedModel):
    '''A dictionary of color names to their values in each mode.
       e.g ColorModel['blue'][Modes.LIGHT] = Color(...)
    '''

    def __init__(self, opacity_model):
        super().__init__()
        self.opacity_model = opacity_model
        self.variable_type = VariableType.COLOR

    def Add(self, name, value_obj, context):
        added = []
        # If a color has generate_per_mode set, a separate variable will be
        # created for each mode, suffixed by mode name.
        # (e.g my_color_light, my_color_debug)
        generate_per_mode = False
        # If a color has generate_inverted set, a |color_name|_inverted will be
        # generated which uses the dark color for light mode and vice versa.
        generate_inverted = False
        if isinstance(value_obj, dict):
            generate_per_mode = value_obj.pop('generate_per_mode', None)
            generate_inverted = value_obj.pop('generate_inverted', None)
        elif isinstance(self._CreateValue(value_obj), ColorBlend):
            # A blended color could evaluate to different colors in different
            # modes, so add it to all the modes.
            value_obj = {mode: value_obj for mode in Modes.ALL}

        generated_context = dict(context)
        generated_context['generated'] = True

        if generate_per_mode or generate_inverted:
            for mode, value in value_obj.items():
                per_mode_name = name + '_' + mode
                added += ModeKeyedModel.Add(self, per_mode_name, value,
                                            generated_context)
                value_obj[mode] = '$' + per_mode_name
        if generate_inverted:
            if Modes.LIGHT not in value_obj or Modes.DARK not in value_obj:
                raise ValueError(
                    'generate_inverted requires both dark and light modes to be'
                    ' set')
            added += ModeKeyedModel.Add(
                self, name + '_inverted', {
                    Modes.LIGHT: '$' + name + '_dark',
                    Modes.DARK: '$' + name + '_light'
                }, generated_context)

        added += ModeKeyedModel.Add(self, name, value_obj, context)
        return added

    # Returns a Color that is the final RGBA value for |name| in |mode|.
    def ResolveToRGBA(self, name, mode):
        return self._ResolveColorToRGBA(self.Resolve(name, mode), mode)

    # Returns a Color that is the hexadecimal string for |name| in |mode|.
    def ResolveToHexString(self, name, mode):
        color = self._ResolveColorToRGBA(self.Resolve(name, mode), mode)
        opacity = int(float(repr(color.opacity)) * 255)
        return '#{:02x}{:02x}{:02x}{:02x}'.format(color.r, color.g, color.b,
                                                  opacity)

    # Returns a Color that is the final RGBA value for |color| in |mode|.
    def _ResolveColorToRGBA(self, color, mode):
        if isinstance(color, ColorVar):
            return self.ResolveToRGBA(color.var, mode)

        if isinstance(color, ColorBlend) and len(color.blended_colors) == 2:
            return self._BlendColors(color.blended_colors[0],
                                     color.blended_colors[1], mode)

        result = ColorRGB()
        assert color.opacity
        result.opacity = self.opacity_model.ResolveOpacity(color.opacity, mode)

        rgb = color
        if isinstance(color, ColorRGBVar):
            rgb = self.ResolveToRGBA(color.ToVar(), mode)

        (result.r, result.g, result.b) = (rgb.r, rgb.g, rgb.b)
        return result

    def _ProcessBlendedColors(self, default_preblend):
        # Calculate the final RGBA for all blended colors because the
        # generator's subclasses can't blend yet.
        temp_model = {}
        for name, value in self.items():
            for mode, color in value.items():
                context = self.variable_map[name].context
                should_preblend = context.get('CSS',
                                              {}).get('preblend',
                                                      default_preblend)
                if isinstance(color, ColorBlend) and should_preblend:
                    assert len(color.blended_colors) == 2
                    if name not in temp_model:
                        temp_model[name] = {}
                    temp_model[name][mode] = self.ResolveToRGBA(name, mode)

        for name, value in temp_model.items():
            for mode, color in value.items():
                self[name][mode] = temp_model[name][mode]

    # Returns a Color that is the final RGBA value for |color_a| over |color_b|
    # in |mode|.
    def _BlendColors(self, color_a, color_b, mode):
        # TODO(b/206887565): Check for circular references.
        color_a_res = self._ResolveColorToRGBA(color_a, mode)
        (alpha_a, r_a, g_a, b_a) = (color_a_res.opacity.a, color_a_res.r,
                                    color_a_res.g, color_a_res.b)
        color_b_res = self._ResolveColorToRGBA(color_b, mode)
        (alpha_b, r_b, g_b, b_b) = (color_b_res.opacity.a, color_b_res.r,
                                    color_b_res.g, color_b_res.b)

        # Blend using the formula for "A over B" from
        # https://wikipedia.org/wiki/Alpha_compositing.
        alpha_out = alpha_a + (alpha_b * (1 - alpha_a))
        r_out = round(
            (r_a * alpha_a + r_b * alpha_b * (1 - alpha_a)) / alpha_out)
        g_out = round(
            (g_a * alpha_a + g_b * alpha_b * (1 - alpha_a)) / alpha_out)
        b_out = round(
            (b_a * alpha_a + b_b * alpha_b * (1 - alpha_a)) / alpha_out)

        return ColorRGB((r_out, g_out, b_out), Opacity(alpha_out))

    def _CreateValue(self, value):
        return ParseColor(value) or ColorRGB()


class SimpleModel(collections.OrderedDict, Submodel):
    def __init__(self, variable_type, check_func=None):
        self.variable_type = variable_type
        self.check_func = check_func

    def Add(self, name, value_obj, context):
        if self.check_func:
            self.check_func(name, value_obj, context)
        self[name] = value_obj
        return [StyleVariable(self.variable_type, name, value_obj, context)]


# A simple model where all variables are prefixed with the current namespace.
class NamespacedModel(SimpleModel):
    def Add(self, name, value_obj, context):
        name = full_token_name(name, context)
        return super().Add(name, value_obj, context)


# A color model where all variables are prefixed with the current namespace.
class NamespacedColorModel(ColorModel):
    def Add(self, name, value_obj, context):
        name = full_token_name(name, context)
        return super().Add(name, value_obj, context)


# A color model specifically for storing mappings of arbitrary css vars to some
# known StyleVariable.
class LegacyMappingsModel(ColorModel):
    def Add(self, name, value_obj, context):
        if isinstance(value_obj, dict):
            raise ValueError(
                'Legacy mappings can only be singular references.')
        return super().Add(name, value_obj, context)


class Model(object):
    def __init__(self):
        # A map of all variables to their |StyleVariable| object.
        self.variable_map = dict()

        # A map of |VariableType| to its underlying model.
        self.submodels = dict()

        self.opacities = OpacityModel()
        self.submodels[VariableType.OPACITY] = self.opacities

        self.colors = NamespacedColorModel(self.opacities)
        self.submodels[VariableType.COLOR] = self.colors

        self.untyped_css = NamespacedModel(VariableType.UNTYPED_CSS)
        self.submodels[VariableType.UNTYPED_CSS] = self.untyped_css

        self.legacy_mappings = LegacyMappingsModel(self.opacities)
        self.submodels[VariableType.LEGACY_MAPPING] = self.legacy_mappings

        def CheckTypeFace(name, value_obj, context):
            assert value_obj['font_family']
            assert value_obj['font_size']
            assert value_obj['font_weight']
            assert value_obj['line_height']

        self.typefaces = NamespacedModel(VariableType.TYPEFACE, CheckTypeFace)
        self.submodels[VariableType.TYPEFACE] = self.typefaces

        def CheckFontFamily(name, value_obj, context):
            assert name.startswith('font_family_')

        self.font_families = NamespacedModel(VariableType.FONT_FAMILY,
                                             CheckFontFamily)
        self.submodels[VariableType.FONT_FAMILY] = self.font_families

        def CheckFontFace(name, value_obj, context):
            assert name.startswith('face_')

        self.font_faces = NamespacedModel(VariableType.FONT_FACE,
                                          CheckFontFace)
        self.submodels[VariableType.FONT_FACE] = self.font_faces

    def Add(self, variable_type, name, value_obj, context):
        '''Adds a new variable to the submodel for |variable_type|.
        '''
        try:
            added = self.submodels[variable_type].Add(name, value_obj, context)
        except ValueError as err:
            raise ValueError(
                f'Error parsing {variable_type} "{name}": {value_obj}'
            ) from err

        for var in added:
            if var.name in self.variable_map:
                raise ValueError('Variable name "%s" is reused' % name)
            self.variable_map[var.name] = var


    def PostProcess(self, default_preblend=True):
        '''Called after all variables have been added to perform operations that
           require a complete worldview.
        '''

        # Resolve blended colors after all the files are added because some
        # color dependencies are between different files.
        self.colors._ProcessBlendedColors(default_preblend)

        self.Validate()

    def Validate(self):
        colors = self.colors
        color_names = set(colors.keys())
        opacities = self.opacities
        opacity_names = set(opacities.keys())

        def CheckColorReference(name, referrer):
            if name == referrer:
                raise ValueError("{0} refers to itself".format(name))
            if name not in color_names:
                raise ValueError("Cannot find color %s referenced by %s" %
                                 (name, referrer))

        def CheckOpacityReference(name, referrer):
            if name == referrer:
                raise ValueError("{0} refers to itself".format(name))
            if name not in opacity_names:
                raise ValueError("Cannot find opacity %s referenced by %s" %
                                 (name, referrer))

        def CheckColor(color, name):
            if isinstance(color, ColorVar):
                CheckColorReference(color.var, name)
            if isinstance(color, ColorRGBVar):
                CheckColorReference(color.ToVar(), name)
            if isinstance(color,
                          (ColorRGB, ColorRGBVar)) and color.opacity.var:
                CheckOpacityReference(color.opacity.var, name)
            if isinstance(color, ColorBlend):
                assert len(color.blended_colors) == 2
                CheckColor(color.blended_colors[0], name)
                CheckColor(color.blended_colors[1], name)

        RESERVED_SUFFIXES = ['_' + s for s in Modes.ALL + ['rgb', 'inverted']]

        # Check all colors in all modes refer to colors that exist in the
        # default mode.
        for name, mode_values in colors.items():
            for suffix in RESERVED_SUFFIXES:
                if not self.variable_map[name].context.get(
                        'generated') and name.endswith(suffix):
                    raise ValueError(
                        'Variable name "%s" uses a reserved suffix: %s' %
                        (name, suffix))
            if Modes.DEFAULT not in mode_values:
                raise ValueError("Color %s not defined for default mode" %
                                 name)

            for mode, color in mode_values.items():
                CheckColor(color, name)

        for name, mode_values in opacities.items():
            for mode, opacity in mode_values.items():
                if opacity.var:
                    CheckOpacityReference(opacity.var, name)

        # TODO(b/206887565): Check for circular references.