prosereflect 0.2.0 → 0.3.0

data/lib/prosereflect/schema/node_type.rb

@@ -0,0 +1,274 @@
+# frozen_string_literal: true
+
+module Prosereflect
+  class Schema
+    class NodeType
+      attr_reader :name, :attrs, :content_match, :groups, :schema, :spec,
+                  :content_expression
+      attr_accessor :mark_set
+
+      def initialize(name:, attrs: {}, content_expression: nil, groups: [],
+                     schema: nil, spec: nil, inline: false, atom: false)
+        @name = name
+        @attrs = attrs
+        @groups = groups
+        @schema = schema
+        @spec = spec
+        @inline = inline
+        @atom = atom
+        @mark_set = nil
+        @content_expression = content_expression
+
+        # Content match will be built later by Schema#build_content_matches
+        # to avoid circular dependency issues during node type construction
+        @content_match = ContentMatch.empty
+      end
+
+      def self.from_spec(name, 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}} or attr_name as key
+                    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)
+                      else
+                        # attr_spec is a Hash with :default, :name, etc as keys
+                        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)
+                      end
+                    end
+                  else
+                    # Old format: values are attribute objects with .name and .default
+                    spec_attrs.transform_values do |a|
+                      Attribute.new(name: a.name, default: a.default)
+                    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"] || v.keys.first,
+              default: v[:default] || v["default"],
+            )
+          end
+        end
+
+        content_expr = spec.respond_to?(:content) ? spec.content : (spec[:content] || spec["content"])
+        groups = spec.respond_to?(:groups) ? spec.groups : parse_groups(spec)
+        inline = spec.respond_to?(:inline) ? spec.inline : (spec[:inline] || spec["inline"] || false)
+        atom = spec.respond_to?(:atom) ? spec.atom : (spec[:atom] || spec["atom"] || false)
+
+        new(
+          name: name,
+          attrs: attrs,
+          content_expression: content_expr,
+          groups: groups,
+          schema: schema,
+          spec: spec,
+          inline: inline,
+          atom: atom,
+        )
+      end
+
+      def self.parse_groups(spec)
+        group_str = spec[:group] || spec["group"]
+        return [] unless group_str
+
+        group_str.is_a?(Array) ? group_str : group_str.to_s.split
+      end
+
+      def is_block?
+        !@inline && @name != "text"
+      end
+
+      def is_inline?
+        !is_block?
+      end
+
+      alias inline? is_inline?
+
+      def text?
+        @name == "text"
+      end
+
+      def is_leaf?
+        @content_match == ContentMatch.empty || @content_match.edge_count.zero?
+      end
+
+      def is_atom?
+        is_leaf? || @atom
+      end
+
+      def is_textblock?
+        is_block? && @content_match.inline_content?
+      end
+
+      def in_group?(group_name)
+        return true if group_name == "inline" && text?
+        return true if group_name == "block" && is_block?
+
+        @groups.include?(group_name)
+      end
+
+      def has_required_attrs?
+        @attrs.values.any?(&:required?)
+      end
+
+      def default_attrs
+        defaults = {}
+        @attrs.each do |name, attr_def|
+          return nil unless attr_def.has_default?
+
+          defaults[name] = attr_def.default
+        end
+        defaults.empty? ? nil : defaults
+      end
+
+      def compute_attrs(attrs)
+        return default_attrs if attrs.nil?
+
+        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 attribute #{name} on node #{@name}"
+          end
+        end
+        built
+      end
+
+      # Create a node with validation
+      def create(attrs = nil, content = nil, marks = [])
+        if text?
+          raise Prosereflect::SchemaErrors::Error,
+                "NodeType.create cannot construct text nodes"
+        end
+
+        content_fragment = case content
+                           when Fragment then content
+                           when nil then Fragment.empty
+                           when Array then Fragment.new(content)
+                           when Node then Fragment.new([content])
+                           end
+
+        attrs = compute_attrs(attrs)
+        Node.new(type: self, attrs: attrs, content: content_fragment,
+                 marks: marks)
+      end
+
+      # Create a node with content validation
+      def create_checked(attrs = nil, content = nil, marks = [])
+        content_fragment = case content
+                           when Fragment then content
+                           when nil then Fragment.empty
+                           when Array then Fragment.new(content)
+                           when Node then Fragment.new([content])
+                           end
+
+        check_content(content_fragment)
+        attrs = compute_attrs(attrs)
+        Node.new(type: self, attrs: attrs, content: content_fragment,
+                 marks: marks)
+      end
+
+      # Create and fill a node with default content
+      def create_and_fill(attrs = nil, content = nil, marks = [])
+        attrs = compute_attrs(attrs)
+        content_fragment = Fragment.from(content)
+
+        if content_fragment.size.positive?
+          before = @content_match.fill_before(after: content_fragment,
+                                              to_end: false)
+          return nil unless before
+
+          content_fragment = before.append(content_fragment)
+        end
+
+        matched = @content_match.match_fragment(content_fragment)
+        return nil unless matched
+
+        after = matched.fill_before(after: Fragment.empty, to_end: true)
+        return nil unless after
+
+        full_content = content_fragment.append(after)
+        Node.new(type: self, attrs: attrs, content: full_content, marks: marks)
+      end
+
+      def valid_content?(fragment)
+        result = @content_match.match_fragment(fragment)
+        return false unless result&.valid_end
+
+        fragment.content.each do |child|
+          return false unless allows_marks?(child.marks)
+        end
+        true
+      end
+
+      def check_content(fragment)
+        return if valid_content?(fragment)
+
+        raise Prosereflect::SchemaErrors::ValidationError,
+              "Invalid content for node #{@name}: #{fragment.to_s[0, 50]}"
+      end
+
+      def check_attrs(attrs)
+        attrs ||= {}
+        attrs.each_key do |attr_name|
+          unless @attrs.key?(attr_name)
+            raise Prosereflect::SchemaErrors::ValidationError,
+                  "Unsupported attribute #{attr_name} for node #{@name}"
+          end
+        end
+
+        @attrs.each do |name, attr_def|
+          attr_def.validate_value(attrs[name]) if attrs.key?(name)
+        end
+      end
+
+      def allows_mark_type?(mark_type)
+        @mark_set.nil? || @mark_set.include?(mark_type)
+      end
+
+      def allows_marks?(marks)
+        return true if @mark_set.nil?
+
+        marks.all? { |mark| allows_mark_type?(mark.type) }
+      end
+
+      def allowed_marks(marks)
+        return marks if @mark_set.nil?
+
+        result = marks.dup
+        filtered = false
+
+        marks.each_with_index do |mark, i|
+          unless allows_mark_type?(mark.type)
+            result = marks[0...i].dup
+            filtered = true
+            break
+          end
+        end
+
+        filtered ? result : marks
+      end
+
+      def compatible_content?(other)
+        self == other || @content_match.compatible?(other.content_match)
+      end
+
+      def to_s
+        "<NodeType #{@name}>"
+      end
+    end
+  end
+end

