prosereflect 0.1.1 → 0.3.0

data/lib/prosereflect/schema/fragment.rb

@@ -0,0 +1,166 @@
+# frozen_string_literal: true
+
+module Prosereflect
+  class Schema
+    # Lightweight Fragment class for schema validation
+    # This is a minimal implementation focused on the operations needed by ContentMatch
+    class Fragment
+      attr_reader :content
+
+      def initialize(content = [])
+        @content = content.is_a?(Array) ? content : [content].compact
+      end
+
+      def size
+        @content.sum(&:node_size)
+      end
+
+      def empty?
+        @content.empty?
+      end
+
+      def first
+        @content.first
+      end
+
+      def last
+        @content.last
+      end
+
+      def [](index)
+        @content[index]
+      end
+
+      def []=(index, value)
+        @content[index] = value
+      end
+
+      def length
+        @content.length
+      end
+
+      def each(&block)
+        @content.each(&block)
+      end
+
+      def <<(node)
+        @content << node
+        self
+      end
+
+      def append(other)
+        return self if other.empty?
+        return other if empty?
+
+        last_node = @content.last
+        first_other = other.first
+
+        if last_node.text? && first_other.text? && last_node.same_markup?(first_other)
+          merged = last_node.with_text(last_node.text + first_other.text)
+          new_content = @content[0...-1] + [merged] + other.content[1..]
+          Fragment.new(new_content)
+        else
+          Fragment.new(@content + other.content)
+        end
+      end
+
+      def cut(from = 0, to = nil)
+        to ||= size
+        return Fragment.empty if from.zero? && to == size
+
+        return Fragment.empty if to <= from
+
+        result = []
+        pos = 0
+        i = 0
+
+        while pos < to && i < @content.length
+          child = @content[i]
+          child_end = pos + child.node_size
+
+          if child_end > from
+            if pos < from || child_end > to
+              if child.text?
+                start_offset = [0, from - pos].max
+                end_offset = [child.text.length, to - pos].min
+              else
+                start_offset = [0, from - pos - 1].max
+                end_offset = [child.content.size, to - pos - 1].min
+              end
+              cut_child = child.cut(start_offset, end_offset)
+              result << cut_child if cut_child
+            else
+              result << child
+            end
+          end
+
+          pos = child_end
+          i += 1
+        end
+
+        Fragment.new(result)
+      end
+
+      def replace_child(index, replacement)
+        return self if @content[index] == replacement
+
+        new_content = @content.dup
+        new_content[index] = replacement
+        Fragment.new(new_content)
+      end
+
+      def eq?(other)
+        return false unless @content.length == other.content.length
+
+        @content.each_with_index.all? { |node, i| node.eq?(other.content[i]) }
+      end
+
+      def nodes_between(from, to, f, node_start = 0)
+        i = 0
+        pos = 0
+
+        while pos < to && i < @content.length
+          child = @content[i]
+          end_pos = pos + child.node_size
+
+          if end_pos > from && f.call(child, node_start + pos,
+                                      i) != false && child.content.size.positive?
+            child.nodes_between(
+              [0, from - pos].max,
+              [child.content.size, to - pos].min,
+              f,
+              node_start + pos + 1,
+            )
+          end
+
+          pos = end_pos
+          i += 1
+        end
+      end
+
+      def descendants(f)
+        nodes_between(0, size, f)
+      end
+
+      def to_s
+        "<#{@content.join(', ')}>"
+      end
+
+      class << self
+        def empty
+          @empty ||= new([])
+        end
+
+        def from(nodes)
+          return empty if nodes.nil? || (nodes.is_a?(Array) && nodes.empty?)
+
+          case nodes
+          when Fragment then nodes
+          when Array then new(nodes)
+          else new([nodes])
+          end
+        end
+      end
+    end
+  end
+end

