lwe_slate_serializer 1.0.0 → 1.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1e1afc95f11d60edc3272a0097520e1bddca78ee9a8c37cd6908ff63ed0563bd
-  data.tar.gz: 98c0ee15eebb1e2e5e7537419c4144d2985121487c8fa65cc26064da3871b02f
+  metadata.gz: 2baa0cc32467d4363e5fc73033befb4a9cd79ec838afe6e6753993d2b2c84e86
+  data.tar.gz: ca07a3ecdce7fadbf02cc5959ab9ca236839900483d68b51f4a5e224915bdc4d
 SHA512:
-  metadata.gz: 4d84ccba0d9b4027b1888696aa01a34de921d51826c0665671497c640b9d559ddbfa739b09a1d5c0a946671a5539b29b26149ad4056466ae44404351109f4f9b
-  data.tar.gz: e5f8ff256e04ef82167592b755699ebe1fa80506edcb0d4f99bf46ccc5474f4454011cb32488b50fb08a8882034ae36d7a1d8bcd1a78614af96bac7d4a62dbb9
+  metadata.gz: 4526ab16ef29cd444bbfc7db268987fe98f0740e35bd6d5f1a6c4f3dab76582bad196f82b4a0d762e5c031692e6b86c701814cdf3f9e9933188ab84723b308bc
+  data.tar.gz: 97f0425e77ef5b752aec8b02b5bf071f3e5d424cfd93bc5e45ac37d2267571120c4bb764ad2040207e054a9ecec8d40368f6ece85f3e5a4df6fdd0ff134ae469

data/lib/slate_serializer/html.rb

@@ -11,7 +11,6 @@ module SlateSerializer
       'p': 'paragraph',
       'div': 'paragraph',
       'ol1': 'ordered-list',
-      'ola': 'alpha-ordered-list',
       'ol': 'ordered-list',
       'ul': 'unordered-list',
       'table': 'table',
@@ -31,157 +30,183 @@ module SlateSerializer
     MARK_ELEMENTS = {
       'em': 'italic',
       'strong': 'bold',
+      'b': 'bold',
       'u': 'underline'
     }.freeze
 