data/lib/prosereflect/schema/schema_main.rb

@@ -0,0 +1,190 @@
+# frozen_string_literal: true
+
+# Schema implementation - reopen Prosereflect::Schema class to add instance methods
+module Prosereflect
+  class Schema
+    # Alias ValidationError for backwards compatibility
+    ValidationError = Prosereflect::SchemaErrors::ValidationError
+
+    attr_reader :spec, :nodes, :marks
+
+    def initialize(nodes_spec:, marks_spec: {}, top_node: nil)
+      @spec = SchemaSpec.from_hashes(nodes_spec: nodes_spec,
+                                     marks_spec: marks_spec, top_node: top_node)
+      @nodes = {} # name -> NodeType
+      @marks = {} # name -> MarkType
+
+      # Build NodeTypes
+      @spec.nodes.each do |name, node_spec|
+        @nodes[name] = NodeType.from_spec(name, self, node_spec)
+      end
+
+      # Build MarkTypes
+      rank = 0
+      @spec.marks.each do |name, mark_spec|
+        @marks[name] = MarkType.from_spec(name, rank, self, mark_spec)
+        rank += 1
+      end
+
+      # Validate schema
+      validate_schema
+
+      # Build content expressions
+      build_content_matches
+
+      # Build mark sets
+      build_mark_sets
+
+      # Build mark exclusions
+      build_mark_exclusions
+
+      @top_node_type = @nodes[@spec.top_node]
+    end
+
+    def top_node_type
+      @top_node_type
+    end
+
+    def node_type(name)
+      @nodes[name] || raise(::Prosereflect::SchemaErrors::ValidationError,
+                            "Unknown node type: #{name}")
+    end
+
+    def mark_type(name)
+      @marks[name] || raise(::Prosereflect::SchemaErrors::ValidationError,
+                            "Unknown mark type: #{name}")
+    end
+
+    # Create a node
+    def node(type, attrs = nil, content = nil, marks = nil)
+      type_obj = type.is_a?(String) ? node_type(type) : type
+      unless type_obj.is_a?(NodeType)
+        raise ::Prosereflect::SchemaErrors::Error,
+              "Invalid node type: #{type}"
+      end
+      if type_obj.schema != self
+        raise ::Prosereflect::SchemaErrors::Error,
+              "Node type from different schema used (#{type_obj.name})"
+      end
+
+      type_obj.create_checked(attrs, content, marks)
+    end
+
+    # Create a text node
+    def text(text, marks = nil)
+      type = node_type("text")
+      TextNode.new(type: type, attrs: {}, text: text, marks: marks || [])
+    end
+
+    # Create a mark
+    def mark(type, attrs = nil)
+      type_obj = type.is_a?(String) ? mark_type(type) : type
+      type_obj.create(attrs)
+    end
+
+    # Deserialize node from JSON
+    def node_from_json(json_data)
+      Node.from_json(self, json_data)
+    end
+
+    # Deserialize mark from JSON
+    def mark_from_json(json_data)
+      type = mark_type(json_data["type"])
+      attrs = json_data["attrs"] || {}
+      type.create(attrs)
+    end
+
+    private
+
+    def validate_schema
+      unless @nodes.key?(@spec.top_node)
+        raise ::Prosereflect::SchemaErrors::ValidationError,
+              "Schema is missing its top node type #{@spec.top_node}"
+      end
+
+      unless @nodes.key?("text")
+        raise ::Prosereflect::SchemaErrors::ValidationError,
+              "every schema needs a 'text' type"
+      end
+
+      if @nodes["text"].attrs && !@nodes["text"].attrs.empty?
+        raise ::Prosereflect::SchemaErrors::ValidationError,
+              "the text node type should not have attributes"
+      end
+
+      @nodes.each_key do |name|
+        if @marks.key?(name)
+          raise ::Prosereflect::SchemaErrors::ValidationError,
+                "#{name} can not be both a node and a mark"
+        end
+      end
+    end
+
+    def build_content_matches
+      @nodes.each_value do |node_type|
+        content_expr = node_type.content_expression
+        next unless content_expr
+
+        node_type.instance_variable_set(
+          :@content_match,
+          ContentMatch.parse(content_expr, @nodes),
+        )
+      end
+    end
+
+    def build_mark_sets
+      @nodes.each_value do |node_type|
+        mark_expr = if node_type.spec.respond_to?(:[])
+                      node_type.spec[:marks] || node_type.spec["marks"]
+                    elsif node_type.spec.respond_to?(:marks)
+                      node_type.spec.marks
+                    end
+
+        node_type.mark_set = if mark_expr == "_"
+          nil # All marks allowed
+        elsif mark_expr.is_a?(String) && !mark_expr.empty?
+          gather_marks(mark_expr.split)
+        elsif mark_expr == "" || !node_type.content_match.inline_content?
+          []
+        end
+      end
+    end
+
+    def gather_marks(names)
+      result = []
+      names.each do |name|
+        if @marks.key?(name)
+          result << @marks[name]
+        else
+          # Check groups
+          @marks.each_value do |mark|
+            group_str = mark.spec.respond_to?(:group) ? mark.spec.group : nil
+
+            if group_str && group_str.to_s.split.include?(name)
+              result << mark
+            end
+          end
+        end
+      end
+      result
+    end
+
+    def build_mark_exclusions
+      @marks.each_value do |mark|
+        excl = if mark.spec.respond_to?(:[])
+                 mark.spec[:excludes] || mark.spec["excludes"]
+               elsif mark.spec.respond_to?(:excludes)
+                 mark.spec.excludes
+               end
+
+        mark.excluded = if excl.nil?
+                          [mark]
+                        elsif excl == ""
+                          []
+                        else
+                          gather_marks(excl.split)
+                        end
+      end
+    end
+  end
+end

