draftjs_html 0.21.0 → 0.23.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 662afcc40856fc071f8933862c939e45da447bfcf089287ef486c20eaa9ad9ea
-  data.tar.gz: e3c86eb5fd81a6daf446d3cd6a2a8394d4db8c2a79a4d7e3dfc9aa0ff1524514
+  metadata.gz: c01b8b4b8ca17c90c9d53f7d85caebc7fe6c18aab14a79ff635110d8a0fb81dc
+  data.tar.gz: 6e0d85454c9d8ee4e6998e8e398c72c01f6097fc3c5e9b61c165fb07ac01af0f
 SHA512:
-  metadata.gz: 91d4da6dd384c6b38fda6edaa8653af2a968b04e53ab3b0bdc4b1305242043f816c25f906508fb6800ab306bbe8967d6608e3a411294152b53c22f375b0cf6dd
-  data.tar.gz: 8840930b9e1d680477ca458b7b44faff3343dfd1d4129b4e28c931e62c2318dddee8d8c4f8c32bf1f5eaa13e8b542f6704b09ee766c95c9049b9bfa4d37441cf
+  metadata.gz: 76cdd86c495a5900653f060f8d4f9702a29b1a7b3ebdb792b00e3f7071642c2fd7547d56aa1e3f6684ab6f873e8c377a09d8fe0c344e2ecf400db106076ebe66
+  data.tar.gz: 0c65eac79da80da23d667c62352542dc03717e3db1999fffb35f5a7ac19a1afe871345c1c7449dd29c0570fd780d17c1ea44f3c75b02c034e7cd224eb2c002bb

data/README.md

@@ -229,6 +229,15 @@ The callable should return a Hash with symbol keys. The supported values are:
 - `data` (optional, default `{}`)
   - an arbitrary data-bag (Hash) of entity data
 
+#### `:is_semantic_markup:`
+
+Defaults to `true`.
+
+By setting to `false`, the user is stating they want to treat `div` tags as semantic,
+block-level tags. In some markup (emails, for example), there are no semantic tags
+(read, no `p` tags), so the only indications of whitespace and structure come from
+`div` tags. This flag will flush content wrapped in a `div` as a DraftJS block. 
+
 ## Development
 
 After checking out the repo, run `bin/setup` to install dependencies. Then, run

data/lib/draftjs_html/from_html/char_list.rb