-    class << self
-      # Convert html to a Slate document
-      #
-      # @param html format [String] the HTML
-      # @param options [Hash]
-      # @option options [Array] :elements Lookup list to convert html tags to object types
-      # @option options [Array] :block_elemnts List of block types
-      # @option options [Array] :inline_elemnts List of inline types
-      # @option options [Array] :mark_elemnts List of mark types
-      def deserializer(html, options = {})
-        return empty_state if html.nil? || html == ''
-
-        self.elements = options[:elements] || ELEMENTS
-        self.block_elements = options[:block_elements] || BLOCK_ELEMENTS
-        self.inline_elements = options[:inline_elements] || INLINE_ELEMENTS
-        self.mark_elements = options[:mark_elements] || MARK_ELEMENTS
-
-        html = html.gsub('<br>', "\n")
-        Nokogiri::HTML.fragment(html).elements.map do |element|
-          element_to_node(element)
-        end
+    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: ['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
 
-      # Convert html to a Slate document
-      #
-      # @param value format [Hash] the Slate document
-      # @return [String] plain text version of the Slate documnent
-      def serializer(value)
-        return '' unless value.is_a?(Array)
-
-        value.map { |n| serialize_node(n) }.join
+    def register_handler(handler)
+      handler.elements.each do |element|
+        @element_register[element] = handler.deserialize
       end
+      @node_register[handler.node] = handler.serialize
+      @tag_register[handler.node] = handler.elements.first
+    end
 
-      private
-
-      attr_accessor :elements, :block_elements, :inline_elements, :mark_elements
-
-      def element_to_node(element)
-        type = convert_name_to_type(element)
-        children = element.children.flat_map do |child|
-          if block?(child)
-            element_to_node(child)
-          elsif inline?(child)
-            element_to_inline(child)
-          else
-            next if child.text.strip == ''
+    class SerializerHandler
+      attr_reader :elements, :node, :serialize, :deserialize
 
-            element_to_texts(child)
-          end
-        end.compact
+      def initialize(elements: [], node: nil, serialize: nil, deserialize: nil)
+        @elements = elements
+        @node = node
+        @serialize = serialize || ->(node, children, tag) do 
+          "<#{tag}>#{children}</#{tag}>"
+        end
+        @deserialize = deserialize || ->(node, element) do
+          node.merge(type: @node)
+        end
+      end
+    end
 
-        children << { text: '' } if children.empty? && type != 'image'
+    # Convert html to a Slate document
+    #
+    # @param value format [Hash] the Slate document
+    # @return [String] plain text version of the Slate documnent
+    def serialize(value)
+      return '' unless value.is_a?(Array)
 
-        node = {
-          children: children,
-          type: type
-        }
+      value.map { |n| serialize_node(n) }.join
+    end
 
-        type.is_a?(Proc) ? type.call(node, element) : node
+    # Convert html to a Slate document
+    #
+    # @param html format [String] the HTML
+    # @param options [Hash]
+    # @option options [Array] :elements Lookup list to convert html tags to object types
+    # @option options [Array] :block_elemnts List of block types
+    # @option options [Array] :inline_elemnts List of inline types
+    # @option options [Array] :mark_elemnts List of mark types
+    def deserialize(html)
+      return empty_state if html.nil? || html == ''
+
+      html = html.gsub('<br>', "\n")
+      Nokogiri::HTML.fragment(html).elements.map do |element|
+        element_to_node(element)
       end
+    end
 
-      def element_to_inline(element)
-        type = convert_name_to_type(element)
-        nodes = element.children.flat_map do |child|
-          element_to_texts(child)
-        end
+    private
 
-        {
-          children: nodes,
-          type: type
-        }
-      end
+    attr_accessor :elements, :block_elements, :inline_elements, :mark_elements
 
-      def element_to_texts(element)
-        nodes = []
-        mark = convert_name_to_mark(element.name)
+    def element_to_node(element, marks = [])
+      handler = @element_register[element.name]
+      
+      mark = convert_name_to_mark(element.name)
+      marks = [*marks, mark].compact
 
-        if element.class == Nokogiri::XML::Element
-          element.children.each do |child|
-            nodes << element_to_text(child, mark)
-          end
+      children = element.children.flat_map do |child|
+        if child.text?
+          next if child.text.strip == ''
+          element_to_text(child, marks)
         else
-          nodes << element_to_text(element)
+          element_to_node(child, marks)
         end
+      end.compact
 
-        nodes
-      end
+      children << { text: '' } if children.empty?
 
-      def element_to_text(element, mark = nil)
-        {
-          text: element.text
-        }.tap do |text|
-          [mark, convert_name_to_mark(element.name)].compact.each do |m|
-            text[m[:type].to_sym] = true
-          end
-        end
-      end
+      return children unless handler
+      handler.call({ children: children }, element)
+    end
 
-      def convert_name_to_type(element)
-        type = [element.name, element.attributes['type']&.value].compact.join
-        elements[type.to_sym] || elements[:p]
+    # def element_to_texts(element)
+    #   nodes = []
+    #   mark = convert_name_to_mark(element.name)
+
+    #   if element.class == Nokogiri::XML::Element
+    #     element.children.each do |child|
+    #       nodes << element_to_text(child, mark)
+    #     end
+    #   else
+    #     nodes << element_to_text(element)
+    #   end
+
+    #   nodes
+    # end
+
+    def element_to_text(element, marks = [])
+      {
+        text: element.text
+      }.tap do |text|
+        marks.compact.each do |m|
+          text[m[:type].to_sym] = true
+        end
       end
+    end
 
-      def convert_name_to_mark(name)
-        type = mark_elements[name.to_sym]
+    def convert_name_to_mark(name)
+      type = mark_elements[name.to_sym]
 
-        return nil unless type
+      return nil unless type
+      {
+        type: type
+      }
+    end
 
+    def empty_state
+      [
         {
-          type: type
+          type: 'paragraph',
+          children: [
+            {
+              text: ''
+            }
+          ]
         }
-      end
-
-      def block?(element)
-        block_elements.include?(element.name)
-      end
-
-      def inline?(element)
-        inline_elements.include?(element.name)
-      end
-
-      def empty_state
-        [
-          {
-            type: 'paragraph',
-            children: [
-              {
-                text: ''
-              }
-            ]
-          }
-        ] 
-      end
+      ] 
+    end
 
-      def serialize_node(node)
-        if node[:text]
-          node[:text]
-        else
-          children = node[:children].map { |n| serialize_node(n) }.join
+    def serialize_node(node)
+      if node[:text]
+        node[:text]
+      else
+        handler = @node_register[node[:type]]
+        children = node[:children].map { |n| serialize_node(n) }.join
 
-          element = ELEMENTS.find { |_, v| v == node[:type] }[0]
-          
-          if %i[ol1 ola].include?(element)
-            element = :ol
-          end
+        return children unless handler
 
-          "<#{element}>#{children}</#{element}>"
-        end
+        tag = @tag_register[node[:type]]
+        handler.call(node, children, tag)
       end
     end
   end

data/lib/slate_serializer/version.rb

@@ -1,3 +1,3 @@
 module SlateSerializer
-  VERSION = '1.0.0'.freeze
+  VERSION = '1.0.1'.freeze
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: lwe_slate_serializer
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.0.1
 platform: ruby
 authors:
 - Wesley Stam