data/lib/prosereflect/schema/mark.rb

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+module Prosereflect
+  class Schema
+    # Lightweight Mark class for schema validation
+    class Mark
+      attr_reader :type, :attrs
+
+      def initialize(type:, attrs: {})
+        @type = type
+        @attrs = attrs || {}
+      end
+
+      def eq?(other)
+        return false unless other.is_a?(Mark)
+
+        @type == other.type && @attrs == other.attrs
+      end
+
+      def same_set?(other_marks)
+        return false unless other_marks.length == length
+
+        other_marks.each_with_index.all? { |m, i| self[i].eq?(m) }
+      end
+
+      def [](index)
+        @type.is_a?(Array) ? @type[index] : self
+      end
+
+      def length
+        1
+      end
+
+      def is_in_set?(mark_set)
+        mark_set.any? { |m| m.type == @type }
+      end
+
+      # Add this mark to a set, respecting exclusion rules and rank ordering
+      # Follows prosemirror-py Mark.add_to_set logic
+      def add_to_set(mark_set)
+        copy = nil
+        placed = false
+
+        mark_set.each_with_index do |other, i|
+          if eq?(other)
+            # Self already in set, return unchanged
+            return mark_set
+          end
+
+          if @type.excludes?(other.type)
+            # This mark's type excludes the other's type
+            # Remove the other from the result by starting copy
+            copy ||= mark_set[0...i]
+          elsif other.type.excludes?(@type)
+            # Other's type excludes this mark's type - don't add
+            return mark_set
+          else
+            # No exclusion - insert before if other's rank is higher and not yet placed
+            if !placed && other.type.rank > @type.rank
+              copy ||= mark_set[0...i]
+              copy << self
+              placed = true
+            end
+            copy << other if copy
+          end
+        end
+
+        copy ||= mark_set.dup
+        copy << self unless placed
+        sort_marks(copy)
+      end
+
+      def remove_from_set(mark_set)
+        mark_set.reject { |m| m.type == @type }
+      end
+
+      def to_h
+        result = { "type" => @type.name }
+        result["attrs"] = @attrs unless @attrs.empty?
+        result
+      end
+
+      def to_s
+        "<Mark #{@type.name}>"
+      end
+
+      class << self
+        def set_from(marks)
+          return none if marks.nil? || marks.empty?
+
+          marks.filter_map { |m| m.is_a?(Mark) ? m : m }
+        end
+
+        def none
+          @none ||= []
+        end
+
+        def sort_marks(marks)
+          marks.sort_by { |m| m.type.rank }
+        end
+
+        # Class method for comparing two mark sets
+        # Returns true if both sets contain the same marks in the same order
+        def same_set(a, b)
+          return true if a == b
+          return false unless a.length == b.length
+
+          a.each_with_index.all? do |mark_a, i|
+            mark_a.eq?(b[i])
+          end
+        end
+      end
+
+      private
+
+      def sort_marks(marks)
+        marks.sort_by { |m| m.type.rank }
+      end
+    end
+  end
+end

