lwe_slate_serializer 1.0.5 → 1.0.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4be6592b6639d543a61ac8a7cbbc07c1203d128f966c07a9d7e5d37e55f813e2
-  data.tar.gz: a6a86c860771d87d73753c8fdf3d6afe3124a4104813389819e4ef75d36fb160
+  metadata.gz: 357ee78ae9c5e22655caebfce304878620477033d63f13a75923a8509dfb6f67
+  data.tar.gz: 03f957e81cea5001d40ab05316bee3910509acd5c5c9e396627d370f0782676b
 SHA512:
-  metadata.gz: 169da2e749a77071253baf94290ba960c7eacf59c855549bbd2a8a73fa4092b03d6e7552d3e028eb9118f8ff5f29be3076041172e0d8c24b53df2fa85974facf
-  data.tar.gz: 824aceef51bbfef01c7852be04bbbcb50aa8eaed0a1054f14f501bcd7b333f8f0200eeeafe76668e9e3ef8365f70f2e58cad65786dccc6b818778e845661e181
+  metadata.gz: ec50813c392a9fc2cc0acfd6063f3346c10512b364e7b7000ba351d654bca283c8c45638a82f8d95e0ffc72e6fd630dcf91a93873774b1e462ea6640ee690c10
+  data.tar.gz: c3e120dc1585c020715a4bc1392f0b4aba0c57d51908898d8ccc28f3fb8122fa1442fa108c4e16b89e9506cf7bea8e233112a07576e2771295f8b389ae56aac7

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,179 @@ 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: ['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
 
-      # 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
       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, :mark
 
-            element_to_texts(child)
+      def initialize(elements: [], node: nil, mark: nil, serialize: nil, deserialize: nil)
+        @elements = elements
+        @node = node
+        @mark = mark
+        @serialize = serialize || ->(node, children, tag) do 
+          "<#{tag}>#{children}</#{tag}>"
+        end
+        @deserialize = deserialize || ->(children, element) do
+          if @node
+            { type: @node, children: children }
+          else 
+            children
           end
-        end.compact
+        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.flat_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]
+      marks = [*marks, handler&.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 handler&.mark
+          element_to_text(child, marks)
+        elsif 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.deserialize.call(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_text(element, marks = [])
+      handler = @element_register[element.name]
+      marks = [*marks, handler.mark].compact
+      {
+        text: element.text
+      }.tap do |text|
+        marks.compact.each do |m|
+          text[m.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]
+      elsif node[:children]
+        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.5'.freeze
+  VERSION = '1.0.7'.freeze
 end

metadata

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