uniword 1.0.0

data/lib/uniword/revision.rb

@@ -0,0 +1,200 @@
+# frozen_string_literal: true
+
+module Uniword
+  # Represents a single revision (change) in a Word document.
+  #
+  # Revisions are part of Word's track changes feature, recording
+  # insertions, deletions, and formatting changes with author and
+  # timestamp information.
+  #
+  # In OOXML:
+  # - Insertions: <w:ins>
+  # - Deletions: <w:del>
+  # - Format changes: <w:rPrChange>, <w:pPrChange>
+  #
+  # @example Create an insertion
+  #   revision = Uniword::Revision.new(
+  #     type: :insert,
+  #     author: "John Doe",
+  #     text: "New text"
+  #   )
+  #
+  # @example Create a deletion
+  #   revision = Uniword::Revision.new(
+  #     type: :delete,
+  #     author: "Jane Smith",
+  #     text: "Deleted text"
+  #   )
+  #
+  # @attr [Symbol] type Revision type (:insert, :delete, :format_change)
+  # @attr [String] author Author name
+  # @attr [String] date Revision date/time
+  # @attr [String] revision_id Unique revision identifier
+  # @attr [String] text Content affected by the revision
+  #
+  # @see TrackedChanges For revision collection management
+  class Revision < Lutaml::Model::Serializable
+    # OOXML namespace configuration
+    xml do
+      element 'ins'
+      namespace Ooxml::Namespaces::WordProcessingML
+
+      map_attribute 'id', to: :revision_id
+      map_attribute 'author', to: :author
+      map_attribute 'date', to: :date
+    end
+
+    # Unique revision identifier
+    attribute :revision_id, :string
+
+    # Author name
+    attribute :author, :string
+
+    # Revision date/time
+    attribute :date, :string
+
+    # Revision type (:insert, :delete, :format_change)
+    attr_accessor :type
+
+    # Content affected by revision
+    attr_accessor :content
+
+    # Initialize a new revision
+    #
+    # @param attributes [Hash] Revision attributes
+    # @option attributes [Symbol] :type Revision type
+    # @option attributes [String] :author Author name
+    # @option attributes [String] :text Text content
+    # @option attributes [String] :date Revision date
+    # @option attributes [String] :revision_id Unique ID
+    def initialize(attributes = {})
+      # Extract custom attributes before calling super
+      @type = attributes.delete(:type) || :insert
+      text_content = attributes.delete(:text)
+      @content = attributes.delete(:content)
+
+      super
+
+      # Auto-generate revision_id if not provided
+      @revision_id ||= generate_revision_id
+
+      # Set date to current time if not provided
+      @date ||= format_date(Time.now)
+
+      # Set content from text if provided
+      return unless text_content && !text_content.empty?
+
+      @content = text_content
+    end
+
+    # Accept a visitor for the visitor pattern
+    #
+    # @param visitor [Object] The visitor object
+    # @return [Object] The result of the visit operation
+    def accept(visitor)
+      visitor.visit_revision(self)
+    end
+
+    # Get text content
+    #
+    # @return [String] The text content
+    def text
+      content.to_s
+    end
+
+    # Check if this is an insertion
+    #
+    # @return [Boolean] true if insertion
+    def insert?
+      type == :insert
+    end
+
+    # Check if this is a deletion
+    #
+    # @return [Boolean] true if deletion
+    def delete?
+      type == :delete
+    end
+
+    # Check if this is a format change
+    #
+    # @return [Boolean] true if format change
+    def format_change?
+      type == :format_change
+    end
+
+    # Check if this revision is valid
+    #
+    # A revision is valid if it has a non-empty author, a revision_id,
+    # a type, and the type is one of the valid types.
+    #
+    # @return [Boolean] true if valid
+    def valid?
+      required_attributes_valid?
+    end
+
+    # Get the XML element name based on revision type
+    #
+    # @return [String] The XML element name
+    def xml_element_name
+      case type
+      when :insert
+        'ins'
+      when :delete
+        'del'
+      when :format_change
+        'rPrChange'
+      else
+        raise ArgumentError, "Invalid revision type: #{type}"
+      end
+    end
+
+    # Provide detailed inspection for debugging
+    #
+    # @return [String] A readable representation of the revision
+    def inspect
+      text_preview = text[0..30]
+      text_preview += '...' if text.length > 30
+      "#<Uniword::Revision type=#{type.inspect} author=#{author.inspect} text=#{text_preview.inspect}>"
+    end
+
+    protected
+
+    # Validate that revision has required attributes
+    #
+    # @return [Boolean] true if valid
+    def required_attributes_valid?
+      !author.nil? && !author.empty? &&
+        !revision_id.nil? &&
+        !type.nil? &&
+        valid_type?
+    end
+
+    private
+
+    # Check if type is valid
+    #
+    # @return [Boolean] true if valid type
+    def valid_type?
+      %i[insert delete format_change].include?(type)
+    end
+
+    # Generate a unique revision ID
+    #
+    # @return [String] A unique revision ID
+    def generate_revision_id
+      # Use timestamp + random component for uniqueness
+      "#{Time.now.to_i}_#{rand(10_000)}"
+    end
+
+    # Format date for OOXML
+    #
+    # @param time [Time] The time object
+    # @return [String] ISO 8601 formatted date string
+    def format_date(time)
+      return time if time.is_a?(String)
+
+      time.utc.iso8601
+    end
+  end
+end

