coradoc 2.0.1 → 2.0.3

data/lib/coradoc/query.rb

@@ -3,44 +3,12 @@
 module Coradoc
   # Document querying and introspection API.
   #
-  # This module provides CSS-like selectors for navigating and querying
-  # document trees. It enables powerful document manipulation patterns.
-  #
-  # @example Querying documents
-  #   doc = Coradoc.parse(adoc_text, format: :asciidoc)
-  #
-  #   # Find all sections
-  #   sections = doc.query('section')
-  #
-  #   # Find level-2 sections
-  #   doc.query('section.level-2').each do |section|
-  #     puts section.title
-  #   end
-  #
-  #   # Find paragraphs with specific role
-  #   examples = doc.query('[role=example]')
-  #
-  #   # Complex selectors
-  #   doc.query('section > paragraph:first-child')
-  #
+  # Provides CSS-like selectors for navigating and querying document trees.
   module Query
     # Selector parsing and matching
-    #
-    # Supports CSS-like selectors for document querying:
-    # - Element type: `section`, `paragraph`, `table`
-    # - Class/level: `.level-2`, `.important`
-    # - ID: `#intro`, `#section-1`
-    # - Attributes: `[id=intro]`, `[role=example]`, `[level>1]`
-    # - Pseudo-classes: `:first-child`, `:last-child`, `:nth-child(2)`
-    # - Combinators: `>` (child), space (descendant)
-    #
     class Selector
       attr_reader :element_type, :id, :classes, :attributes, :pseudo_classes
 
-      # Parse a selector string
-      #
-      # @param selector [String] CSS-like selector
-      # @return [Selector] Parsed selector object
       def self.parse(selector)
         new.parse(selector)
       end
@@ -53,40 +21,31 @@ module Coradoc
         @pseudo_classes = []
       end
 
-      # Parse a selector string into this object
-      #
-      # @param selector [String] The selector to parse
-      # @return [self]
       def parse(selector)
         @original = selector.to_s.strip
         return self if @original.empty?
 
-        # Parse element type
         @original.sub!(/\A([a-z_][a-z0-9_-]*)/i) do |match|
           @element_type = match.downcase
           ''
         end
 
-        # Parse ID
         @original.sub!(/#([a-z_][a-z0-9_-]*)/i) do
           @id = ::Regexp.last_match(1)
           ''
         end
 
-        # Parse classes
         @original.gsub!(/\.([a-z_][a-z0-9_-]*)/i) do
           @classes << ::Regexp.last_match(1)
           ''
         end
 
-        # Parse attributes
         @original.gsub!(/\[([^\]]+)\]/) do
           attr_expr = ::Regexp.last_match(1)
           parse_attribute(attr_expr)
           ''
         end
 
-        # Parse pseudo-classes
         @original.gsub!(/:([a-z-]+)(?:\(([^)]+)\))?/i) do
           name = ::Regexp.last_match(1).downcase
           arg = ::Regexp.last_match(2)
@@ -97,34 +56,16 @@ module Coradoc
         self
       end
 
-      # Check if an element matches this selector
-      #
-      # @param element [CoreModel::Base] The element to check
-      # @return [Boolean]
       def matches?(element)
         return false unless element
-
-        # Check element type
         return false if @element_type && !type_matches?(element)
-
-        # Check ID
-        return false if @id && element_id(element) != @id
-
-        # Check classes/roles
+        return false if @id && element.id != @id
         return false if @classes.any? && !classes_match?(element)
-
-        # Check attributes
         return false if @attributes.any? && !attributes_match?(element)
 
         true
       end
 
-      # Check pseudo-class conditions
-      #
-      # @param element [CoreModel::Base] The element to check
-      # @param siblings [Array] Sibling elements
-      # @param index [Integer] Element's index among siblings
-      # @return [Boolean]
       def matches_pseudo_classes?(element, siblings:, index:)
         @pseudo_classes.all? do |pseudo|
           case pseudo[:name]
@@ -134,20 +75,17 @@ module Coradoc
             index == siblings.length - 1
           when 'nth-child'
             n = pseudo[:argument].to_i
-            index == n - 1 # 1-indexed in CSS
+            index == n - 1
           when 'only-child'
             siblings.length == 1
           when 'empty'
             empty_element?(element)
           else
