lwe_slate_serializer 1.0.3 → 1.0.4

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
checksums.yaml CHANGED
@@ -1,7 +1,7 @@
1
1
  ---
2
2
  SHA256:
3
- metadata.gz: 8e9e8a5615362af2fc54a03f861b890df09ac66cc0f08eb1f315cb24001b7950
4
- data.tar.gz: ffa3f1e4c265f0d44ae3a59c37ed041aa6cc9e9bcf59d7ffa20a25632ae655f0
3
+ metadata.gz: ee065454439454fb5ea945ea83d59a254832b285211bb41e0d58e34a88e763c9
4
+ data.tar.gz: b30286ecdfa37885288a12f168353d80e63e3b0e5f91eb5387ca15829f103484
5
5
  SHA512:
6
- metadata.gz: 7d923f1c365e59685db17512e1a23767157c8806bcae0d0f6331c1800d64b08c5a6d90f598db7e82fc9f404dc7c26d264ff028abe419566de650faeae76b073d
7
- data.tar.gz: c80a64dc9a8fcd388b5b612cb08d0f7eb4faff8f00e4049d0726997c5bb28d9e71bfe1c2093a9d185082851683fc1a89db5d8815733b4f9b36ab89a761975174
6
+ metadata.gz: 7cbcd0f9bfdcdcad1e9f53d4a14fb2dfc2e50f6a095ef0b15e169746a899f9fc7b119cd6f2b88fcbee5e57eade53b4710179901a87e7300ae8cebbe7319438d0
7
+ data.tar.gz: 26f233a45d443c56d9ef108e27d372010367ad3f3c83259b39f09b15d0567d283ee31b25b5affcd7e0675d9d89d7b4ace3efe8e3bceedbcb848bfa1d1c1d200e
data/Gemfile.lock CHANGED
@@ -1,16 +1,18 @@
1
1
  PATH
2
2
  remote: .
3
3
  specs:
4
- lwe_slate_serializer (1.0.1)
4
+ slate_serializer (1.0.4)
5
5
  nokogiri (~> 1.11)
6
6
 
7
7
  GEM
8
8
  remote: https://rubygems.org/
9
9
  specs:
10
10
  diff-lcs (1.4.4)
11
- nokogiri (1.13.3-x86_64-darwin)
11
+ mini_portile2 (2.8.4)
12
+ nokogiri (1.15.4)
13
+ mini_portile2 (~> 2.8.2)
12
14
  racc (~> 1.4)
13
- racc (1.6.0)
15
+ racc (1.7.1)
14
16
  rake (13.0.3)
15
17
  rspec (3.10.0)
16
18
  rspec-core (~> 3.10.0)
@@ -31,9 +33,9 @@ PLATFORMS
31
33
 
32
34
  DEPENDENCIES
33
35
  bundler (~> 2.2)
34
- lwe_slate_serializer!
35
36
  rake (~> 13.0)
36
37
  rspec (~> 3.0)
38
+ slate_serializer!
37
39
 
38
40
  BUNDLED WITH
39
41
  2.2.22
@@ -11,6 +11,7 @@ module SlateSerializer
11
11
  'p': 'paragraph',
12
12
  'div': 'paragraph',
13
13
  'ol1': 'ordered-list',
14
+ 'ola': 'alpha-ordered-list',
14
15
  'ol': 'ordered-list',
15
16
  'ul': 'unordered-list',
16
17
  'table': 'table',
@@ -30,179 +31,157 @@ module SlateSerializer
30
31
  MARK_ELEMENTS = {
31
32
  'em': 'italic',
32
33
  'strong': 'bold',
33
- 'b': 'bold',
34
34
  'u': 'underline'
35
35
  }.freeze
36
36
 
