prosereflect 0.1.1 → 0.3.0

data/lib/prosereflect/user.rb

@@ -1,20 +1,20 @@
 # frozen_string_literal: true
 
-require_relative 'node'
-
 module Prosereflect
   # User class represents a user mention in ProseMirror.
   class User < Node
-    PM_TYPE = 'user'
+    PM_TYPE = "user"
 
-    attribute :type, :string, default: -> { send('const_get', 'PM_TYPE') }
+    attribute :type, :string, default: -> {
+      self.class.send(:const_get, "PM_TYPE")
+    }
     attribute :id, :string
     attribute :attrs, :hash
 
     key_value do
-      map 'type', to: :type, render_default: true
-      map 'attrs', to: :attrs
-      map 'content', to: :content
+      map "type", to: :type, render_default: true
+      map "attrs", to: :attrs
+      map "content", to: :content
     end
 
     def initialize(attributes = {})
@@ -23,8 +23,8 @@ module Prosereflect
 
       return unless attributes[:attrs]
 
-      @id = attributes[:attrs]['id']
-      self.attrs = { 'id' => @id }
+      @id = attributes[:attrs]["id"]
+      self.attrs = { "id" => @id }
     end
 
     def self.create(attrs = nil)
@@ -35,16 +35,16 @@ module Prosereflect
     def id=(user_id)
       @id = user_id
       self.attrs ||= {}
-      attrs['id'] = user_id
+      attrs["id"] = user_id
     end
 
     def id
-      @id || attrs&.[]('id')
+      @id || attrs&.[]("id")
     end
 
     # Override content-related methods since user mentions don't have content
     def add_child(*)
-      raise NotImplementedError, 'User mention nodes cannot have children'
+      raise NotImplementedError, "User mention nodes cannot have children"
     end
 
     def content
@@ -53,10 +53,10 @@ module Prosereflect
 
     def to_h
       hash = super