data/lib/uniword/schema/model_generator.rb

@@ -0,0 +1,182 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+
+module Uniword
+  module Schema
+    # ModelGenerator generates lutaml-model classes from YAML schema definitions
+    #
+    # This generator creates complete, proper lutaml-model classes that follow
+    # ALL architectural rules, especially Pattern 0 (attributes BEFORE xml blocks).
+    #
+    # @example Generate classes for WordProcessingML namespace
+    #   generator = ModelGenerator.new('wordprocessingml')
+    #   generator.generate_all
+    class ModelGenerator
+      attr_reader :schema_name, :namespace_info, :output_dir
+
+      def initialize(schema_name, output_dir: nil)
+        @schema_name = schema_name
+        @loader = SchemaLoader.instance
+        @namespace_info = @loader.namespace(schema_name)
+        @output_dir = output_dir || File.join(__dir__, '../../generated', schema_name)
+      end
+
+      # Generate all classes for this schema
+      #
+      # @return [Hash] Map of element_name => generated_file_path
+      def generate_all
+        element_names = @loader.element_names(schema_name)
+
+        # Ensure output directory exists
+        FileUtils.mkdir_p(@output_dir)
+
+        results = {}
+        element_names.each do |element_name|
+          file_path = generate_element_class(element_name)
+          results[element_name] = file_path
+        end
+
+        results
+      end
+
+      # Generate a single element class
+      #
+      # @param element_name [String] Element XML tag name
+      # @return [String] Path to generated file
+      def generate_element_class(element_name)
+        element_def = @loader.element_definition(schema_name, element_name)
+        raise "Element '#{element_name}' not found in schema '#{schema_name}'" unless element_def
+
+        # Ensure output directory exists
+        FileUtils.mkdir_p(@output_dir)
+
+        class_name = element_def['class_name']
+        file_name = underscore(class_name)
+        file_path = File.join(@output_dir, "#{file_name}.rb")
+
+        code = generate_class_code(element_name, element_def)
+        File.write(file_path, code)
+
+        file_path
+      end
+
+      private
+
+      # Generate complete class code
+      #
+      # @param element_name [String] XML element name
+      # @param element_def [Hash] Element definition from schema
+      # @return [String] Ruby class code
+      def generate_class_code(element_name, element_def)
+        class_name = element_def['class_name']
+        description = element_def['description']
+        attributes = element_def['attributes'] || []
+
+        <<~RUBY
+          # frozen_string_literal: true
+
+          require 'lutaml/model'
+
+          module Uniword
+            module Generated
+              module #{camelize(schema_name)}
+                # #{description}
+                #
+                # Generated from OOXML schema: #{schema_name}.yml
+                # Element: <#{@namespace_info['prefix']}:#{element_name}>
+                class #{class_name} < Lutaml::Model::Serializable
+          #{generate_attributes(attributes)}
+
+          #{generate_xml_mapping(element_name, attributes)}
+                end
+              end
+            end
+          end
+        RUBY
+      end
+
+      # Generate attribute declarations
+      # CRITICAL: These MUST come BEFORE xml mapping (Pattern 0)
+      #
+      # @param attributes [Array<Hash>] Attribute definitions
+      # @return [String] Attribute declaration code
+      def generate_attributes(attributes)
+        return '' if attributes.empty?
+
+        lines = attributes.map do |attr|
+          # Convert type to symbol for primitive types
+          type_str = if %w[String
+                           Integer].include?(attr['type'])
+                       ":#{attr['type'].downcase}"
+                     else
+                       attr['type']
+                     end
+          attr_code = "          attribute :#{attr['name']}, #{type_str}"
+          attr_code += ', collection: true' if attr['collection']
+          attr_code += ', initialize_empty: true' if attr['collection']
+          attr_code
+        end
+
+        lines.join("\n")
+      end
+
+      # Generate XML mapping block
+      # CRITICAL: This comes AFTER attributes (Pattern 0)
+      #
+      # @param element_name [String] XML element name
+      # @param attributes [Array<Hash>] Attribute definitions
+      # @return [String] XML mapping code
+      def generate_xml_mapping(element_name, attributes)
+        lines = []
+        lines << '          xml do'
+        lines << "            element '#{element_name}'"
+        lines << "            namespace '#{@namespace_info['uri']}', '#{@namespace_info['prefix']}'"
+        lines << '            mixed_content' if has_nested_content?(attributes)
+        lines << ''
+
+        # Map each attribute
+        attributes.each do |attr|
+          if attr['xml_attribute']
+            # Attribute value (e.g., <w:p w:val="value">)
+            lines << "            map_attribute '#{attr['xml_name']}', to: :#{attr['name']}"
+          else
+            # Element value (e.g., <w:p><w:pPr>...</w:pPr></w:p>)
+            map_line = "            map_element '#{attr['xml_name']}', to: :#{attr['name']}"
+            map_line += ', render_nil: false' unless attr['required']
+            lines << map_line
+          end
+        end
+
+        lines << '          end'
+        lines.join("\n")
+      end
+
+      # Check if element has nested content requiring mixed_content
+      #
+      # @param attributes [Array<Hash>] Attribute definitions
+      # @return [Boolean] true if has nested elements
+      def has_nested_content?(attributes)
+        attributes.any? { |attr| attr['xml_name'] && !attr['xml_attribute'] }
+      end
+
+      # Convert CamelCase to snake_case
+      #
+      # @param str [String] CamelCase string
+      # @return [String] snake_case string
+      def underscore(str)
+        str.gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
+           .gsub(/([a-z\d])([A-Z])/, '\1_\2')
+           .downcase
+      end
+
+      # Convert snake_case to CamelCase
+      #
+      # @param str [String] snake_case string
+      # @return [String] CamelCase string
+      def camelize(str)
+        str.split('_').map(&:capitalize).join
+      end
+    end
+  end
+end