-            true # Unknown pseudo-classes pass
+            true
           end
         end
       end
 
-      # Check if selector is universal (*)
-      #
-      # @return [Boolean]
       def universal?
         @element_type == '*' || @original == '*'
       end
@@ -155,7 +93,6 @@ module Coradoc
       private
 
       def parse_attribute(expr)
-        # Handle different attribute operators
         case expr
         when /(\w+)\s*=\s*["']?([^"']+)["']?/
           @attributes[::Regexp.last_match(1).to_sym] = {
@@ -183,7 +120,6 @@ module Coradoc
             value: ::Regexp.last_match(2)
           }
         when /(\w+)/
-          # Attribute presence check
           @attributes[::Regexp.last_match(1).to_sym] = { operator: :present }
         end
       end
@@ -191,14 +127,9 @@ module Coradoc
       def type_matches?(element)
         return true if @element_type == '*'
 
-        # First check the element_type attribute if present (for StructuralElement/Block)
-        if element.respond_to?(:element_type) && element.element_type
-          return element.element_type.to_s.downcase == @element_type.downcase
-        end
+        return element.element_type.to_s.downcase == @element_type.downcase if (element.is_a?(CoreModel::StructuralElement) || element.is_a?(CoreModel::Block)) && element.element_type
 
-        # Then check the class-derived snake_case name (exact match only)
         class_name = class_to_query_name(element.class)
-
         class_name == @element_type
       end
 
@@ -212,22 +143,25 @@ module Coradoc
              .downcase
       end
 
-      def element_id(element)
-        element.respond_to?(:id) ? element.id : nil
-      end
-
       def classes_match?(element)
-        element_classes = if element.respond_to?(:role) && element.role
-                            element.role.split.map(&:downcase)
-                          elsif element.respond_to?(:classes)
-                            Array(element.classes).map(&:downcase)
-                          else
+        element_classes = if element.is_a?(CoreModel::StructuralElement) && element.element_type
+                            [element.element_type]
+                          elsif element.is_a?(CoreModel::Base)
                             []
+                          else
+                            extract_role(element)
                           end
 
         @classes.all? { |c| element_classes.include?(c.downcase) }
       end
 
+      def extract_role(element)
+        role = element.public_send(:role)
+        role ? role.to_s.split.map(&:downcase) : []
+      rescue NoMethodError
+        []
+      end
+
       def attributes_match?(element)
         @attributes.all? do |attr_name, condition|
           value = get_attribute_value(element, attr_name)
@@ -237,17 +171,23 @@ module Coradoc
 
       def get_attribute_value(element, attr_name)
         case attr_name
-        when :id
-          element.respond_to?(:id) ? element.id : nil
+        when :id, :title
+          element.public_send(attr_name)
         when :level
-          element.respond_to?(:level) ? element.level : nil
-        when :role
-          element.respond_to?(:role) ? element.role : nil
+          if element.is_a?(CoreModel::StructuralElement)
+            element.level
+          else
+            element.public_send(:level)
+          end
+        when :element_type
+          element.element_type if element.is_a?(CoreModel::StructuralElement) || element.is_a?(CoreModel::Block)
         when :type
-          element.respond_to?(:type) ? element.type : nil
+          element.type if element.is_a?(CoreModel::AnnotationBlock) || element.is_a?(CoreModel::InlineElement)
         else
-          element.respond_to?(attr_name) ? element.send(attr_name) : nil
+          element.public_send(attr_name) if element.is_a?(CoreModel::Base) && element.class.attributes.key?(attr_name)
         end
+      rescue NoMethodError
+        nil
       end
 
       def match_attribute_condition(value, condition)
@@ -270,7 +210,7 @@ module Coradoc
       end
 
       def empty_element?(element)
-        return true unless element.respond_to?(:content)
+        return true unless element.is_a?(CoreModel::Block) || element.is_a?(CoreModel::StructuralElement)
 
         content = element.content
         case content
@@ -285,82 +225,46 @@ module Coradoc
     end
 
     # Query result set - collection of matched elements
-    #
-    # Provides array-like access with additional query methods for
-    # chaining and further filtering.
-    #
     class ResultSet
       include Enumerable
 
-      # @return [Array<CoreModel::Base>] Matched elements
       attr_reader :elements
 
