Class: SlateSerializer::Html

Inherits:
Object
  • Object
show all
Defined in:
lib/slate_serializer/html.rb

Overview

Html de- and serializer

Defined Under Namespace

Classes: SerializerHandler

Constant Summary collapse

ELEMENTS =

Default lookup list to convert html tags to object types

{
  'a': 'link',
  'img': 'image',
  'li': 'list-item',
  'p': 'paragraph',
  'div': 'paragraph',
  'ol1': 'ordered-list',
  'ol': 'ordered-list',
  'ul': 'unordered-list',
  'table': 'table',
  'tbody': 'tbody',
  'tr': 'tr',
  'td': 'td',
  'text': 'text',
  'hr': 'hr',
  'figure': 'figure',
  'figcaption': 'figcaption'
}.freeze
BLOCK_ELEMENTS =

Default block types list

%w[figure figcaption hr img li p ol ul table tbody tr td].freeze
INLINE_ELEMENTS =

Default inline types list

%w[a].freeze
MARK_ELEMENTS =

Default mark types list

{
  'em': 'italic',
  'strong': 'bold',
  'b': 'bold',
  'u': 'underline'
}.freeze

Instance Method Summary collapse

Constructor Details

#initialize(options = {}) ⇒ Html

Returns a new instance of Html.



37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
 
# File 'lib/slate_serializer/html.rb', line 37

def initialize(options = {})
  @elements = options[:elements] || ELEMENTS
  @block_elements = options[:block_elements] || BLOCK_ELEMENTS
  @inline_elements = options[:inline_elements] || INLINE_ELEMENTS
  @mark_elements = options[:mark_elements] || MARK_ELEMENTS
  @element_register = {}
  @node_register = {}
  @tag_register = {}
  
  (options[:handlers] || [
    SerializerHandler.new(
      elements: ['img'], 
      node: 'image', 
      serialize: ->(node, children, tag) do
        "<#{tag} src=\"#{node[:url]}\"/>" 
      end
    ),
    SerializerHandler.new(
      elements: ['hr'], 
      node: 'hr', 
      serialize: ->(node, children, tag) do
        "<#{tag}/>" 
      end
    ),
    SerializerHandler.new(elements: ['text']),
    SerializerHandler.new(elements: ['i', 'em'], mark: 'italic'),
    SerializerHandler.new(elements: ['u'], mark: 'underline'),
    SerializerHandler.new(elements: ['strong', 'b'], mark: 'bold'),
    SerializerHandler.new(elements: ['a'], node: 'link'),
    SerializerHandler.new(elements: ['ol'], node: 'ordered-list'),
    SerializerHandler.new(elements: ['ul'], node: 'unordered-list'),
    SerializerHandler.new(elements: ['li'], node: 'list-item'),
    SerializerHandler.new(elements: ['p', 'div'], node: 'paragraph'),
    SerializerHandler.new(elements: ['table'], node: 'table'),
    SerializerHandler.new(elements: ['tbody'], node: 'tbody'),
    SerializerHandler.new(elements: ['tr'], node: 'tr'),
    SerializerHandler.new(elements: ['td'], node: 'td'),
    SerializerHandler.new(elements: ['figure'], node: 'figure'),
    SerializerHandler.new(elements: ['figcaption'], node: 'figcaption'),
  ]).each do |handler|
    register_handler(handler)
  end
end

Instance Method Details

#deserialize(html) ⇒ Object

Convert html to a Slate document

Parameters:

  • html —

    format [String] the HTML

  • options (Hash) 


127
128
129
130
131
132
133
134
 
# File 'lib/slate_serializer/html.rb', line 127

def deserialize(html)
  return empty_state if html.nil? || html == ''

  html = html.gsub('<br>', "\n")
  Nokogiri::HTML.fragment(html).elements.flat_map do |element|
    element_to_node(element)
  end
end

#register_handler(handler) ⇒ Object 



81
82
83
84
85
86
87
 
# File 'lib/slate_serializer/html.rb', line 81

def register_handler(handler)
  handler.elements.each do |element|
    @element_register[element] = handler
  end
  @node_register[handler.node] = handler.serialize
  @tag_register[handler.node] = handler.elements.first
end

#serialize(value) ⇒ String

Convert html to a Slate document

Parameters:

  • value —

    format [Hash] the Slate document

Returns:

  • (String) —

    plain text version of the Slate documnent



113
114
115
116
117
 
# File 'lib/slate_serializer/html.rb', line 113

def serialize(value)
  return '' unless value.is_a?(Array)

  value.map { |n| serialize_node(n) }.join
end