portable_text 0.1.0

data/lib/portable_text/html/base_component.rb

@@ -0,0 +1,19 @@
+# Base component for PortableText HTML components
+# It overrides Dry::Initializer option and params to allow using them without triggering weird errors
+# See https://github.com/orgs/phlex-ruby/discussions/553
+
+module PortableText
+  module Html
+    class BaseComponent < Phlex::HTML
+      extend Dry::Initializer
+
+      def self.option(*args, **kwargs, &block)
+        super(*args, reader: false, **kwargs, &block)
+      end
+
+      def self.param(*args, **kwargs, &block)
+        super(*args, reader: false, **kwargs, &block)
+      end
+    end
+  end
+end

data/lib/portable_text/html/block_types/block.rb

@@ -0,0 +1,32 @@
+module PortableText
+  module Html
+    module BlockTypes
+      class Block < Html::BaseComponent
+        include Configured
+
+        param :block
+        delegate :style, :children, :mark_defs, :list_item, to: :@block
+
+        def view_template
+          node_style = node.fetch(:node)
+          node_arguments = node.except(:node)
+
+          send(node_style, **node_arguments) do
+            children.each do |child|
+              render block_type(:span).new(child, mark_defs: mark_defs)
+            end
+          end
+        end
+
+        private
+
+        def node
+          return @node if defined?(@node)
+          return @node = config.block.styles.fetch(:li) if list_item.present?
+
+          @node = config.block.styles.fetch(style&.to_sym, { node: :p })
+        end
+      end
+    end
+  end
+end

data/lib/portable_text/html/block_types/image.rb

@@ -0,0 +1,17 @@
+module PortableText
+  module Html
+    module BlockTypes
+      class Image < Html::BaseComponent
+        param :image
+
+        def view_template
+          if @image.asset.key?("url")
+            img(src: @image.asset["url"])
+          else
+            div { "Please provide a url for this image" }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/portable_text/html/block_types/list.rb

@@ -0,0 +1,29 @@
+module PortableText
+  module Html
+    module BlockTypes
+      class List < Html::BaseComponent
+        include Configured
+
+        param :list
+        delegate :items, :list_type, to: :@list
+
+        def view_template
+          node_style = node.fetch(:node)
+          node_arguments = node.except(:node)
+
+          send(node_style, **node_arguments) do
+            items.each do |block|
+              render block_type(block.type).new(block)
+            end
+          end
+        end
+
+        private
+
+        def node
+          @node ||= config.block.list_types.fetch(list_type.to_sym, { node: :ul })
+        end
+      end
+    end
+  end
+end

data/lib/portable_text/html/block_types/null.rb

@@ -0,0 +1,13 @@
+module PortableText
+  module Html
+    module BlockTypes
+      class Null < Html::BaseComponent
+        param :block
+
+        def view_template
+          div { "This block type is not referenced yet: #{@block.type}" }
+        end
+      end
+    end
+  end
+end

data/lib/portable_text/html/block_types/span.rb

@@ -0,0 +1,84 @@
+module PortableText
+  module Html
+    module BlockTypes
+      class Span < Html::BaseComponent
+        include Configured
+
+        param :span
+        option :mark_defs, default: proc { [] }
+        delegate :marks, :text, to: :@span
+
+        def view_template
+          root = create_nodes
+          visit(root)
+        end
+
+        private
+
+        # Visit a node and render it
+        # If the node is a mark definition, render the appropriate mark definition
+        # Otherwise, render the node with the appropriate mark decorator
+        # If the node has a child, visit the child
+        # Else render the node as plain text
+        # -------------
+        # Mark definitions and mark decorators are defined in the configuration
+        # If a mark definition is not found, a Null mark definition is rendered along with an error message
+        # if a mark is not found, a span tag is rendered
+        def visit(node)
+          return plain(node.value) if node.child.nil?
+
+          if matching_mark_def?(node.value)
+            annotation = @mark_defs.find { |mark_def| mark_def.key == node.value }
+
+            render annotation_klass(annotation).new(annotation) do
+              visit(node.child)
+            end
+          else
+            decorator = config.span.marks.fetch(node.value.to_sym, { node: :span })
+            mark_node = decorator.fetch(:node)
+            node_arguments = decorator.except(:node)
+
+            send(mark_node, **node_arguments) { visit(node.child) }
+          end
+        end
+
+        def annotation_klass(annotation)
+          config.block.mark_defs.fetch(annotation.type.to_sym, Html::MarkDefs::Null)
+        end
+
+        def matching_mark_def?(mark)
+          return false unless @mark_defs.present?
+
+          @mark_defs.map(&:key).include?(mark)
+        end
+
+        class Node
+          attr_accessor :value, :child
+
+          def initialize(value:, child: nil)
+            @value = value
+            @child = child
+          end
+        end
+
+        # Create a linked list of nodes to make it easier to traverse the tree of marks
+        # Marks are traversed in the marks order and the text is the last node
+        def create_nodes
+          nodes = marks + [text]
+
+          root = Node.new(value: nodes.first)
+          return root if nodes.size == 1
+
+          current_node = root
+
+          nodes[1..].each do |mark|
+            current_node.child = Node.new(value: mark)
+            current_node = current_node.child
+          end
+
+          root
+        end
+      end
+    end
+  end
+end