@@ -0,0 +1,136 @@
+# frozen_string_literal: true
+require 'set'
+
+module DraftjsHtml
+  class FromHtml < Nokogiri::XML::SAX::Document
+    class CharList
+      module FinishableRange
+        def range
+          start..finish
+        end
+
+        def try_finish(index)
+          self[:finish] ||= index
+        end
+      end
+
+      Char = Struct.new(:it, :styles, :entity, :atomic, keyword_init: true) do
+        def atomic?
+          self.atomic
+        end
+
+        def styles
+          self[:styles] ||= Set.new
+        end
+      end
+
+      EntityRange = Struct.new(:entity, :start, :finish, keyword_init: true) do
+        include FinishableRange
+      end
+
+      StyleRange = Struct.new(:style, :start, :finish, keyword_init: true) do
+        include FinishableRange
+      end
+
+      attr_reader :chars
+
+      def initialize(initial = [])
+        @chars = initial.dup
+      end
+
+      def append(str, styles: Set.new, entity: nil)
+        @chars << Char.new(it: "\n") if @chars.last&.atomic?
+
+        @chars += str.chars.map { Char.new(it: _1, styles: Set.new(styles), entity: entity) }
+      end
+
+      def append_char(char)
+        @chars << char
+      end
+
+      def text
+        @chars.map(&:it).join
+      end
+
+      def size
+        @chars.size
+      end
+
+      def any?
+        size > 0
+      end
+
+      def atomic?
+        @chars.any? && @chars.all?(&:atomic?)
+      end
+
+      def each_line
+        return to_enum(:each_line) unless block_given?
+
+        line = self.class.new
+        chars.each do |c|
+          if c.it == "\n"
+            yield  line
+            line = self.class.new
+            next
+          end
+
+          line.append_char(c)
+        end
+
+        yield line if line.any?
+      end
+
+      def apply_entity(range, entity)
+        @chars[range].each { _1.entity = entity }
+      end
+
+      def append_atomic_entity(entity)
+        append("\n") if @chars.any?
+        append_char(Char.new(it: ' ', atomic: true, entity: entity))
+      end
+
+      def append_styles(range, styles)
+        @chars[range].each { _1.styles += Array(styles) }
+      end
+
+      def +(other)
+        self.class.new(@chars + other.chars)
+      end
+
+      def entity_ranges
+        current_entity = nil
+
+        entity_ranges = @chars.each_with_object(Array.new).with_index do |(char, ranges), i|
+          next if char.entity == current_entity
+
+          current_entity = char.entity
+          ranges.last&.try_finish(i - 1)
+          ranges << EntityRange.new(entity: char.entity, start: i) if char.entity
+        end
+
+        entity_ranges.last&.try_finish(@chars.size - 1)
+        entity_ranges
+      end
+
+      def style_ranges
+        style_ranges = @chars.each_with_object({}).with_index do |(char, ranges_by_style), i|
+          char.styles.each do |style|
+            ranges_by_style[style] ||= []
+            if i > 0 && @chars[i-1].styles.include?(style)
+              ranges_by_style[style].last << i
+            else
+              ranges_by_style[style] << [i]
+            end
+          end
+        end
+
+        style_ranges.flat_map do |style, ranges|
+          ranges.map do |range|
+            StyleRange.new(style: style, start: range.first, finish: range.last)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/draftjs_html/from_html/depth_stack.rb

@@ -1,15 +1,16 @@
 module DraftjsHtml
   class FromHtml < Nokogiri::XML::SAX::Document
     class DepthStack
-      def initialize
+      def initialize(is_semantic_markup: true)
         @stack = []
         @nodes = []
         @list_depth = -1
-        @style_stack = StyleStack.new
+        @active_styles = []
+        @is_semantic_markup = is_semantic_markup
       end
 
       def push(tagname, attrs)
-        @stack << PendingBlock.from_tag(tagname, attrs, @nodes.dup, @list_depth)
+        @stack << PendingBlock.from_tag(tagname, attrs, @nodes.dup, @list_depth, is_semantic_markup: @is_semantic_markup)
         track_block_node(tagname)
       end
 
@@ -26,8 +27,7 @@ module DraftjsHtml
           @nodes.pop
         end
         blocks.reverse_each do |pending_block|
-          pending_block.flush_to(draftjs, @style_stack)
-          pending_block.apply_entities_to(draftjs)
+          pending_block.flush_to(draftjs)
         end
         @list_depth -= 1
       end
@@ -59,34 +59,35 @@ module DraftjsHtml
           next unless user_created_entity
 
           if content == '' && !user_created_entity[:atomic]
-            current.text_buffer << ' '
-            range = range.begin..(range.end+1)
+            current.text_buffer.append(' ', entity: user_created_entity)
+          elsif content == '' && user_created_entity[:atomic]
+            current.text_buffer.append_atomic_entity(user_created_entity)
+          else
+            current.text_buffer.apply_entity(range, user_created_entity)
           end
-          current.entities << user_created_entity.merge(start: range.begin, finish: range.end)
         end
       end
 
       def style_start(tagname)
-        @style_stack.track_start(tagname, current_character_offset + 1)
+        @active_styles += [DraftjsHtml::HtmlDefaults::HTML_STYLE_TAGS_TO_STYLE[tagname]]
       end
 
       def style_end(tagname)
-        @style_stack.track_end(tagname, current_character_offset)
+        @active_styles.delete_at(@active_styles.index(DraftjsHtml::HtmlDefaults::HTML_STYLE_TAGS_TO_STYLE[tagname]))
       end
 
       def flush_to(draftjs)