data/lib/prosereflect/schema/mark_type.rb

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+module Prosereflect
+  class Schema
+    class MarkType
+      attr_reader :name, :attrs, :rank, :schema, :spec
+      attr_accessor :excluded
+
+      def initialize(name:, attrs: {}, rank: 0, schema: nil, spec: nil,
+inclusive: true)
+        @name = name
+        @attrs = attrs
+        @rank = rank
+        @schema = schema
+        @spec = spec
+        @inclusive = inclusive
+        @excluded = []
+      end
+
+      def self.from_spec(name, rank, schema, spec)
+        attrs = {}
+        if spec.respond_to?(:attrs)
+          spec_attrs = spec.attrs
+          attrs = if spec_attrs.is_a?(Hash)
+                    # New format: {"attr_name" => {default: value}}
+                    spec_attrs.each_with_object({}) do |(attr_name, attr_spec), hash|
+                      if attr_spec.respond_to?(:name)
+                        hash[attr_name] =
+                          Attribute.new(name: attr_spec.name,
+                                        default: attr_spec.default, validate: nil)
+                      else
+                        # attr_spec is a Hash
+                        attr_name = attr_spec[:name] || attr_spec["name"] || attr_name
+                        default = attr_spec[:default] || attr_spec["default"]
+                        hash[attr_name] =
+                          Attribute.new(name: attr_name, default: default,
+                                        validate: nil)
+                      end
+                    end
+                  else
+                    # Old format: values are attribute objects
+                    spec_attrs.transform_values do |a|
+                      Attribute.new(name: a.name, default: a.default, validate: nil)
+                    end
+                  end
+        elsif spec.is_a?(Hash)
+          spec_attrs = spec[:attrs] || spec["attrs"] || {}
+          attrs = spec_attrs.transform_values do |v|
+            Attribute.new(name: v[:name] || v["name"],
+                          default: v[:default] || v["default"])
+          end
+        end
+
+        new(
+          name: name,
+          attrs: attrs,
+          rank: rank,
+          schema: schema,
+          spec: spec,
+          inclusive: if spec.respond_to?(:inclusive)
+                       spec.inclusive
+                     elsif spec.key?(:inclusive)
+                       spec[:inclusive]
+                     elsif spec.key?("inclusive")
+                       spec["inclusive"]
+                     else
+                       true
+                     end,
+        )
+      end
+
+      def create(attrs = nil)
+        return instance if attrs.nil? && @instance
+
+        computed_attrs = compute_attrs(attrs)
+        Mark.new(type: self, attrs: computed_attrs)
+      end
+
+      def remove_from_set(mark_set)
+        mark_set.reject { |m| m.type == self }
+      end
+
+      def is_in_set?(mark_set)
+        mark_set.any? { |m| m.type == self }
+      end
+
+      def check_attrs(attrs)
+        attrs ||= {}
+        attrs.each do |attr_name, value|
+          unless @attrs.key?(attr_name)
+            raise Prosereflect::SchemaErrors::ValidationError,
+                  "Unsupported attribute #{attr_name} for mark #{@name}"
+          end
+
+          attr_def = @attrs[attr_name]
+          attr_def&.validate_value(value)
+        end
+      end
+
+      def excludes?(other_mark_type)
+        @excluded.include?(other_mark_type)
+      end
+
+      def inclusive?
+        @inclusive
+      end
+
+      def instance
+        @instance ||= create(nil)
+      end
+
+      private
+
+      def compute_attrs(attrs)
+        built = {}
+        @attrs.each do |name, attr_def|
+          if attrs&.key?(name)
+            built[name] = attrs[name]
+          elsif attr_def.has_default?
+            built[name] = attr_def.default
+          else
+            raise Prosereflect::SchemaErrors::ValidationError,
+                  "No value supplied for required attribute #{name} on mark #{@name}"
+          end
+        end
+        built
+      end
+    end
+  end
+end

data/lib/prosereflect/schema/node.rb