data/lib/uniword/schema/schema_loader.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+require 'yaml'
+require 'singleton'
+
+module Uniword
+  module Schema
+    # SchemaLoader loads and caches OOXML schema definitions from YAML files
+    #
+    # This class follows the Singleton pattern to ensure schemas are loaded once
+    # and reused throughout the application lifecycle.
+    #
+    # @example Load a schema
+    #   loader = SchemaLoader.instance
+    #   wordprocessingml = loader.load_schema('wordprocessingml')
+    #   element_def = loader.element_definition('wordprocessingml', 'p')
+    class SchemaLoader
+      include Singleton
+
+      def initialize
+        @schemas = {}
+        @schema_path = File.join(__dir__, '../../../config/ooxml/schemas')
+      end
+
+      # Load a schema by name
+      #
+      # @param schema_name [String] Name of the schema file (without .yml extension)
+      # @return [Hash] Parsed schema definition
+      # @raise [SchemaNotFoundError] if schema file doesn't exist
+      def load_schema(schema_name)
+        return @schemas[schema_name] if @schemas.key?(schema_name)
+
+        schema_file = File.join(@schema_path, "#{schema_name}.yml")
+        unless File.exist?(schema_file)
+          raise SchemaNotFoundError,
+                "Schema file not found: #{schema_file}"
+        end
+
+        @schemas[schema_name] = YAML.load_file(schema_file)
+      end
+
+      # Get element definition from a schema
+      #
+      # @param schema_name [String] Schema name
+      # @param element_name [String] Element XML tag name
+      # @return [Hash, nil] Element definition or nil if not found
+      def element_definition(schema_name, element_name)
+        schema = load_schema(schema_name)
+        schema.dig('elements', element_name)
+      end
+
+      # Get namespace information for a schema
+      #
+      # @param schema_name [String] Schema name
+      # @return [Hash] Namespace definition with :uri, :prefix, :description
+      def namespace(schema_name)
+        schema = load_schema(schema_name)
+        schema['namespace']
+      end
+
+      # Get all element names in a schema
+      #
+      # @param schema_name [String] Schema name
+      # @return [Array<String>] Element names
+      def element_names(schema_name)
+        schema = load_schema(schema_name)
+        schema['elements']&.keys || []
+      end
+
+      # Clear cached schemas (useful for testing)
+      #
+      # @return [void]
+      def clear_cache!
+        @schemas.clear
+      end
+
+      # Get all available schemas
+      #
+      # @return [Array<String>] Schema names
+      def available_schemas
+        Dir.glob(File.join(@schema_path, '*.yml')).map do |file|
+          File.basename(file, '.yml')
+        end
+      end
+    end
+
+    # Raised when a schema file cannot be found
+    class SchemaNotFoundError < StandardError; end
+  end
+end

data/lib/uniword/schema.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Uniword
+  module Schema
+    autoload :SchemaLoader, "#{__dir__}/schema/schema_loader"
+    autoload :ModelGenerator, "#{__dir__}/schema/model_generator"
+  end
+end

data/lib/uniword/section.rb