-      hash['attrs'] = {
-        'id' => id
+      hash["attrs"] = {
+        "id" => id,
       }
-      hash['content'] = []
+      hash["content"] = []
       hash
     end
   end

data/lib/prosereflect/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Prosereflect
-  VERSION = '0.1.1'
+  VERSION = "0.3.0"
 end

data/lib/prosereflect.rb

@@ -1,23 +1,36 @@
 # frozen_string_literal: true
 
-require_relative 'prosereflect/version'
-require_relative 'prosereflect/node'
-require_relative 'prosereflect/mark'
-require_relative 'prosereflect/attribute'
-require_relative 'prosereflect/text'
-require_relative 'prosereflect/paragraph'
-require_relative 'prosereflect/hard_break'
-require_relative 'prosereflect/table'
-require_relative 'prosereflect/table_row'
-require_relative 'prosereflect/table_cell'
-require_relative 'prosereflect/heading'
-require_relative 'prosereflect/document'
-require_relative 'prosereflect/parser'
-require_relative 'prosereflect/input/html'
-require_relative 'prosereflect/output/html'
-require_relative 'prosereflect/user'
+require "lutaml/model"
 
 module Prosereflect
   class Error < StandardError; end
-  # Your code goes here...
+
+  autoload :Attribute, "prosereflect/attribute"
+  autoload :Blockquote, "prosereflect/blockquote"
+  autoload :BulletList, "prosereflect/bullet_list"
+  autoload :CodeBlock, "prosereflect/code_block"
+  autoload :CodeBlockWrapper, "prosereflect/code_block_wrapper"
+  autoload :Document, "prosereflect/document"
+  autoload :Fragment, "prosereflect/fragment"
+  autoload :HardBreak, "prosereflect/hard_break"
+  autoload :Heading, "prosereflect/heading"
+  autoload :HorizontalRule, "prosereflect/horizontal_rule"
+  autoload :Image, "prosereflect/image"
+  autoload :Input, "prosereflect/input"
+  autoload :ListItem, "prosereflect/list_item"
+  autoload :Mark, "prosereflect/mark"
+  autoload :Node, "prosereflect/node"
+  autoload :OrderedList, "prosereflect/ordered_list"
+  autoload :Output, "prosereflect/output"
+  autoload :Paragraph, "prosereflect/paragraph"
+  autoload :Parser, "prosereflect/parser"
+  autoload :ResolvedPos, "prosereflect/resolved_pos"
+  autoload :Table, "prosereflect/table"
+  autoload :TableCell, "prosereflect/table_cell"
+  autoload :TableHeader, "prosereflect/table_header"
+  autoload :TableRow, "prosereflect/table_row"
+  autoload :Text, "prosereflect/text"
+  autoload :Transform, "prosereflect/transform"
+  autoload :User, "prosereflect/user"
+  autoload :VERSION, "prosereflect/version"
 end

data/prosereflect.gemspec

@@ -1,34 +1,35 @@
 # frozen_string_literal: true
 
-require_relative 'lib/prosereflect/version'
+require_relative "lib/prosereflect/version"
 
 all_files_in_git = Dir.chdir(File.expand_path(__dir__)) do
   `git ls-files -z`.split("\x0")
 end
 
 Gem::Specification.new do |spec|
-  spec.name = 'prosereflect'
+  spec.name = "prosereflect"
   spec.version = Prosereflect::VERSION
-  spec.authors = ['Ribose']
-  spec.email = ['open.source@ribose.com']
+  spec.authors = ["Ribose"]
+  spec.email = ["open.source@ribose.com"]
 
-  spec.summary = 'Ruby model accessor for prosereflect document trees.'
-  spec.homepage = 'https://github.com/metanorma/prosereflect'
-  spec.license = 'BSD-2-Clause'
-  spec.required_ruby_version = Gem::Requirement.new('>= 2.6.0')
+  spec.summary = "Ruby model accessor for prosereflect document trees."
+  spec.homepage = "https://github.com/metanorma/prosereflect"
+  spec.license = "BSD-2-Clause"
+  spec.required_ruby_version = Gem::Requirement.new(">= 2.6.0")
 
-  spec.metadata['homepage_uri'] = spec.homepage
-  spec.metadata['source_code_uri'] = spec.homepage
-  spec.metadata['bug_tracker_uri'] = "#{spec.homepage}/issues"
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = spec.homepage
+  spec.metadata["bug_tracker_uri"] = "#{spec.homepage}/issues"
+  spec.metadata["rubygems_mfa_required"] = "true"
 
   # Specify which files should be added to the gem when it is released.
   spec.files = all_files_in_git
-               .reject { |f| f.match(%r{\A(?:test|features|bin|\.)/}) }
+    .reject { |f| f.match(%r{\A(?:test|features|bin|\.)/}) }
 
-  spec.bindir = 'exe'
+  spec.bindir = "exe"
   spec.executables = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
-  spec.require_paths = ['lib']
+  spec.require_paths = ["lib"]
 
-  spec.add_dependency 'lutaml-model', '~> 0.7'
-  spec.add_dependency 'nokogiri', '~> 1.18'
+  spec.add_dependency "lutaml-model", "~> 0.8"
+  spec.add_dependency "nokogiri", "~> 1.18"
 end

data/spec/fixtures/documents/formatted_text.yaml

@@ -0,0 +1,14 @@
+type: doc
+content:
+  - type: paragraph
+    content:
+      - type: text
+        text: Hello
+        marks:
+          - type: bold
+      - type: text
+        text: " World"
+      - type: text
+        text: "!"
+        marks:
+          - type: italic

data/spec/fixtures/documents/heading_paragraph.yaml

@@ -0,0 +1,16 @@
+type: doc
+content:
+  - type: heading
+    attrs:
+      level: 1
+    content:
+      - type: text
+        text: Title
+  - type: paragraph
+    content:
+      - type: text
+        text: First paragraph
+  - type: paragraph
+    content:
+      - type: text
+        text: Second paragraph

data/spec/fixtures/documents/lists_doc.yaml

@@ -0,0 +1,32 @@
+type: doc
+content:
+  - type: bullet_list
+    content:
+      - type: list_item
+        content:
+          - type: paragraph
+            content:
+              - type: text
+                text: Bullet 1
+      - type: list_item
+        content:
+          - type: paragraph
+            content:
+              - type: text
+                text: Bullet 2
+  - type: ordered_list
+    attrs:
+      order: 1
+    content:
+      - type: list_item
+        content:
+          - type: paragraph
+            content:
+              - type: text
+                text: Item 1
+      - type: list_item
+        content:
+          - type: paragraph
+            content:
+              - type: text
+                text: Item 2

data/spec/fixtures/documents/mixed_content.yaml

@@ -0,0 +1,40 @@
+type: doc
+content:
+  - type: heading
+    attrs:
+      level: 2
+    content:
+      - type: text
+        text: Mixed Content
+  - type: paragraph
+    content:
+      - type: text
+        text: Normal text
+      - type: text
+        text: " bold"
+        marks:
+          - type: bold
+      - type: text
+        text: " and "
+      - type: text
+        text: italic
+        marks:
+          - type: italic
+      - type: text
+        text: " with a "
+      - type: text
+        text: link
+        marks:
+          - type: link
+            attrs:
+              href: https://example.com
+  - type: code_block
+    attrs:
+      language: ruby
+    content:
+      - type: text
+        text: puts 'hello'
+  - type: image
+    attrs:
+      src: https://example.com/image.png
+      alt: Example image

data/spec/fixtures/documents/nested_doc.yaml

@@ -0,0 +1,20 @@
+type: doc
+content:
+  - type: blockquote
+    content:
+      - type: paragraph
+        content:
+          - type: text
+            text: Quoted text
+      - type: paragraph
+        content:
+          - type: text
+            text: More quoted text
+  - type: horizontal_rule
+  - type: paragraph
+    content:
+      - type: text
+        text: "Line 1"
+      - type: hard_break
+      - type: text
+        text: "Line 2"

data/spec/fixtures/documents/simple_doc.yaml

@@ -0,0 +1,6 @@
+type: doc
+content:
+  - type: paragraph
+    content:
+      - type: text
+        text: Hello World

data/spec/fixtures/documents/table_doc.yaml

@@ -0,0 +1,32 @@
+type: doc
+content:
+  - type: table
+    content:
+      - type: table_row
+        content:
+          - type: table_header
+            content:
+              - type: paragraph
+                content:
+                  - type: text
+                    text: Header 1
+          - type: table_header
+            content:
+              - type: paragraph
+                content:
+                  - type: text
+                    text: Header 2
+      - type: table_row
+        content:
+          - type: table_cell
+            content:
+              - type: paragraph
+                content:
+                  - type: text
+                    text: Cell 1
+          - type: table_cell
+            content:
+              - type: paragraph
+                content:
+                  - type: text
+                    text: Cell 2

data/spec/fixtures/documents/transform_test.yaml

@@ -0,0 +1,14 @@
+type: doc
+content:
+  - type: paragraph
+    content:
+      - type: text
+        text: abcdef
+  - type: paragraph
+    content:
+      - type: text
+        text: ghijkl
+  - type: paragraph
+    content:
+      - type: text
+        text: mnopqr

data/spec/fixtures/schema/custom_schema.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require "prosereflect"
+require "prosereflect/schema"
+
+# Custom schema with mark exclusion rules
+# Used for testing that link excludes emoji
+module CustomSchemaFixture
+  CUSTOM_SCHEMA_NODES = {
+    "doc" => { "content" => "block+" },
+    "paragraph" => { "content" => "inline*" },
+    "text" => {},
+  }.freeze
+
+  CUSTOM_SCHEMA_MARKS = {
+    "link" => { "excludes" => "emoji" },
+    "bold" => {},
+    "italic" => {},
+    "emoji" => {},
+  }.freeze
+
+  def self.build
+    Prosereflect::Schema.new(
+      nodes_spec: CUSTOM_SCHEMA_NODES,
+      marks_spec: CUSTOM_SCHEMA_MARKS,
+      top_node: "doc",
+    )
+  end
+
+  def self.nodes
+    CUSTOM_SCHEMA_NODES
+  end
+
+  def self.marks
+    CUSTOM_SCHEMA_MARKS
+  end
+end

data/spec/fixtures/schema/test_schema.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require "prosereflect"
+require "prosereflect/schema"
+
+# Test schema matching prosemirror-py test_schema
+# Used for testing content expressions, mark handling, etc.
+module TestSchemaFixture
+  TEST_SCHEMA_NODES = {
+    "doc" => { "content" => "block+" },
+    "paragraph" => { "content" => "inline*" },
+    "code_block" => { "content" => "text*", "marks" => "" },
+    "heading" => { "content" => "inline*", "attrs" => { "level" => { "default" => 1 } } },
+    "blockquote" => { "content" => "block+", "defining" => true },
+    "horizontal_rule" => {},
+    "text" => {},
+    "image" => { "attrs" => { "src" => {}, "alt" => { "default" => "" }, "title" => { "default" => "" } } },
+    "hard_break" => { "selectable" => false },
+    "ordered_list" => { "content" => "list_item+", "attrs" => { "order" => { "default" => 1 } }, "group" => "block" },
+    "bullet_list" => { "content" => "list_item+", "group" => "block" },
+    "list_item" => { "content" => "paragraph block*", "defining" => true },
+  }.freeze
+
+  TEST_SCHEMA_MARKS = {
+    "link" => { "attrs" => { "href" => {}, "title" => { "default" => "" } }, "inclusive" => false },
+    "em" => {},
+    "strong" => {},
+    "code" => {},
+  }.freeze
+
+  def self.build
+    Prosereflect::Schema.new(
+      nodes_spec: TEST_SCHEMA_NODES,
+      marks_spec: TEST_SCHEMA_MARKS,
+      top_node: "doc",
+    )
+  end
+
+  def self.nodes
+    TEST_SCHEMA_NODES
+  end
+
+  def self.marks
+    TEST_SCHEMA_MARKS
+  end
+end

data/spec/fixtures/test_builder/helpers.rb

@@ -0,0 +1,212 @@
+# frozen_string_literal: true
+
+# TestBuilder - Port of prosemirror-py test_builder/build.py
+# Provides helpers for creating test nodes from string representations
+
+module TestBuilder
+  # Parse a test string into a document
+  # Examples:
+  #   TestBuilder.parse("doc(p(\"hello world\"))")
+  #   TestBuilder.parse("doc(p(\"hello<|a> world\"))")
+  def self.parse(str)
+    builder = Builder.new
+    builder.parse(str)
+  end
+
+  # Create a builder for a specific schema
+  def self.for_schema(schema)
+    Builder.new(schema: schema)
+  end
+
+  class Builder
+    attr_reader :schema
+
+    def initialize(schema: nil)
+      @schema = schema
+    end
+
+    def parse(str)
+      # Parse the string into a node tree
+      # This is a simplified parser for test strings like:
+      # doc(p("hello", em("world")))
+      # doc(p("hello<|a> world"))
+      content = extract_content(str)
+      return nil if content.nil?
+
+      parse_content(content)
+    end
+
+    def parse_content(str)
+      # Simple recursive descent parser for test strings
+      # Handles: doc(...), p(...), em(...), strong(...), etc.
+      # And string literals: "hello world"
+      tokens = tokenize(str)
+      parse_tokens(tokens)
+    end
+
+    private
+
+    def tokenize(str)
+      # Simple tokenizer
+      tokens = []
+      i = 0
+      while i < str.length
+        case str[i]
+        when /\s/
+          i += 1
+        when /[a-z_]/
+          # Identifier
+          start = i
+          i += 1
+          while i < str.length && str[i] =~ /[a-z0-9_]/
+            i += 1
+          end
+          tokens << [:identifier, str[start...i]]
+        when '"'
+          # String literal
+          i += 1
+          start = i
+          while i < str.length && str[i] != '"'
+            i += 1
+          end
+          tokens << [:string, str[start...i]]
+          i += 1 if i < str.length
+        when "(", ")", "<", ">", "|", ","
+          tokens << [str[i], str[i]]
+          i += 1
+        else
+          i += 1
+        end
+      end
+      tokens
+    end
+
+    def parse_tokens(tokens)
+      return nil if tokens.empty?
+
+      token = tokens.first
+      return nil unless token
+
+      if token[0] == :identifier
+        name = token[1]
+        tokens.shift
+        consume("(", tokens)
+        if name == "doc"
+          children = parse_children(tokens)
+          consume(")", tokens)
+          build_doc(children)
+        elsif name == "text"
+          str_token = tokens.shift
+          consume(")", tokens)
+          build_text(str_token ? str_token[1] : "")
+        else
+          # Assume it's a paragraph or other node
+          children = parse_children(tokens)
+          consume(")", tokens)
+          build_node(name, children)
+        end
+      elsif token[0] == :string
+        tokens.shift
+        build_text(token[1])
+      end
+    end
+
+    def parse_children(tokens)
+      children = []
+      while tokens.any? && tokens.first[0] != ")"
+        child = parse_tokens(tokens)
+        children << child if child
+        break if tokens.empty?
+
+        if tokens.first[0] == ","
+          tokens.shift
+        end
+      end
+      children
+    end
+
+    def consume(expected, tokens)
+      return if tokens.empty?
+
+      token = tokens.first
+      return unless token && token[0] == expected
+
+      tokens.shift
+    end
+
+    def build_doc(children)
+      nodes = children.flat_map do |child|
+        if child.is_a?(Array)
+          child
+        else
+          [child].compact
+        end
+      end
+      Prosereflect::Document.new(content: nodes)
+    end
+
+    def build_node(type, children)
+      case type
+      when "p"
+        content = children.flat_map do |child|
+          if child.is_a?(Prosereflect::Node)
+            [child]
+          else
+            []
+          end
+        end
+        Prosereflect::Paragraph.new(content: content)
+      when "text"
+        children.first || ""
+      else
+        # Generic node - return children as content
+        children.flatten.compact.first
+      end
+    end
+
+    def build_text(str)
+      return str if str.is_a?(String)
+
+      Prosereflect::Text.new(text: str.to_s)
+    end
+
+    def extract_content(str)
+      # Extract content between outermost parentheses
+      paren_depth = 0
+      start = nil
+      str.each_char.with_index do |char, i|
+        if char == "(" && paren_depth == 0
+          start = i + 1
+          paren_depth += 1
+        elsif char == "("
+          paren_depth += 1
+        elsif char == ")"
+          paren_depth -= 1
+          if paren_depth == 0 && start
+            return str[start...i]
+          end
+        end
+      end
+      nil
+    end
+  end
+
+  # Extract position markers from a test string
+  # Returns [content_string, positions_hash]
+  # Example: "doc(p(\"hello<|a> world<|b>\"))" => ["doc(p(\"hello world\"))", {"a" => 6, "b" => 12}]
+  def self.extract_markers(str)
+    positions = {}
+    marker_regex = /<\|([a-z0-9]+)>|<([0-9]+)>|<\|>/
+    result = str.gsub(marker_regex) do |_match|
+      if $1
+        positions[$1] = $~.offset(0)[0]
+      elsif $2
+        positions[$2.to_i] = $~.offset(0)[0]
+      else
+        positions[:cursor] = $~.offset(0)[0]
+      end
+      ""
+    end
+    [result, positions]
+  end
+end