class PrawnHtml::Attributes

def apply_rule!(merged_styles:, rule:, value:, options:)

def apply_rule!(merged_styles:, rule:, value:, options:)
  return (@initial << rule) if value == 'initial'
  if rule[:set] == :append_styles
    val = Utils.normalize_style(value, rule[:values])
    (merged_styles[rule[:key]] ||= []) << val if val
  else
    opts = rule[:options] ? options[rule[:options]] : nil
    val = Utils.send(rule[:set], value, options: opts)
    merged_styles[rule[:key]] = val if val
  end
end

def data

Returns:
  • (Hash) - hash of data attributes with 'data-' prefix removed and stripped values
def data
  to_h.each_with_object({}) do |(key, value), res|
    data_key = key.match /\Adata-(.+)/
    res[data_key[1]] = value.strip if data_key
  end
end

def evaluate_rule(rule_key, attr_value)

def evaluate_rule(rule_key, attr_value)
  key = nil
  key = 'text-decoration-line-through' if rule_key == 'text-decoration' && attr_value == 'line-through'
  key ||= rule_key
  STYLES_LIST[key]
end

def initialize(attributes = {})

Init the Attributes
def initialize(attributes = {})
  super
  @styles = {} # result styles
  @initial = Set.new
end

def merge_attr!(attributes, key, value)

Returns:
  • (Hash) - the updated hash of attributes

Parameters:
  • value () --
  • key (Symbol) -- key
  • attributes (Hash) -- target attributes hash
def merge_attr!(attributes, key, value)
  return unless key
  return (attributes[key] = value) unless Attributes::STYLES_MERGE.include?(key)
  attributes[key] ||= 0
  attributes[key] += value
end

def merge_text_styles!(text_styles, options: {})

Parameters:
  • options (Hash) -- options (container width/height/etc.)
  • text_styles (String) -- styles to parse and process
def merge_text_styles!(text_styles, options: {})
  hash_styles = Attributes.parse_styles(text_styles)
  process_styles(hash_styles, options: options) unless hash_styles.empty?
end

def parse_styles(styles)

Returns:
  • (Hash) - hash of styles

Parameters:
  • styles (String) -- styles to parse
def parse_styles(styles)
  (styles || '').scan(/\s*([^:;]+)\s*:\s*([^;]+)\s*/).to_h
end

def process_styles(hash_styles, options:)

def process_styles(hash_styles, options:)
  hash_styles.each do |key, value|
    rule = evaluate_rule(key, value)
    next unless rule
    apply_rule!(merged_styles: @styles, rule: rule, value: value, options: options)
  end
  @styles
end

def remove_value(context_styles, rule)

Parameters:
  • rule (Hash) -- rule from the STYLES_LIST to lookup in the context style for value removal
  • context_styles (Hash) -- hash of the context styles that will be updated
def remove_value(context_styles, rule)
  if rule[:set] == :append_styles
    context_styles[rule[:key]] -= rule[:values] if context_styles[:styles]
  else
    default = Context::DEFAULT_STYLES[rule[:key]]
    default ? (context_styles[rule[:key]] = default) : context_styles.delete(rule[:key])
  end
end

def update_styles(context_styles)

Returns:
  • (Hash) - the update context styles

Parameters:
  • context_styles (Hash) -- hash of the context styles that will be updated
def update_styles(context_styles)
  initial.each do |rule|
    next unless rule
    remove_value(context_styles, rule)
  end
  context_styles
end