@@ -0,0 +1,183 @@
+# frozen_string_literal: true
+
+require 'lutaml/model'
+
+module Uniword
+  # Represents a document section
+  # Each section can have its own page setup, headers, and footers
+  class Section < Lutaml::Model::Serializable
+    attribute :properties, SectionProperties
+    attribute :headers, Header, collection: true, initialize_empty: true
+    attribute :footers, Footer, collection: true, initialize_empty: true
+
+    def initialize(**attributes)
+      super
+      @properties ||= SectionProperties.a4_portrait
+      @headers ||= []
+      @footers ||= []
+    end
+
+    # Add a header to this section
+    def add_header(header)
+      raise ArgumentError, 'header must be a Header instance' unless header.is_a?(Header)
+
+      headers << header
+    end
+
+    # Add a footer to this section
+    def add_footer(footer)
+      footers << footer
+    end
+
+    # Get header by type
+    def get_header(type = 'default')
+      headers.find { |h| h.type == type }
+    end
+
+    # Get footer by type
+    def get_footer(type = 'default')
+      footers.find { |f| f.type == type }
+    end
+
+    # Get or create header by type
+    def header(type = 'default')
+      get_header(type) || begin
+        h = Header.new(type: type)
+        add_header(h)
+        h
+      end
+    end
+
+    # Get or create footer by type
+    def footer(type = 'default')
+      get_footer(type) || begin
+        f = Footer.new(type: type)
+        add_footer(f)
+        f
+      end
+    end
+
+    # Convenience accessors for different header types
+    def default_header
+      get_header('default')
+    end
+
+    def default_header=(header)
+      # Remove existing default header
+      headers.reject! { |h| h.type == 'default' }
+      header.type = 'default' if header
+      add_header(header) if header
+    end
+
+    def first_header
+      get_header('first')
+    end
+
+    def first_header=(header)
+      headers.reject! { |h| h.type == 'first' }
+      header.type = 'first' if header
+      add_header(header) if header
+    end
+
+    def even_header
+      get_header('even')
+    end
+
+    def even_header=(header)
+      headers.reject! { |h| h.type == 'even' }
+      header.type = 'even' if header
+      add_header(header) if header
+    end
+
+    # Convenience accessors for different footer types
+    def default_footer
+      get_footer('default')
+    end
+
+    def default_footer=(footer)
+      footers.reject! { |f| f.type == 'default' }
+      footer.type = 'default' if footer
+      add_footer(footer) if footer
+    end
+
+    def first_footer
+      get_footer('first')
+    end
+
+    def first_footer=(footer)
+      footers.reject! { |f| f.type == 'first' }
+      footer.type = 'first' if footer
+      add_footer(footer) if footer
+    end
+
+    def even_footer
+      get_footer('even')
+    end
+
+    def even_footer=(footer)
+      footers.reject! { |f| f.type == 'even' }
+      footer.type = 'even' if footer
+      add_footer(footer) if footer
+    end
+
+    # Check if section has any headers
+    def has_headers?
+      headers.any?
+    end
+
+    # Check if section has any footers
+    def has_footers?
+      footers.any?
+    end
+
+    # Get page margins as hash (docx-js compatibility)
+    # Returns hash with margin values in twips
+    #
+    # @return [Hash] Margin configuration
+    def page_margins
+      ensure_properties
+      {
+        top: @properties.margin_top,
+        bottom: @properties.margin_bottom,
+        left: @properties.margin_left,
+        right: @properties.margin_right,
+        header: @properties.margin_header,
+        footer: @properties.margin_footer
+      }
+    end
+
+    # Set page margins from hash (docx-js compatibility)
+    # Accepts hash with margin values in twips
+    #
+    # @param value [Hash] Margin configuration
+    # @option value [Integer] :top Top margin in twips
+    # @option value [Integer] :bottom Bottom margin in twips
+    # @option value [Integer] :left Left margin in twips
+    # @option value [Integer] :right Right margin in twips
+    # @option value [Integer] :header Header margin in twips
+    # @option value [Integer] :footer Footer margin in twips
+    # @return [Hash] the value set
+    def page_margins=(value)
+      return unless value.is_a?(Hash)
+
+      ensure_properties
+      @properties.margin_top = value[:top] if value.key?(:top)
+      @properties.margin_bottom = value[:bottom] if value.key?(:bottom)
+      @properties.margin_left = value[:left] if value.key?(:left)
+      @properties.margin_right = value[:right] if value.key?(:right)
+      @properties.margin_header = value[:header] if value.key?(:header)
+      @properties.margin_footer = value[:footer] if value.key?(:footer)
+      value
+    end
+
+    private
+
+    # Ensure properties object exists
+    # Creates a new SectionProperties if needed
+    #
+    # @return [SectionProperties] the properties object
+    def ensure_properties
+      @ensure_properties ||= SectionProperties.new
+    end
+  end
+end