-      # Create a new result set
-      #
-      # @param elements [Array<CoreModel::Base>] Matched elements
       def initialize(elements = [])
         @elements = Array(elements).compact
       end
 
-      # Iterate over elements
-      #
-      # @yield [CoreModel::Base] Each matched element
-      # @return [Enumerator]
       def each(&block)
         @elements.each(&block)
       end
 
-      # Get element at index
-      #
-      # @param index [Integer] Element index
-      # @return [CoreModel::Base, nil]
       def [](index)
         @elements[index]
       end
 
-      # Number of matched elements
-      #
-      # @return [Integer]
       def length
         @elements.length
       end
       alias size length
 
-      # Check if result set is empty
-      #
-      # @return [Boolean]
       def empty?
         @elements.empty?
       end
 
-      # Get first element
-      #
-      # @return [CoreModel::Base, nil]
       def first
         @elements.first
       end
 
-      # Get last element
-      #
-      # @return [CoreModel::Base, nil]
       def last
         @elements.last
       end
 
-      # Filter results with an additional selector
-      #
-      # @param selector [String] CSS-like selector
-      # @return [ResultSet] Filtered results
       def filter(selector)
         parsed = Selector.parse(selector)
         filtered = @elements.select { |e| parsed.matches?(e) }
         ResultSet.new(filtered)
       end
 
-      # Query within each element in the result set
-      #
-      # @param selector [String] CSS-like selector
-      # @return [ResultSet] Combined results
       def query(selector)
         results = @elements.flat_map do |element|
           Query.query_within(element, selector).to_a
@@ -368,72 +272,40 @@ module Coradoc
         ResultSet.new(results.uniq)
       end
 
-      # Map over elements and return new result set
-      #
-      # @yield [CoreModel::Base] Block to transform elements
-      # @return [ResultSet]
       def map(&block)
         ResultSet.new(@elements.map(&block))
       end
 
-      # Select elements matching block
-      #
-      # @yield [CoreModel::Base] Test block
-      # @return [ResultSet]
       def select(&block)
         ResultSet.new(@elements.select(&block))
       end
 
-      # Reject elements matching block
-      #
-      # @yield [CoreModel::Base] Test block
-      # @return [ResultSet]
       def reject(&block)
         ResultSet.new(@elements.reject(&block))
       end
 
-      # Convert to array
-      #
-      # @return [Array<CoreModel::Base>]
       def to_a
         @elements.dup
       end
 
-      # Pretty print representation
-      #
-      # @return [String]
       def inspect
         "#<Coradoc::Query::ResultSet count=#{length}>"
       end
     end
 
     # Query engine for executing selectors
-    #
     class Engine
-      # Query a document or element
-      #
-      # @param document [CoreModel::Base] Root document/element
-      # @param selector [String] CSS-like selector
-      # @return [ResultSet] Matched elements
       def self.query(document, selector)
         new.query(document, selector)
       end
 
-      # Query document with selector
-      #
-      # @param document [CoreModel::Base] Root element
-      # @param selector [String] CSS-like selector
-      # @return [ResultSet] Matched elements
       def query(document, selector)
         return ResultSet.new if document.nil? || selector.to_s.strip.empty?
 
-        # Handle comma-separated selectors
         return query_multiple(document, selector.split(',').map(&:strip)) if selector.include?(',')
 
-        # Handle descendant combinator (space) and child combinator (>)
         return query_with_combinators(document, selector) if selector.include?('>') || selector.include?(' ')
 
-        # Simple single selector
         parsed = Selector.parse(selector)
         results = []
 
@@ -462,11 +334,9 @@ module Coradoc
         parts = parse_combinator_selector(selector)
         results = []
 
-        # Find elements matching the first part
         first_results = query(document, parts[:first])
         return ResultSet.new if first_results.empty?
 
-        # For each first match, look for descendants/children
         first_results.each do |parent|
           find_matching_descendants(parent, parts[:rest]).each do |match|
             results << match
@@ -477,7 +347,6 @@ module Coradoc
       end
 
       def parse_combinator_selector(selector)
-        # Simple parsing - handles "parent > child" and "parent child"
         if selector.include?(' > ')
           parts = selector.split(' > ', 2)
           { first: parts[0], rest: [{ combinator: :child, selector: parts[1] }] }