37
- def initialize(options = {})
38
- @elements = options[:elements] || ELEMENTS
39
- @block_elements = options[:block_elements] || BLOCK_ELEMENTS
40
- @inline_elements = options[:inline_elements] || INLINE_ELEMENTS
41
- @mark_elements = options[:mark_elements] || MARK_ELEMENTS
42
- @element_register = {}
43
- @node_register = {}
44
- @tag_register = {}
45
-
46
- (options[:handlers] || [
47
- SerializerHandler.new(
48
- elements: ['img'],
49
- node: 'image',
50
- serialize: ->(node, children, tag) do
51
- "<#{tag} src=\"#{node[:url]}\"/>"
52
- end
53
- ),
54
- SerializerHandler.new(
55
- elements: ['hr'],
56
- node: 'hr',
57
- serialize: ->(node, children, tag) do
58
- "<#{tag}/>"
59
- end
60
- ),
61
- SerializerHandler.new(elements: ['text']),
62
- SerializerHandler.new(elements: ['i', 'em'], mark: 'italic'),
63
- SerializerHandler.new(elements: ['u'], mark: 'underline'),
64
- SerializerHandler.new(elements: ['strong', 'b'], mark: 'bold'),
65
- SerializerHandler.new(elements: ['a'], node: 'link'),
66
- SerializerHandler.new(elements: ['ol'], node: 'ordered-list'),
67
- SerializerHandler.new(elements: ['ul'], node: 'unordered-list'),
68
- SerializerHandler.new(elements: ['li'], node: 'list-item'),
69
- SerializerHandler.new(elements: ['p', 'div'], node: 'paragraph'),
70
- SerializerHandler.new(elements: ['table'], node: 'table'),
71
- SerializerHandler.new(elements: ['tbody'], node: 'tbody'),
72
- SerializerHandler.new(elements: ['tr'], node: 'tr'),
73
- SerializerHandler.new(elements: ['td'], node: 'td'),
74
- SerializerHandler.new(elements: ['figure'], node: 'figure'),
75
- SerializerHandler.new(elements: ['figcaption'], node: 'figcaption'),
76
- ]).each do |handler|
77
- register_handler(handler)
37
+ class << self
38
+ # Convert html to a Slate document
39
+ #
40
+ # @param html format [String] the HTML
41
+ # @param options [Hash]
42
+ # @option options [Array] :elements Lookup list to convert html tags to object types
43
+ # @option options [Array] :block_elemnts List of block types
44
+ # @option options [Array] :inline_elemnts List of inline types
45
+ # @option options [Array] :mark_elemnts List of mark types
46
+ def deserializer(html, options = {})
47
+ return empty_state if html.nil? || html == ''
48
+
49
+ self.elements = options[:elements] || ELEMENTS
50
+ self.block_elements = options[:block_elements] || BLOCK_ELEMENTS
51
+ self.inline_elements = options[:inline_elements] || INLINE_ELEMENTS
52
+ self.mark_elements = options[:mark_elements] || MARK_ELEMENTS
53
+
54
+ html = html.gsub('<br>', "\n")
55
+ Nokogiri::HTML.fragment(html).elements.map do |element|
56
+ element_to_node(element)
57
+ end
78
58
  end
79
- end
80
59
 
81
- def register_handler(handler)
82
- handler.elements.each do |element|
83
- @element_register[element] = handler
60
+ # Convert html to a Slate document
61
+ #
62
+ # @param value format [Hash] the Slate document
63
+ # @return [String] plain text version of the Slate documnent
64
+ def serializer(value)
65
+ return '' unless value.is_a?(Array)
66
+
67
+ value.map { |n| serialize_node(n) }.join
84
68
  end
85
- @node_register[handler.node] = handler.serialize
86
- @tag_register[handler.node] = handler.elements.first
87
- end
88
69
 
89
- class SerializerHandler
90
- attr_reader :elements, :node, :serialize, :deserialize, :mark
70
+ private
91
71
 
92
- def initialize(elements: [], node: nil, mark: nil, serialize: nil, deserialize: nil)
93
- @elements = elements
94
- @node = node
95
- @mark = mark
96
- @serialize = serialize || ->(node, children, tag) do
97
- "<#{tag}>#{children}</#{tag}>"
98
- end
99
- @deserialize = deserialize || ->(children, element) do
100
- if @node
101
- { type: @node, children: children }
102
- else
103
- children
72
+ attr_accessor :elements, :block_elements, :inline_elements, :mark_elements
73
+
74
+ def element_to_node(element)
75
+ type = convert_name_to_type(element)
76
+ children = element.children.flat_map do |child|
77
+ if block?(child)
78
+ element_to_node(child)
79
+ elsif inline?(child)
80
+ element_to_inline(child)
81
+ else
82
+ next if child.text.strip == ''
83
+
84
+ element_to_texts(child)
104
85
  end
