lwe_slate_serializer 1.0.3 → 1.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8e9e8a5615362af2fc54a03f861b890df09ac66cc0f08eb1f315cb24001b7950
-  data.tar.gz: ffa3f1e4c265f0d44ae3a59c37ed041aa6cc9e9bcf59d7ffa20a25632ae655f0
+  metadata.gz: ee065454439454fb5ea945ea83d59a254832b285211bb41e0d58e34a88e763c9
+  data.tar.gz: b30286ecdfa37885288a12f168353d80e63e3b0e5f91eb5387ca15829f103484
 SHA512:
-  metadata.gz: 7d923f1c365e59685db17512e1a23767157c8806bcae0d0f6331c1800d64b08c5a6d90f598db7e82fc9f404dc7c26d264ff028abe419566de650faeae76b073d
-  data.tar.gz: c80a64dc9a8fcd388b5b612cb08d0f7eb4faff8f00e4049d0726997c5bb28d9e71bfe1c2093a9d185082851683fc1a89db5d8815733b4f9b36ab89a761975174
+  metadata.gz: 7cbcd0f9bfdcdcad1e9f53d4a14fb2dfc2e50f6a095ef0b15e169746a899f9fc7b119cd6f2b88fcbee5e57eade53b4710179901a87e7300ae8cebbe7319438d0
+  data.tar.gz: 26f233a45d443c56d9ef108e27d372010367ad3f3c83259b39f09b15d0567d283ee31b25b5affcd7e0675d9d89d7b4ace3efe8e3bceedbcb848bfa1d1c1d200e

data/Gemfile.lock

@@ -1,16 +1,18 @@
 PATH
   remote: .
   specs:
-    lwe_slate_serializer (1.0.1)
+    slate_serializer (1.0.4)
       nokogiri (~> 1.11)
 
 GEM
   remote: https://rubygems.org/
   specs:
     diff-lcs (1.4.4)
-    nokogiri (1.13.3-x86_64-darwin)
+    mini_portile2 (2.8.4)
+    nokogiri (1.15.4)
+      mini_portile2 (~> 2.8.2)
       racc (~> 1.4)
-    racc (1.6.0)
+    racc (1.7.1)
     rake (13.0.3)
     rspec (3.10.0)
       rspec-core (~> 3.10.0)
@@ -31,9 +33,9 @@ PLATFORMS
 
 DEPENDENCIES
   bundler (~> 2.2)
-  lwe_slate_serializer!
   rake (~> 13.0)
   rspec (~> 3.0)
+  slate_serializer!
 
 BUNDLED WITH
    2.2.22

data/lib/slate_serializer/html.rb

@@ -11,6 +11,7 @@ module SlateSerializer
       'p': 'paragraph',
       'div': 'paragraph',
       'ol1': 'ordered-list',
+      'ola': 'alpha-ordered-list',
       'ol': 'ordered-list',
       'ul': 'unordered-list',
       'table': 'table',
@@ -30,179 +31,157 @@ module SlateSerializer
     MARK_ELEMENTS = {
       'em': 'italic',
       'strong': 'bold',
-      'b': 'bold',
       'u': 'underline'
     }.freeze
 
-    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)
+    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
       end
-    end
 
-    def register_handler(handler)
-      handler.elements.each do |element|
-        @element_register[element] = handler
+      # 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
       end
-      @node_register[handler.node] = handler.serialize
-      @tag_register[handler.node] = handler.elements.first
-    end
 
-    class SerializerHandler
-      attr_reader :elements, :node, :serialize, :deserialize, :mark
+      private
 
-      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
+      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 == ''
+
+            element_to_texts(child)
           end
-        end
-      end
-    end
+        end.compact
 
-    # 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)
+        children << { text: '' } if children.empty? && type != 'image'
 
-      value.map { |n| serialize_node(n) }.join
-    end
+        node = {
+          children: children,
+          type: type
+        }
 
-    # 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)
+        type.is_a?(Proc) ? type.call(node, element) : node
       end
-    end
 
-    private
+      def element_to_inline(element)
+        type = convert_name_to_type(element)
+        nodes = element.children.flat_map do |child|
+          element_to_texts(child)
+        end
 
-    attr_accessor :elements, :block_elements, :inline_elements, :mark_elements
+        {
+          children: nodes,
+          type: type
+        }
+      end
 
-    def element_to_node(element, marks = [])
-      handler = @element_register[element.name]
-      marks = [*marks, handler.mark].compact
+      def element_to_texts(element)
+        nodes = []
+        mark = convert_name_to_mark(element.name)
 