@@ -509,7 +378,6 @@ module Coradoc
             results.concat(find_matching_descendants(child, remaining)) if parsed.matches?(child) && pseudo_matches?(
               parsed, child, siblings, index
             )
-            # Also search deeper
             results.concat(find_matching_descendants(child, parts))
           end
         end
@@ -541,20 +409,10 @@ module Coradoc
 
     # Module-level query methods
     class << self
-      # Query a document with a selector
-      #
-      # @param document [CoreModel::Base] The document to query
-      # @param selector [String] CSS-like selector
-      # @return [ResultSet] Matched elements
       def query(document, selector)
         Engine.query(document, selector)
       end
 
-      # Query within an element (not including the element itself)
-      #
-      # @param element [CoreModel::Base] The parent element
-      # @param selector [String] CSS-like selector
-      # @return [ResultSet] Matched elements
       def query_within(element, selector)
         parsed = Selector.parse(selector)
         results = []
@@ -571,22 +429,16 @@ module Coradoc
         ResultSet.new(results)
       end
 
-      # Get navigable children from an element.
-      # Uses ChildrenContent#children when available, falls back to content.
-      #
-      # @param element [Object] Element to get children from
-      # @return [Array] Navigable child elements
       def get_children(element)
         return [] unless element
 
-        children = if element.respond_to?(:children) && element.children&.any?
-                     element.children
-                   elsif element.respond_to?(:content) && element.content
-                     Array(element.content).select { |c| c.is_a?(CoreModel::Base) }
-                   else
-                     []
-                   end
-        Array(children)
+        if element.is_a?(CoreModel::StructuralElement) && element.children&.any?
+          element.children
+        elsif element.is_a?(CoreModel::Block) && element.content
+          Array(element.content).select { |c| c.is_a?(CoreModel::Base) }
+        else
+          []
+        end
       end
 
       private

data/lib/coradoc/registry.rb

@@ -46,8 +46,6 @@ module Coradoc
     # @param options [Hash] optional per-item configuration
     # @return [void]
     def define(item, **opts)
-      return unless item.respond_to?(:processor_id)
-
       register(item.processor_id, item, opts)
     end
 
@@ -85,9 +83,7 @@ module Coradoc
 
     # Direct access to the items hash (for backward compatibility)
     # @return [Hash<Symbol, Object>]
-    def items
-      @items
-    end
+    attr_reader :items
 
     # Number of registered items
     #
@@ -132,7 +128,9 @@ module Coradoc
     # @return [Object, nil]
     def for_file(filename)
       @items.values.find do |item|
-        item.respond_to?(:processor_match?) && item.processor_match?(filename)
+        item.processor_match?(filename)
+      rescue NoMethodError
+        false
       end
     end
 
@@ -149,7 +147,7 @@ module Coradoc
                for_file(options[:filename])
              end
 
-      label = @error_label || "processor"
+      label = @error_label || 'processor'
       raise ArgumentError, "No #{label} found for: #{options}" unless item
 
       item.processor_execute(content, options)

data/lib/coradoc/serializer/registry.rb

@@ -100,14 +100,12 @@ module Coradoc
           serializer_class = lookup(model)
           return nil unless serializer_class
 
-          serializer = serializer_class.respond_to?(:new) ? serializer_class.new : serializer_class
+          serializer = serializer_class.is_a?(Class) ? serializer_class.new : serializer_class
 
-          if serializer.respond_to?(:serialize)
+          if serializer.is_a?(Base)
             serializer.serialize(model, format: format, **options)
-          elsif serializer.respond_to?(:to_s)
-            serializer.to_s
           else
-            model.to_s
+            serializer.to_s
           end
         end
 

data/lib/coradoc/validation.rb

@@ -177,23 +177,26 @@ module Coradoc
     class Rule
       attr_reader :name, :options
 
-      # Create a validation rule
-      #
-      # @param name [Symbol] Rule name
-      # @param options [Hash] Rule options
       def initialize(name, **options)
         @name = name
         @options = options
       end
 
-      # Validate an element
-      #
-      # @param element [Object] Element to validate
-      # @param context [Hash] Validation context
-      # @return [Array<String>] Error messages
       def validate(element, context = {})
         raise NotImplementedError, 'Subclasses must implement #validate'
       end