-        current.flush_to(draftjs, @style_stack)
-        current.apply_entities_to(draftjs)
+        current.flush_to(draftjs)
       end
 
       def append_text(chars)
-        current.text_buffer << chars unless chars.empty?
+        current.text_buffer.append(chars, styles: @active_styles) unless chars.empty?
       end
 
       private
 
       def current_text_buffer
-        current.text_buffer.join
+        current.text_buffer.text
       end
 
       def current_character_offset

data/lib/draftjs_html/from_html/pending_block.rb

@@ -1,15 +1,16 @@
 module DraftjsHtml
   class FromHtml < Nokogiri::XML::SAX::Document
-    PendingBlock = Struct.new(:tagname, :attrs, :chars, :entities, :pending_entities, :parent_tagnames, :depth, keyword_init: true) do
-      def self.from_tag(name, attrs, parent_tagnames, depth)
+    PendingBlock = Struct.new(:tagname, :attrs, :chars, :entities, :pending_entities, :parent_tagnames, :depth, :is_semantic_markup, keyword_init: true) do
+      def self.from_tag(name, attrs, parent_tagnames, depth, is_semantic_markup: true)
         self.new(
           tagname: name,
           attrs: attrs,
           entities: [],
-          chars: [],
+          chars: CharList.new,
           pending_entities: [],
           depth: depth,
           parent_tagnames: parent_tagnames,
+          is_semantic_markup: is_semantic_markup,
         )
       end
 
@@ -17,17 +18,14 @@ module DraftjsHtml
         self[:chars]
       end
 
-      def clear_text_buffer
-        self[:chars] = []
-      end
-
       def character_offset
-        text_buffer.join.length - 1
+        text_buffer.size - 1
       end
 
       def flushable?
         %w[OPENING ol ul li table].include?(parent_tagnames.last) ||
-          (parent_tagnames.last == 'div' && tagname != 'div')
+          (parent_tagnames.last == 'div' && tagname != 'div') ||
+          (!is_semantic_markup && tagname == 'div')
       end
 
       def consume(other_pending_block)
@@ -36,31 +34,21 @@ module DraftjsHtml
         self.entities += other_pending_block.entities
       end
 
-      def flush_to(draftjs, styles)
+      def flush_to(draftjs)
         if text_buffer.any?
-          chars.join.lines.each do |line|
-            draftjs.typed_block(block_name, line.chomp, depth: [depth, 0].max)
-          end
-
-          styles.each do |descriptor|
-            finish = descriptor[:finish] || character_offset
-            draftjs.inline_style(descriptor[:style], descriptor[:start]..finish)
-          end
-        end
+          text_buffer.each_line do |line|
+            block_type = line.atomic? ? 'atomic' : block_name
+            draftjs.typed_block(block_type, line.text, depth: [depth, 0].max)
 
-        clear_text_buffer
-        styles.clear_finished
-      end
+            line.entity_ranges.each do |entity_range|
+              entity = entity_range.entity
+              draftjs.apply_entity entity[:type], entity_range.range, data: entity[:data], mutability: entity.fetch(:mutability, 'IMMUTABLE')
+            end
 
-      def apply_entities_to(draftjs)
-        Array(entities).each do |entity|
-          range = entity[:start]..entity[:finish]
-          if entity[:atomic]
-            draftjs.typed_block('atomic', ' ', depth: [depth, 0].max)
-            range = 0..0
+            line.style_ranges.each do |style_range|
+              draftjs.inline_style(style_range.style, style_range.range)
+            end
           end
-
-          draftjs.apply_entity entity[:type], range, data: entity[:data], mutability: entity.fetch(:mutability, 'IMMUTABLE')
         end
       end
 

data/lib/draftjs_html/from_html.rb

@@ -1,9 +1,9 @@
 require 'stringio'
 require_relative 'html_defaults'
 require_relative 'from_html/elements'