data/lib/prosereflect/schema/spec.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+module Prosereflect
+  class Schema
+    # Represents a node specification from a schema
+    class NodeSpec
+      attr_reader :name, :attrs, :content, :groups, :inline, :atom, :marks
+
+      def initialize(name:, attrs: {}, content: nil, groups: [], inline: false,
+atom: false, marks: nil)
+        @name = name
+        @attrs = attrs
+        @content = content
+        @groups = groups
+        @inline = inline
+        @atom = atom
+        @marks = marks
+      end
+
+      def self.from_hash(name, spec)
+        new(
+          name: name,
+          attrs: spec[:attrs] || spec["attrs"] || {},
+          content: spec[:content] || spec["content"],
+          groups: parse_groups(spec),
+          inline: spec[:inline] || spec["inline"] || false,
+          atom: spec[:atom] || spec["atom"] || false,
+          marks: spec[:marks] || spec["marks"],
+        )
+      end
+
+      def self.parse_groups(spec)
+        group_str = spec[:group] || spec["group"]
+        return [] unless group_str
+
+        group_str.is_a?(Array) ? group_str : group_str.to_s.split
+      end
+    end
+
+    # Represents a mark specification from a schema
+    class MarkSpec
+      attr_reader :name, :attrs, :excludes, :inclusive, :group
+
+      def initialize(name:, attrs: {}, excludes: nil, inclusive: true,
+group: nil)
+        @name = name
+        @attrs = attrs
+        @excludes = excludes
+        @inclusive = inclusive
+        @group = group
+      end
+
+      def self.from_hash(name, spec)
+        new(
+          name: name,
+          attrs: spec[:attrs] || spec["attrs"] || {},
+          excludes: spec[:excludes] || spec["excludes"],
+          inclusive: if spec.key?(:inclusive)
+                       spec[:inclusive]
+                     elsif spec.key?("inclusive")
+                       spec["inclusive"]
+                     else
+                       true
+                     end,
+          group: spec[:group] || spec["group"],
+        )
+      end
+    end
+
+    # Represents a complete schema specification
+    class SchemaSpec
+      attr_reader :nodes, :marks, :top_node
+
+      def initialize(nodes: {}, marks: {}, top_node: nil)
+        @nodes = nodes
+        @marks = marks
+        @top_node = top_node || "doc"
+      end
+
+      def self.from_hashes(nodes_spec:, marks_spec: {}, top_node: nil)
+        nodes = nodes_spec.each_with_object({}) do |(name, spec), hash|
+          hash[name] = NodeSpec.from_hash(name, spec)
+        end
+        marks = marks_spec.each_with_object({}) do |(name, spec), hash|
+          hash[name] = MarkSpec.from_hash(name, spec)
+        end
+
+        new(nodes: nodes, marks: marks, top_node: top_node)
+      end
+    end
+  end
+end

