prosemirror 0.4.0 → 0.6.0

data/lib/prosemirror/nodes/youtube.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require "uri"
+
+module Prosemirror
+  module Nodes
+    # Tiptap's YouTube embed. `src` is the video's URL, like `https://www.youtube.com/watch?v=…`, rendered as
+    # an iframe of its embed URL. Without a YouTube URL, it renders nothing. Override `embed_host` for
+    # `https://www.youtube-nocookie.com`, as Tiptap's `nocookie` option.
+    class Youtube < NodeType
+      # The URLs Tiptap accepts: on youtube.com, youtu.be and youtube-nocookie.com.
+      URL = %r{\A(?:(?:https?:)?//)?(?:(?:www|m|music)\.)?(?:youtube\.com|youtu\.be|youtube-nocookie\.com)(?:/(?:[\w-]+\?v=|embed/|v/)?)[\w-]+\S*\z}
+      EMBED_HOSTS = %w[youtube.com youtube-nocookie.com].freeze
+
+      group :block
+
+      prop :src, _String(length: 1..), parse_html: ->(element) { Youtube.from_embed_url(element["src"])&.fetch(:src) || element["src"] }
+      prop :start, _Integer(0..), default: 0,
+        parse_html: ->(element) { Youtube.from_embed_url(element["src"])&.fetch(:start) }, &Coerce::INTEGER
+      prop :width, _Integer?(1..), default: 640, &Coerce::INTEGER
+      prop :height, _Integer?(1..), default: 480, &Coerce::INTEGER
+
+      # Tiptap's markup, `<div data-youtube-video><iframe>`, or an iframe of a YouTube embed URL.
+      parse_html(tag: "iframe[src]") do |element|
+        (element.parent&.key?("data-youtube-video") || Youtube.from_embed_url(element["src"])) ? {} : false
+      end
+
+      def view_template
+        src = safe_url(self.class.embed_url(@src, start: @start, host: embed_host))
+        return unless src
+
+        div(data_youtube_video: "") { iframe(src:, width: @width, height: @height, allowfullscreen: true) }
+      end
+
+      def embed_host = "https://www.youtube.com"
+
+      # The URL, as text that Markdown links. With `html: true`, the iframe.
+      def to_markdown(markdown, _parent, _index)
+        markdown.write(markdown.html? ? markdown.node_html(node) : "<#{markdown.url(@src)}>")
+        markdown.close_block(node)
+      end
+
+      # The embed URL of a video or playlist, as Tiptap builds it, or nil.
+      def self.embed_url(src, start: 0, host: "https://www.youtube.com")
+        return unless src.match?(URL)
+
+        if (playlist = src[/[?&]list=([\w-]+)/, 1])
+          return "#{host}/embed/videoseries?list=#{playlist}"
+        end
+
+        id = src[%r{(?:youtu\.be/|/embed/|/v/|/shorts/|/live/|[?&]v=)([\w-]+)}, 1]
+        id && "#{host}/embed/#{id}#{"?start=#{start}" if start.positive?}"
+      end
+
+      # The video URL and start time of an embed URL, as Tiptap reads them, or nil.
+      def self.from_embed_url(url)
+        uri = URI.parse(url.to_s)
+        return unless uri.is_a?(URI::HTTP) && EMBED_HOSTS.include?(uri.host.to_s.delete_prefix("www."))
+
+        query = URI.decode_www_form(uri.query.to_s).to_h
+        src = case uri.path
+        when "/embed/videoseries" then query["list"]&.then { |list| "https://www.youtube.com/playlist?list=#{list}" }
+        when %r{\A/embed/([\w-]+)\z} then "https://www.youtube.com/watch?v=#{Regexp.last_match(1)}"
+        end
+        {src:, start: query["start"].to_i} if src&.match?(URL)
+      rescue URI::Error, ArgumentError
+        nil
+      end
+    end
+  end
+end

data/lib/prosemirror/schema.rb

@@ -24,13 +24,17 @@ module Prosemirror
     # Called with an `InvalidDocument` error for each problem fixed.
     prop :on_invalid, _Callable?, reader: false
 
-    # Tiptap's StarterKit and common extensions.
-    def self.tiptap(**)
+    # Tiptap's StarterKit and common extensions. `text_align: true` adds the TextAlign extension, configured
+    # for headings and paragraphs.
+    def self.tiptap(text_align: false, **)
       new(
         nodes: [
-          Nodes::Doc, Nodes::Paragraph, Nodes::Text, Nodes::Heading, Nodes::Blockquote, Nodes::BulletList,
+          Nodes::Doc, text_align ? TextAlign::Paragraph : Nodes::Paragraph, Nodes::Text,
+          text_align ? TextAlign::Heading : Nodes::Heading, Nodes::Blockquote, Nodes::BulletList,
           Nodes::OrderedList, Nodes::ListItem, Nodes::CodeBlock, Nodes::HardBreak, Nodes::HorizontalRule,
-          Nodes::Image, Nodes::Table, Nodes::TableRow, Nodes::TableHeader, Nodes::TableCell
+          Nodes::Image, Nodes::Table, Nodes::TableRow, Nodes::TableHeader, Nodes::TableCell, Nodes::TaskList,
+          Nodes::TaskItem, Nodes::Details, Nodes::DetailsSummary, Nodes::DetailsContent, Nodes::Youtube,
+          Nodes::Twitch, Nodes::Mention
         ],
         # In Tiptap's order, which sorts and nests marks.
         marks: [
@@ -57,6 +61,8 @@ module Prosemirror
     def after_initialize
       @node_lookup = lookup(@nodes)
       @mark_lookup = lookup(@marks)
+      @node_names = spellings(@node_lookup)
+      @mark_names = spellings(@mark_lookup)
       @textblocks = @nodes.to_h { |type| [type, textblock_type?(type)] }
       @content_matches = @nodes.to_h { |type| [type, ContentMatch.compile(type.content, self)] }
       raise ArgumentError, "the schema has no #{@top_node} node type" unless node_type(@top_node)
@@ -100,11 +106,11 @@ module Prosemirror
 
     # The node type for a name, alias, or camelCase name.
     def node_type(name)
-      @node_lookup[Naming.snake(name).to_sym]
+      @node_names[name] || @node_lookup[Naming.snake(name).to_sym]
     end
 
     def mark_type(name)
-      @mark_lookup[Naming.snake(name).to_sym]
+      @mark_names[name] || @mark_lookup[Naming.snake(name).to_sym]
     end
 
     # Build a document from JSON, given as a Hash or a String.
@@ -228,6 +234,16 @@ module Prosemirror
       end
     end
 
+    # The names of a lookup table, as Symbols and Strings, in snake_case and camelCase, so that most names
+    # are found without converting them.
+    def spellings(lookup)
+      table = {}
+      lookup.each { |name, type| table[name] = table[name.name] = type }
+      lookup.each { |name, type| table[Naming.camel(name).freeze] ||= type }
+      table.each_key.select { |name| name.is_a?(String) }.each { |name| table[name.to_sym] ||= table[name] }
+      table.freeze
+    end
+
     def merge_types(types, additions)
       additions.reduce(types) do |list, addition|
         index = list.index { |type| type.type_name == addition.type_name }

data/lib/prosemirror/text_align.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Prosemirror
+  # Tiptap's TextAlign extension: a `textAlign` attribute, rendered as a `text-align` style. Included in the
+  # paragraphs and headings of `Schema.tiptap(text_align: true)`. A custom type includes it, and renders
+  # `style: text_align_style`.
+  module TextAlign
+    ALIGNMENTS = %w[left center right justify].freeze
+
+    def self.included(type)
+      # From the `text-align` style, or the old `align` attribute, which Tiptap doesn't read.
+      type.prop :text_align, type._Union?(*ALIGNMENTS), json: "textAlign", parse_html: lambda { |element|
+        (element.style["text-align"] || element["align"]).to_s.strip.downcase.then { |value| value if ALIGNMENTS.include?(value) }
+      }
+    end
+
+    def text_align_style = @text_align && "text-align: #{@text_align}"
+
+    class Paragraph < Nodes::Paragraph
+      include TextAlign
+
+      def view_template(&) = p(style: text_align_style, &)
+    end
+
+    class Heading < Nodes::Heading
+      include TextAlign
+
+      def view_template(&) = tag(:"h#{@level}", style: text_align_style, &)
+    end
+  end
+end

data/lib/prosemirror/type_definition.rb

@@ -3,6 +3,7 @@
 module Prosemirror
   # Class-level declarations shared by node types and mark types.
   module TypeDefinition
+    EMPTY_HASH = {}.freeze
     # The name of the type, as a snake_case Symbol. It defaults to the class name (`BulletList` → `:bullet_list`),
     # and subclasses of a concrete type keep its name.
     def type_name(name = nil)
@@ -24,7 +25,12 @@ module Prosemirror
     # - `parse_html:` a block reading the attribute from an HTML element, when importing HTML. By default,
     #   the HTML attribute with the JSON name is read.
     def prop(name, type, kind = :keyword, json: nil, aliases: [], parse_html: nil, **, &)
-      attribute_names[name] = {json: (json || name).to_s, aliases: aliases.map(&:to_s), parse_html:}.freeze
+      json = (json || name).to_s
+      aliases = aliases.map(&:to_s)
+      # The keys accepted in JSON: each name as written, in snake_case and in camelCase.
+      keys = [json, *aliases].flat_map { |key| [key, Naming.snake(key), Naming.camel(key)] }.uniq.map(&:freeze).freeze
+      attribute_names[name] = {json:, aliases:, parse_html:, keys:}.freeze
+      @known_keys = nil
       super(name, type, kind, **, &)
     end
 
@@ -54,7 +60,10 @@ module Prosemirror
     # Invalid values are converted when the meaning is clear, or replaced by their default.
     # Returns nil when a required attribute is missing or invalid.
     def build_attrs(given, report:)
-      given = given.is_a?(Hash) ? given.transform_keys(&:to_s) : {}
+      given = if !given.is_a?(Hash) then EMPTY_HASH
+      elsif keys?(given) { |key| key.is_a?(String) } then given
+      else given.transform_keys(&:to_s)
+      end
 
       literal_properties.each_with_object({}) do |property, attrs|
         json_name = attribute_names.dig(property.name, :json)
@@ -86,14 +95,19 @@ module Prosemirror
 
     # The JSON attributes this type doesn't declare, with String keys, so that `to_h` gives them back.
     def unknown_attrs(given)
-      return {} unless given.is_a?(Hash)
+      return EMPTY_HASH unless given.is_a?(Hash)
+
+      known = known_keys
+      return EMPTY_HASH if keys?(given) { |key| known.include?(key.is_a?(Symbol) ? key.name : key) }
 
-      known = attribute_names.values.flat_map do |names|
-        [names[:json], *names[:aliases]].flat_map { |name| [name, Naming.snake(name), Naming.camel(name)] }
-      end
       given.transform_keys(&:to_s).except(*known)
     end
 
+    # The JSON keys of the declared attributes, in all their spellings.
+    def known_keys
+      @known_keys ||= attribute_names.each_value.flat_map { |names| names[:keys] }.to_set.freeze
+    end
+
     # Attributes as JSON, with their JSON names.
     def serialize_attrs(attrs)
       attrs.to_h { |name, value| [attribute_names.dig(name, :json) || name.to_s, value] }
@@ -122,17 +136,23 @@ module Prosemirror
       superclass.send(:inherited_setting, ivar, default)
     end
 
+    # Whether the block is true for all keys of the hash, without the Enumerator `each_key.all?` allocates.
+    def keys?(hash)
+      hash.each_key { |key| return false unless yield(key) }
+      true
+    end
+
     def attribute_key(given, names)
-      [names[:json], *names[:aliases]].each do |name|
-        [name, Naming.snake(name), Naming.camel(name)].each do |candidate|
-          return candidate if given.key?(candidate)
-        end
-      end
-      nil
+      names[:keys].find { |key| given.key?(key) }
     end
 
+    # The gem's coercions don't use `self`: they are called directly, without Literal's `instance_exec`.
     def coerce_attribute(property, value)
-      property.coercion ? property.coerce(value, context: self) : value
+      coercion = property.coercion
+      if coercion.nil? then value
+      elsif Coerce::PLAIN.include?(coercion) then coercion.call(value)
+      else property.coerce(value, context: self)
+      end
     rescue
       value
     end

data/lib/prosemirror/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Prosemirror
-  VERSION = "0.4.0"
+  VERSION = "0.6.0"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: prosemirror
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.6.0
 platform: ruby
 authors:
 - Hans Lemuet
@@ -84,6 +84,7 @@ files:
 - lib/prosemirror/mark.rb
 - lib/prosemirror/mark_type.rb
 - lib/prosemirror/markdown/builder.rb
+- lib/prosemirror/markdown_serializer.rb
 - lib/prosemirror/marks/basic/code.rb
 - lib/prosemirror/marks/basic/em.rb
 - lib/prosemirror/marks/basic/link.rb
@@ -106,22 +107,31 @@ files:
 - lib/prosemirror/nodes/blockquote.rb
 - lib/prosemirror/nodes/bullet_list.rb
 - lib/prosemirror/nodes/code_block.rb
+- lib/prosemirror/nodes/details.rb
+- lib/prosemirror/nodes/details_content.rb
+- lib/prosemirror/nodes/details_summary.rb
 - lib/prosemirror/nodes/doc.rb
 - lib/prosemirror/nodes/hard_break.rb
 - lib/prosemirror/nodes/heading.rb
 - lib/prosemirror/nodes/horizontal_rule.rb
 - lib/prosemirror/nodes/image.rb
 - lib/prosemirror/nodes/list_item.rb
+- lib/prosemirror/nodes/mention.rb
 - lib/prosemirror/nodes/ordered_list.rb
 - lib/prosemirror/nodes/paragraph.rb
 - lib/prosemirror/nodes/table.rb
 - lib/prosemirror/nodes/table_cell.rb
 - lib/prosemirror/nodes/table_header.rb
 - lib/prosemirror/nodes/table_row.rb
+- lib/prosemirror/nodes/task_item.rb
+- lib/prosemirror/nodes/task_list.rb
 - lib/prosemirror/nodes/text.rb
+- lib/prosemirror/nodes/twitch.rb
+- lib/prosemirror/nodes/youtube.rb
 - lib/prosemirror/parse_rule.rb
 - lib/prosemirror/rendering.rb
 - lib/prosemirror/schema.rb
+- lib/prosemirror/text_align.rb
 - lib/prosemirror/text_serializer.rb
 - lib/prosemirror/transformer.rb
 - lib/prosemirror/type_definition.rb