-require_relative 'from_html/style_stack'
 require_relative 'from_html/pending_block'
 require_relative 'from_html/depth_stack'
+require_relative 'from_html/char_list'
 
 module DraftjsHtml
   class FromHtml < Nokogiri::XML::SAX::Document
@@ -11,7 +11,7 @@ module DraftjsHtml
     def initialize(options = {})
       @draftjs = Draftjs::RawBuilder.new
       @parser = Nokogiri::HTML4::SAX::Parser.new(self)
-      @depth_stack = DepthStack.new
+      @depth_stack = DepthStack.new(is_semantic_markup: options.fetch(:is_semantic_markup, true))
       @options = ensure_options!(options.dup)
     end
 

data/lib/draftjs_html/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module DraftjsHtml
-  VERSION = "0.21.0"
+  VERSION = "0.23.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: draftjs_html
 version: !ruby/object:Gem::Version
-  version: 0.21.0
+  version: 0.23.0
 platform: ruby
 authors:
 - TJ Taylor
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2022-11-20 00:00:00.000000000 Z
+date: 2022-12-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: nokogiri
@@ -68,10 +68,10 @@ files:
 - lib/draftjs_html/draftjs/raw_builder.rb
 - lib/draftjs_html/draftjs/to_raw.rb
 - lib/draftjs_html/from_html.rb
+- lib/draftjs_html/from_html/char_list.rb
 - lib/draftjs_html/from_html/depth_stack.rb
 - lib/draftjs_html/from_html/elements.rb
 - lib/draftjs_html/from_html/pending_block.rb
-- lib/draftjs_html/from_html/style_stack.rb
 - lib/draftjs_html/html_defaults.rb
 - lib/draftjs_html/html_depth.rb
 - lib/draftjs_html/node.rb
@@ -100,7 +100,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.6
+rubygems_version: 3.3.26
 signing_key: 
 specification_version: 4
 summary: A tool for converting DraftJS JSON to HTML (and back again)

data/lib/draftjs_html/from_html/style_stack.rb

@@ -1,50 +0,0 @@
-module DraftjsHtml
-  class FromHtml < Nokogiri::XML::SAX::Document
-    class StyleStack
-      def initialize
-        @stack = []
-      end
-
-      def clear_finished
-        @stack.delete_if { !!_1[:finish] }
-      end
-
-      def each(&block)
-        @stack.reverse_each.group_by { _1[:tagname] }.each do |_, descriptors|
-          overlapping_ranges = find_overlapping_styles(descriptors)
-          widest_descriptor = overlapping_ranges.max_by { (_1[:start].._1[:finish]).size }
-
-          applicable_styles = descriptors - overlapping_ranges + [widest_descriptor].compact
-          applicable_styles.each(&block)
-        end
-      end
-
-      def track_start(tagname, current_character_offset)
-        style = DraftjsHtml::HtmlDefaults::HTML_STYLE_TAGS_TO_STYLE[tagname]
-        @stack.unshift({ tagname: tagname, style: style, start: current_character_offset })
-      end
-
-      def track_end(tagname, current_character_offset)
-        descriptor_index = @stack.find_index { _1[:tagname] == tagname && !_1[:finish] }
-        descriptor = @stack[descriptor_index]
-        descriptor[:finish] = current_character_offset
-      end
-
-      private
-
-      def find_overlapping_styles(descriptors)
-        descriptors.select do |candidate_a|
-          candidate_range = candidate_a[:start]..candidate_a[:finish]
-          (descriptors - [candidate_a]).any? do |other|
-            other_range = other[:start]..other[:finish]
-            range_overlaps?(candidate_range, other_range)
-          end
-        end
-      end
-
-      def range_overlaps?(candidate_range, other_range)
-        other_range.begin == candidate_range.begin || candidate_range.cover?(other_range.begin) || other_range.cover?(candidate_range.begin)
-      end
-    end
-  end
-end