105
- end
106
- end
107
- end
86
+ end.compact
108
87
 
109
- # Convert html to a Slate document
110
- #
111
- # @param value format [Hash] the Slate document
112
- # @return [String] plain text version of the Slate documnent
113
- def serialize(value)
114
- return '' unless value.is_a?(Array)
88
+ children << { text: '' } if children.empty? && type != 'image'
115
89
 
116
- value.map { |n| serialize_node(n) }.join
117
- end
90
+ node = {
91
+ children: children,
92
+ type: type
93
+ }
118
94
 
119
- # Convert html to a Slate document
120
- #
121
- # @param html format [String] the HTML
122
- # @param options [Hash]
123
- # @option options [Array] :elements Lookup list to convert html tags to object types
124
- # @option options [Array] :block_elemnts List of block types
125
- # @option options [Array] :inline_elemnts List of inline types
126
- # @option options [Array] :mark_elemnts List of mark types
127
- def deserialize(html)
128
- return empty_state if html.nil? || html == ''
129
-
130
- html = html.gsub('<br>', "\n")
131
- Nokogiri::HTML.fragment(html).elements.flat_map do |element|
132
- element_to_node(element)
95
+ type.is_a?(Proc) ? type.call(node, element) : node
133
96
  end
134
- end
135
97
 
136
- private
98
+ def element_to_inline(element)
99
+ type = convert_name_to_type(element)
100
+ nodes = element.children.flat_map do |child|
101
+ element_to_texts(child)
102
+ end
137
103
 
138
- attr_accessor :elements, :block_elements, :inline_elements, :mark_elements
104
+ {
105
+ children: nodes,
106
+ type: type
107
+ }
108
+ end
139
109
 
140
- def element_to_node(element, marks = [])
141
- handler = @element_register[element.name]
142
- marks = [*marks, handler.mark].compact
110
+ def element_to_texts(element)
111
+ nodes = []
112
+ mark = convert_name_to_mark(element.name)
143
113
 
144
- children = element.children.flat_map do |child|
145
- if handler.mark
146
- element_to_text(child, marks)
147
- elsif child.text?
148
- next if child.text.strip == ''
149
- element_to_text(child, marks)
114
+ if element.class == Nokogiri::XML::Element
115
+ element.children.each do |child|
116
+ nodes << element_to_text(child, mark)
117
+ end
150
118
  else
151
- element_to_node(child, marks)
119
+ nodes << element_to_text(element)
152
120
  end
153
- end.compact
154
121
 
155
- children << { text: '' } if children.empty?
156
-
157
- return children unless handler
158
- handler.deserialize.call(children, element)
159
- end
122
+ nodes
123
+ end
160
124
 
161
- def element_to_text(element, marks = [])
162
- handler = @element_register[element.name]
163
- marks = [*marks, handler.mark].compact
164
- {
165
- text: element.text
166
- }.tap do |text|
167
- marks.compact.each do |m|
168
- text[m.to_sym] = true
125
+ def element_to_text(element, mark = nil)
126
+ {
127
+ text: element.text
128
+ }.tap do |text|
129
+ [mark, convert_name_to_mark(element.name)].compact.each do |m|
130
+ text[m[:type].to_sym] = true
131
+ end
169
132
  end
170
133
  end
171
- end
172
134
 
173
- def convert_name_to_mark(name)
174
- type = mark_elements[name.to_sym]
135
+ def convert_name_to_type(element)
136
+ type = [element.name, element.attributes['type']&.value].compact.join
137
+ elements[type.to_sym] || elements[:p]
138
+ end
175
139
 
176
- return nil unless type
177
- {
178
- type: type
179
- }
180
- end
140
+ def convert_name_to_mark(name)
141
+ type = mark_elements[name.to_sym]
142
+
143
+ return nil unless type
181
144
 
182
- def empty_state
183
- [
184
145
  {
185
- type: 'paragraph',
186
- children: [
187
- {
188
- text: ''
189
- }
190
- ]
146
+ type: type
191
147
  }
192
- ]
193
- end
148
+ end
149
+
150
+ def block?(element)
151
+ block_elements.include?(element.name)
152
+ end
153
+
154
+ def inline?(element)
155
+ inline_elements.include?(element.name)
156
+ end
194
157
 