data/lib/prosereflect/schema.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Prosereflect
+  module SchemaErrors
+    class Error < StandardError; end
+    class AttributeParseError < Error; end
+    class ContentMatchError < Error; end
+    class ValidationError < Error; end
+  end
+end
+
+# Define Schema as a proper class (not module) that will be extended by schema_main.rb
+# The nested classes (NodeType, MarkType, etc.) are defined in their own files
+# and accessed as Prosereflect::Schema::NodeType etc.
+module Prosereflect
+  class Schema
+    class << self
+      attr_accessor :node_types, :mark_types
+    end
+    self.node_types = []
+    self.mark_types = []
+
+    # Alias ContentMatchError for backwards compatibility
+    ContentMatchError = Prosereflect::SchemaErrors::ContentMatchError
+
+    # Alias Error for backwards compatibility
+    Error = Prosereflect::SchemaErrors::Error
+  end
+end
+
+require_relative "schema/attribute"
+require_relative "schema/spec"
+require_relative "schema/fragment"
+require_relative "schema/mark"
+require_relative "schema/node"
+require_relative "schema/content_match"
+require_relative "schema/mark_type"
+require_relative "schema/node_type"
+require_relative "schema/schema_main"

data/lib/prosereflect/text.rb

@@ -23,6 +23,30 @@ module Prosereflect
       text || ""
     end
 
+    # Text node size is text length + 1 (for the opening token)
+    def node_size
+      (text || "").length + 1
+    end
+
+    # Text nodes are text nodes
+    def text?
+      true
+    end
+
+    # Return a copy of this text node with content restricted to range
+    def cut(from = 0, to = nil)
+      txt = text || ""
+      to ||= txt.length
+      self.class.new(text: txt[from...to], marks: raw_marks)
+    end
+
+    # Check equality with another text node
+    def eq?(other)
+      return false unless other.is_a?(self.class)
+
+      text == other.text && to_h == other.to_h
+    end
+
     # Override the to_h method to include the text attribute
     def to_h
       result = super