-      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)
+        if element.class == Nokogiri::XML::Element
+          element.children.each do |child|
+            nodes << element_to_text(child, mark)
+          end
         else
-          element_to_node(child, marks)
+          nodes << element_to_text(element)
         end
-      end.compact
 
-      children << { text: '' } if children.empty?
-
-      return children unless handler
-      handler.deserialize.call(children, element)
-    end
+        nodes
+      end
 
-    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
+      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
-    end
 
-    def convert_name_to_mark(name)
-      type = mark_elements[name.to_sym]
+      def convert_name_to_type(element)
+        type = [element.name, element.attributes['type']&.value].compact.join
+        elements[type.to_sym] || elements[:p]
+      end
 
-      return nil unless type
-      {
-        type: type
-      }
-    end
+      def convert_name_to_mark(name)
+        type = mark_elements[name.to_sym]
+
+        return nil unless type
 
-    def empty_state
-      [
         {
-          type: 'paragraph',
-          children: [
-            {
-              text: ''
-            }
-          ]
+          type: type
         }
-      ] 
-    end
+      end
+
+      def block?(element)
+        block_elements.include?(element.name)
+      end
+
+      def inline?(element)
+        inline_elements.include?(element.name)
+      end
 
-    def serialize_node(node)
-      if node[:text]
-        node[:text]
-      else
-        handler = @node_register[node[:type]]
-        children = node[:children].map { |n| serialize_node(n) }.join
+      def empty_state
+        [
+          {
+            type: 'paragraph',
+            children: [
+              {
+                text: ''
+              }
+            ]
+          }
+        ] 
+      end
 
-        return children unless handler
+      def serialize_node(node)
+        if node[:text]
+          node[:text]
+        else
+          children = node[:children].map { |n| serialize_node(n) }.join
 
-        tag = @tag_register[node[:type]]
-        handler.call(node, children, tag)
+          element = ELEMENTS.find { |_, v| v == node[:type] }[0]
+          
+          if %i[ol1 ola].include?(element)
+            element = :ol
+          end
+
+          "<#{element}>#{children}</#{element}>"
+        end
       end
     end
   end

data/lib/slate_serializer/version.rb

@@ -1,3 +1,3 @@
 module SlateSerializer
-  VERSION = '1.0.3'.freeze
+  VERSION = '1.0.4'.freeze
 end

data/slate_serializer.gemspec

@@ -5,12 +5,12 @@ require 'slate_serializer/version'
 Gem::Specification.new do |spec|
   spec.name          = 'lwe_slate_serializer'
   spec.version       = SlateSerializer::VERSION
-  spec.authors       = ['Wesley Stam', 'Paul Crabtree']
-  spec.email         = ['wesley@stam.me', 'paul@learningwithexperts.com']
+  spec.authors       = ['Wesley Stam']
+  spec.email         = ['wesley@stam.me']
   spec.license       = 'MIT'
 
   spec.summary       = 'Serializer for Slate documents written in Ruby'
-  spec.homepage      = 'https://github.com/learningwithexperts/slate_serializer'
+  spec.homepage      = 'https://github.com/wesleystam/slate_serializer'
 
   # Specify which files should be added to the gem when it is released.
   # 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|
     `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
   end
   spec.bindir        = 'exe'
-  #spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ['lib']
 
   spec.add_dependency 'nokogiri', '~> 1.11'

metadata

@@ -1,15 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lwe_slate_serializer
 version: !ruby/object:Gem::Version
-  version: 1.0.3
+  version: 1.0.4
 platform: ruby
 authors:
 - Wesley Stam
-- Paul Crabtree
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2022-04-27 00:00:00.000000000 Z
+date: 2023-08-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: nokogiri
@@ -70,7 +69,6 @@ dependencies:
 description:
 email:
 - wesley@stam.me
-- paul@learningwithexperts.com
 executables: []
 extensions: []
 extra_rdoc_files: []
@@ -90,7 +88,7 @@ files:
 - lib/slate_serializer/plain.rb
 - lib/slate_serializer/version.rb
 - slate_serializer.gemspec
-homepage: https://github.com/learningwithexperts/slate_serializer
+homepage: https://github.com/wesleystam/slate_serializer
 licenses:
 - MIT
 metadata: {}
@@ -109,7 +107,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.8
+rubygems_version: 3.4.18
 signing_key:
 specification_version: 4
 summary: Serializer for Slate documents written in Ruby