data/lib/portable_text/html/config.rb

@@ -0,0 +1,48 @@
+module PortableText
+  module Html
+    class Config
+      extend Dry::Configurable
+
+      # Default settings
+      # These can be overridden
+      # Example: PortableText::Html.config.block.types.merge!({ block: MyCustomBlock })
+
+      setting :block do
+        setting :types, default: {
+          block: Html::BlockTypes::Block,
+          image: Html::BlockTypes::Image,
+          list: Html::BlockTypes::List,
+          span: Html::BlockTypes::Span
+        }
+
+        setting :styles, default: {
+          h1: { node: :h1 },
+          h2: { node: :h2 },
+          h3: { node: :h3 },
+          h4: { node: :h4 },
+          h5: { node: :h5 },
+          h6: { node: :h6 },
+          blockquote: { node: :blockquote },
+          normal: { node: :p },
+          li: { node: :li }
+        }
+
+        setting :mark_defs, default: {
+          link: Html::MarkDefs::Link
+        }
+
+        setting :list_types, default: {
+          bullet: { node: :ul },
+          numeric: { node: :ol }
+        }
+      end
+
+      setting :span do
+        setting :marks, default: {
+          strong: { node: :strong },
+          em: { node: :em }
+        }
+      end
+    end
+  end
+end

data/lib/portable_text/html/configured.rb

@@ -0,0 +1,11 @@
+module PortableText
+  module Html
+    module Configured
+      def config = Config.config
+
+      def block_type(type)
+        config.block.types.fetch(type.to_sym, BlockTypes::Null)
+      end
+    end
+  end
+end

data/lib/portable_text/html/mark_defs/base.rb

@@ -0,0 +1,14 @@
+module PortableText
+  module Html
+    module MarkDefs
+      class Base < Html::BaseComponent
+        param :mark_def
+        delegate :type, :key, to: :@mark_def
+
+        def view_template
+          raise PortableText::Errors::UnimplementedError
+        end
+      end
+    end
+  end
+end

data/lib/portable_text/html/mark_defs/link.rb

@@ -0,0 +1,13 @@
+module PortableText
+  module Html
+    module MarkDefs
+      class Link < Base
+        delegate :href, to: :@mark_def
+
+        def view_template(&block)
+          a(href: href, &block)
+        end
+      end
+    end
+  end
+end

data/lib/portable_text/html/mark_defs/null.rb

@@ -0,0 +1,13 @@
+module PortableText
+  module Html
+    module MarkDefs
+      class Null < Base
+        def view_template
+          div do
+            "Missing mark def html renderer for type: #{type} - key: #{key}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/portable_text/html/rendering.rb

@@ -0,0 +1,7 @@
+module PortableText
+  module Html
+    module Rendering
+      def render(view, **parameters) = view.call(**parameters)
+    end
+  end
+end

data/lib/portable_text/html/serializer.rb

@@ -0,0 +1,17 @@
+module PortableText
+  module Html
+    class Serializer < Html::BaseComponent
+      include Configured
+
+      param :blocks
+
+      def content(**_options) = self
+
+      def view_template
+        @blocks.each do |block|
+          render block_type(block.type).new(block)
+        end
+      end
+    end
+  end
+end

data/lib/portable_text/mark_defs/base.rb

@@ -0,0 +1,10 @@
+module PortableText
+  module MarkDefs
+    class Base
+      extend Dry::Initializer
+
+      option :_key, as: :key
+      option :_type, as: :type
+    end
+  end
+end

data/lib/portable_text/mark_defs/link.rb