@@ -0,0 +1,236 @@
+# frozen_string_literal: true
+
+module Prosereflect
+  class Schema
+    # Lightweight Node class for schema validation
+    # This wraps the existing prosereflect Node and provides schema-aware methods
+    class Node
+      attr_reader :type, :attrs, :content, :marks
+
+      def initialize(type:, attrs: {}, content: nil, marks: [])
+        @type = type
+        @attrs = attrs || {}
+        @content = if content.is_a?(Fragment)
+                     content
+                   else
+                     (content ? Fragment.new(content) : Fragment.empty)
+                   end
+        @marks = if marks.is_a?(Array)
+                   marks
+                 else
+                   (marks ? [marks] : [])
+                 end
+      end
+
+      def node_size
+        size = 1 # Every node has at least size 1
+        @content.content.each do |child|
+          size += child.node_size
+        end
+        size
+      end
+
+      def text?
+        @type.text?
+      end
+
+      def is_text
+        text?
+      end
+
+      def is_block
+        @type.is_block?
+      end
+
+      def is_inline
+        @type.is_inline?
+      end
+
+      def is_leaf
+        @type.is_leaf?
+      end
+
+      def is_atom
+        @type.is_atom?
+      end
+
+      def same_markup?(other)
+        return false unless @type == other.type && @marks.length == other.marks.length
+
+        @marks.zip(other.marks).all? do |m1, m2|
+          m1.type == m2.type && m1.attrs == m2.attrs
+        end
+      end
+
+      def with_text(new_text)
+        TextNode.new(type: @type, attrs: @attrs, text: new_text, marks: @marks)
+      end
+
+      def cut(from = 0, to = nil)
+        to ||= node_size
+        return self if from.zero? && to == node_size
+
+        if text?
+          # For text nodes, cut by character offset
+          TextNode.new(
+            type: @type,
+            attrs: @attrs,
+            text: @attrs[:text][from...to],
+            marks: @marks,
+          )
+        else
+          # For non-text nodes, cut content
+          new_content = @content.cut(from - 1, to - 1)
+          Node.new(type: @type, attrs: @attrs, content: new_content,
+                   marks: @marks)
+        end
+      end
+
+      def nodes_between(from, to, f, node_start = 0)
+        return unless to > from
+
+        if text?
+          f.call(self, node_start)
+          return
+        end
+
+        pos = 0
+        i = 0
+
+        while pos < to && i < @content.content.length
+          child = @content.content[i]
+          end_pos = pos + child.node_size
+
+          if end_pos > from
+            child_start = node_start + pos + 1
+            if f.call(child, child_start,
+                      i) != false && child.content.size.positive?
+              child.nodes_between(
+                [0, from - pos].max,
+                [child.content.size, to - pos].min,
+                f,
+                child_start,
+              )
+            end
+          end
+
+          pos = end_pos
+          i += 1
+        end
+      end
+
+      def descendants(f)
+        nodes_between(0, node_size, f)
+      end
+
+      def eq?(other)
+        return false unless other.is_a?(Node)
+        return false unless @type == other.type
+
+        @attrs == other.attrs && @content.eq?(other.content) && same_marks?(other)
+      end
+
+      def same_marks?(other)
+        return true if @marks.nil? && other.marks.nil?
+        return false if @marks.nil? || other.marks.nil?
+        return false unless @marks.length == other.marks.length
+
+        @marks.each_with_index.all? do |m, i|
+          m.type == other.marks[i].type && m.attrs == other.marks[i].attrs
+        end
+      end
+
+      def to_h
+        result = { "type" => @type.name }
+
+        if @attrs && !@attrs.empty?
+          result["attrs"] = @attrs
+        end
+
+        if @marks && !@marks.empty?
+          result["marks"] = @marks.map(&:to_h)
+        end
+
+        if @content && !@content.empty?
+          result["content"] = @content.content.map(&:to_h)
+        end
+
+        result
+      end
+
+      def to_s
+        "<Node #{@type.name}>"
+      end
+
+      class << self
+        def from_json(schema, json)
+          type_name = json["type"]
+          type = schema.node_type(type_name)
+
+          attrs = json["attrs"] || {}
+          content_data = json["content"]
+
+          marks = if json["marks"].is_a?(Array)
+                    json["marks"].map { |m| schema.mark_from_json(m) }
+                  else
+                    []
+                  end
+
+          # Handle text nodes specially
+          if type.text?
+            text = json["text"] || ""
+            TextNode.new(type: type, attrs: attrs, text: text, marks: marks)
+          else
+            content = if content_data.is_a?(Array)
+                        content_data.map { |c| from_json(schema, c) }
+                      else
+                        []
+                      end
+            Node.new(type: type, attrs: attrs, content: Fragment.new(content),
+                     marks: marks)
+          end
+        end
+      end
+    end
+
+    # Lightweight TextNode for schema validation
+    class TextNode < Node
+      attr_reader :text
+
+      def initialize(type:, attrs: {}, text: "", marks: [])
+        super(type: type, attrs: { text: text }, content: Fragment.empty, marks: marks)
+        @text = text
+      end
+
+      def node_size
+        @text.length + 1
+      end
+
+      def text_content
+        @text
+      end
+
+      def cut(from = 0, to = nil)
+        to ||= @text.length
+        TextNode.new(type: @type, attrs: { text: @text[from...to] },
+                     text: @text[from...to], marks: @marks)
+      end
+
+      def eq?(other)
+        return false unless other.is_a?(TextNode)
+
+        @text == other.text && super
+      end
+
+      def to_h
+        result = { "type" => @type.name, "text" => @text }
+        result["marks"] = @marks.map(&:to_h) if @marks && !@marks.empty?
+        result
+      end
+
+      def to_s
+        "<TextNode \"#{@text[0, 20]}\">"
+      end
+    end
+  end
+end