+
+      private
+
+      def field_value(element, field)
+        if element.is_a?(CoreModel::Base)
+          element.public_send(field) if element.class.attributes.key?(field)
+        else
+          element.public_send(field)
+        end
+      rescue NoMethodError
+        nil
+      end
     end
 
     # Built-in validation rules
@@ -212,7 +215,13 @@ module Coradoc
         private
 
         def get_value(element, field)
-          element.send(field) if element.respond_to?(field)
+          if element.is_a?(CoreModel::Base)
+            element.public_send(field) if element.class.attributes.key?(field)
+          else
+            element.public_send(field)
+          end
+        rescue NoMethodError
+          nil
         end
       end
 
@@ -221,7 +230,7 @@ module Coradoc
         def validate(element, _context = {})
           field = options[:field]
           expected_type = options[:type]
-          value = element.send(field) if element.respond_to?(field)
+          value = field_value(element, field)
 
           return [] if value.nil? && !options[:required]
           return [] if value.nil?
@@ -236,12 +245,12 @@ module Coradoc
       class Length < Rule
         def validate(element, _context = {})
           field = options[:field]
-          value = element.send(field) if element.respond_to?(field)
+          value = field_value(element, field)
 
           return [] if value.nil?
 
           errors = []
-          length = value.respond_to?(:length) ? value.length : 0
+          length = value.is_a?(String) ? value.length : 0
 
           errors << "#{field} must have at least #{options[:min]} characters/items" if options[:min] && length < options[:min]
 
@@ -255,12 +264,12 @@ module Coradoc
       class Count < Rule
         def validate(element, _context = {})
           field = options[:field]
-          value = element.send(field) if element.respond_to?(field)
+          value = field_value(element, field)
 
           return [] if value.nil?
 
           errors = []
-          count = value.respond_to?(:count) ? value.count : 0
+          count = value.is_a?(Enumerable) ? value.count : 0
 
           errors << "#{field} must have at least #{options[:min]} items" if options[:min] && count < options[:min]
 
@@ -275,7 +284,7 @@ module Coradoc
         def validate(element, _context = {})
           field = options[:field]
           pattern = options[:pattern]
-          value = element.send(field) if element.respond_to?(field)
+          value = field_value(element, field)
 
           return [] if value.nil?
 
@@ -377,7 +386,7 @@ module Coradoc
       private
 
       def validate_field(document, name, config, result)
-        value = document.respond_to?(name) ? document.send(name) : nil
+        value = field_value(document, name)
         path = name.to_s
 
         # Check required
@@ -398,7 +407,7 @@ module Coradoc
         end
 
         # Check min_length
-        if config[:min_length] && value.respond_to?(:length) && (value.length < config[:min_length])
+        if config[:min_length] && value.is_a?(String) && (value.length < config[:min_length])
           result.add_error(
             "#{name} must have at least #{config[:min_length]} characters",
             path: path,
@@ -407,7 +416,7 @@ module Coradoc
         end
 
         # Check max_length
-        if config[:max_length] && value.respond_to?(:length) && (value.length > config[:max_length])
+        if config[:max_length] && value.is_a?(String) && (value.length > config[:max_length])
           result.add_error(
             "#{name} must have at most #{config[:max_length]} characters",
             path: path,
@@ -416,7 +425,7 @@ module Coradoc
         end
 
         # Check min_count
-        if config[:min_count] && value.respond_to?(:count) && (value.count < config[:min_count])
+        if config[:min_count] && value.is_a?(Enumerable) && (value.count < config[:min_count])
           result.add_error(
             "#{name} must have at least #{config[:min_count]} items",
             path: path,
@@ -433,6 +442,16 @@ module Coradoc
           code: :format
         )
       end
+
+      def field_value(document, field)
+        if document.is_a?(CoreModel::Base)
+          document.public_send(field) if document.class.attributes.key?(field)
+        else
+          document.public_send(field)
+        end
+      rescue NoMethodError
+        nil
+      end
     end
 
     # Schema generator from CoreModel types
@@ -479,7 +498,7 @@ module Coradoc
         #   )
         #
         def generate(model_class, required: [], ignored: [], custom_rules: {})
-          return nil unless model_class.respond_to?(:attributes)
+          return nil unless model_class.is_a?(Class) && model_class < CoreModel::Base
 
           # Pre-compute attribute definitions before the schema block
           attribute_defs = compute_attribute_definitions(