@@ -0,0 +1,7 @@
+module PortableText
+  module MarkDefs
+    class Link < Base
+      option :href, default: proc { "" }
+    end
+  end
+end

data/lib/portable_text/mark_defs/null.rb

@@ -0,0 +1,6 @@
+module PortableText
+  module MarkDefs
+    class Null < Base
+    end
+  end
+end

data/lib/portable_text/plain/serializer.rb

@@ -0,0 +1,34 @@
+module PortableText
+  module Plain
+    class Serializer
+      def initialize(blocks)
+        @blocks = blocks
+      end
+
+      def content(**_params)
+        visit(@blocks)
+      end
+
+      private
+
+      def visit(nodes)
+        nodes.map do |block|
+          case block.type
+          when "block"
+            block.children.map(&:text).join(" ").squeeze.strip
+          when "list"
+            visit(block.items)
+          when "image"
+            if block.asset.present?
+              block.asset["url"]
+            else
+              "image url not found"
+            end
+          else
+            "Block #{block.type} found"
+          end
+        end.join("\n")
+      end
+    end
+  end
+end

data/lib/portable_text/serializer.rb

@@ -0,0 +1,97 @@
+module PortableText
+  class Serializer
+    attr_reader :content, :blocks, :to, :converted
+
+    def initialize(content:, to: :html)
+      @content = content
+      @blocks = []
+      @to = to
+      @converted = false
+    end
+
+    # After conversion, the Portable Text content is serialized to the desired format.
+    def render(**options)
+      convert!
+
+      serializer.new(blocks).content(**options)
+    end
+
+    # Converts the Portable Text content into a collection of blocks converted to ruby objects
+    # along with their children and markDefs.
+    # Object parameters are symbolized and camelCase keys are converted to snake_case.
+    # This method is idempotent.
+    def convert!
+      return if converted
+
+      content.each do |block_params|
+        params = block_params.transform_keys(&:to_sym)
+        params[:children] = create_children(params[:children])
+        params[:markDefs] = create_mark_defs(params[:markDefs])
+
+        block = block_klass(params.fetch(:_type)).new(**params)
+        add_block(block)
+      end
+
+      @converted = true
+    end
+
+    # The serializer is determined by the `to` parameter, which defaults to `:html`.
+    # The serializer must be defined in the PortableText configuration.
+    def serializer
+      config.serializers.fetch(to) { raise Errors::UnknownSerializerError }
+    end
+
+    private
+
+    def config = PortableText.config
+
+    def block_klass(type)
+      config.block.types.fetch(type.to_sym, BlockTypes::Null)
+    end
+
+    # Adds a block to the blocks collection.
+    # If the block is a list item, it will be added to the last list block if it exists.
+    # Else a new list block will be created.
+    def add_block(block)
+      return blocks.push(block) unless block.list_item?
+
+      last_block = blocks.last
+
+      if last_block&.list?
+        last_block.add(block)
+      else
+        blocks.push(
+          block_klass(:list).new(
+            items: [block],
+            level: block.level,
+            parent: nil
+          )
+        )
+      end
+    end
+
+    def create_children(children)
+      return [] if children.blank?
+
+      children.map do |child|
+        block_klass(:span).new(**child.transform_keys(&:to_sym))
+      end
+    end
+
+    def create_mark_defs(mark_defs)
+      return [] if mark_defs.blank?
+
+      inflector = Dry::Inflector.new
+
+      mark_defs.map do |mark_def|
+        mark_def.transform_keys!(&:to_sym)
+        mark_type = inflector.underscore(mark_def[:_type]).to_sym
+
+        config.block.mark_defs.fetch(
+          mark_type,
+          MarkDefs::Null
+        ).new(**mark_def.merge(_type: mark_type))
+      end
+    end
+  end
+end

data/lib/portable_text/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module PortableText
+  VERSION = "0.1.0"
+end

data/lib/portable_text.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require "active_support"
+require "active_support/core_ext"
+require "dry/configurable"
+require "dry/inflector"
+require "dry/initializer"
+require "zeitwerk"
+require "phlex"
+
+module PortableText
+  def self.config = Config.config
+
+  module Html
+    def self.config = Html::Config.config
+  end
+end
+
+loader = Zeitwerk::Loader.for_gem
+loader.setup

data/sig/portable_text.rbs

@@ -0,0 +1,4 @@
+module PortableText
+  VERSION: String
+  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+end