195
- def serialize_node(node)
196
- if node[:text]
197
- node[:text]
198
- else
199
- handler = @node_register[node[:type]]
200
- children = node[:children].map { |n| serialize_node(n) }.join
158
+ def empty_state
159
+ [
160
+ {
161
+ type: 'paragraph',
162
+ children: [
163
+ {
164
+ text: ''
165
+ }
166
+ ]
167
+ }
168
+ ]
169
+ end
201
170
 
202
- return children unless handler
171
+ def serialize_node(node)
172
+ if node[:text]
173
+ node[:text]
174
+ else
175
+ children = node[:children].map { |n| serialize_node(n) }.join
203
176
 
204
- tag = @tag_register[node[:type]]
205
- handler.call(node, children, tag)
177
+ element = ELEMENTS.find { |_, v| v == node[:type] }[0]
178
+
179
+ if %i[ol1 ola].include?(element)
180
+ element = :ol
181
+ end
182
+
183
+ "<#{element}>#{children}</#{element}>"
184
+ end
206
185
  end
207
186
  end
208
187
  end
@@ -1,3 +1,3 @@
1
1
  module SlateSerializer
2
- VERSION = '1.0.3'.freeze
2
+ VERSION = '1.0.4'.freeze
3
3
  end
@@ -5,12 +5,12 @@ require 'slate_serializer/version'
5
5
  Gem::Specification.new do |spec|
6
6
  spec.name = 'lwe_slate_serializer'
7
7
  spec.version = SlateSerializer::VERSION
8
- spec.authors = ['Wesley Stam', 'Paul Crabtree']
9
- spec.email = ['wesley@stam.me', 'paul@learningwithexperts.com']
8
+ spec.authors = ['Wesley Stam']
9
+ spec.email = ['wesley@stam.me']
10
10
  spec.license = 'MIT'
11
11
 
12
12
  spec.summary = 'Serializer for Slate documents written in Ruby'
13
- spec.homepage = 'https://github.com/learningwithexperts/slate_serializer'
13
+ spec.homepage = 'https://github.com/wesleystam/slate_serializer'
14
14
 
15
15
  # Specify which files should be added to the gem when it is released.
16
16
  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
@@ -18,7 +18,7 @@ Gem::Specification.new do |spec|
18
18
  `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
19
19
  end
20
20
  spec.bindir = 'exe'
21
- #spec.executables = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
21
+ spec.executables = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
22
22
  spec.require_paths = ['lib']
23
23
 
24
24
  spec.add_dependency 'nokogiri', '~> 1.11'
metadata CHANGED
@@ -1,15 +1,14 @@
1
1
  --- !ruby/object:Gem::Specification
2
2
  name: lwe_slate_serializer
3
3
  version: !ruby/object:Gem::Version
4
- version: 1.0.3
4
+ version: 1.0.4
5
5
  platform: ruby
6
6
  authors:
7
7
  - Wesley Stam
8
- - Paul Crabtree
9
8
  autorequire:
10
9
  bindir: exe
11
10
  cert_chain: []
12
- date: 2022-04-27 00:00:00.000000000 Z
11
+ date: 2023-08-15 00:00:00.000000000 Z
13
12
  dependencies:
14
13
  - !ruby/object:Gem::Dependency
15
14
  name: nokogiri
@@ -70,7 +69,6 @@ dependencies:
70
69
  description:
71
70
  email:
72
71
  - wesley@stam.me
73
- - paul@learningwithexperts.com
74
72
  executables: []
75
73
  extensions: []
76
74
  extra_rdoc_files: []
@@ -90,7 +88,7 @@ files:
90
88
  - lib/slate_serializer/plain.rb
91
89
  - lib/slate_serializer/version.rb
92
90
  - slate_serializer.gemspec
93
- homepage: https://github.com/learningwithexperts/slate_serializer
91
+ homepage: https://github.com/wesleystam/slate_serializer
94
92
  licenses:
95
93
  - MIT
96
94
  metadata: {}
@@ -109,7 +107,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
109
107
  - !ruby/object:Gem::Version
110
108
  version: '0'
111
109
  requirements: []
112
- rubygems_version: 3.3.8
110
+ rubygems_version: 3.4.18
113
111
  signing_key:
114
112
  specification_version: 4
115
113
  summary: Serializer for Slate documents written in Ruby