notare 0.0.4 → 0.0.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1dd4e9ab394b198d4a9ddd59eb40fac35c865159e527fe14a90113bba1071fd0
-  data.tar.gz: e10d211085e797c80850ab3433b8802270df96bc01cd3d2ac348da6f17c675ec
+  metadata.gz: 959b59c2f2dc30ff265115057c1fd304f3b7747adfe16c9818e6de9e5c564fc1
+  data.tar.gz: 6c3da88bce319ed81fdb519308d6854c00f6a846343e37178e6bafab2b1fefbb
 SHA512:
-  metadata.gz: ba2c27ab7d6ad5a6f5b5239f54504e8352a5fee52374685f7e09d61284781ba93e9353a0c75f07a3e047571cc55d598c3764beb3c1d08663e54d11119e515fa5
-  data.tar.gz: b42bc57c20a639882a8912b1da7759b2c131443ce840f3d901a1a29a70a86e4f8238ce0b9d38ed688e0332fb99b77f7c5edcebffc611302273ede404c2a72197
+  metadata.gz: '00558f142269e3927cdb5aab15271a92533a48ff5ff2cf19c349e8757ccd9da77af9d27a249bc1a2551c910b8578a8bc9a354622cea7c20424183b7230bc06b9'
+  data.tar.gz: 2f179ca2e773afe314151b61fb9de4e48a6b0037bba3ce50397636b9f2a26790f5e0399c11f5d807c4f3a3090f562e094d0e02da40b4a77719f1bd4c3ea7ee8a

data/README.md

@@ -332,6 +332,75 @@ doc.table(style: :borderless) do
 end
 ```
 
+#### Column Sizing
+
+Control table column widths with layout modes and explicit sizing.
+
+**Auto-layout** - columns adjust to fit content:
+
+```ruby
+doc.table(layout: :auto) do
+  doc.tr do
+    doc.td "Short"
+    doc.td "This column expands to fit longer content"
+  end
+end
+```
+
+**Fixed column widths** - specify widths for all columns:
+
+```ruby
+# Inches
+doc.table(columns: %w[2in 3in 1.5in]) do
+  doc.tr do
+    doc.td "2 inches"
+    doc.td "3 inches"
+    doc.td "1.5 inches"
+  end
+end
+
+# Centimeters
+doc.table(columns: %w[5cm 10cm]) do
+  doc.tr { doc.td "5cm"; doc.td "10cm" }
+end
+
+# Percentages
+doc.table(columns: %w[25% 50% 25%]) do
+  doc.tr { doc.td "Quarter"; doc.td "Half"; doc.td "Quarter" }
+end
+```
+
+**Per-cell widths** - set width on individual cells:
+
+```ruby
+doc.table do
+  doc.tr do
+    doc.td("Narrow", width: "1in")
+    doc.td("Wide", width: "4in")
+  end
+end
+```
+
+**Combined layout and columns:**
+
+```ruby
+doc.table(layout: :fixed, columns: %w[2in 2in 2in]) do
+  doc.tr do
+    doc.td "A"
+    doc.td "B"
+    doc.td "C"
+  end
+end
+```
+
+**Width formats:**
+
+| Format | Example | Description |
+|--------|---------|-------------|
+| Inches | `"2in"` | Fixed width in inches |
+| Centimeters | `"5cm"` | Fixed width in centimeters |
+| Percentage | `"50%"` | Percentage of table width |
+
 ### Images
 
 Images can be added to paragraphs, table cells, and list items. Supports PNG and JPEG formats.
@@ -526,10 +595,10 @@ end
 | `li(text)` | List item with text |
 | `li { }` | List item with block content |
 | `li(text) { }` | List item with text and nested content |
-| `table(style:) { }` | Table with optional style |
+| `table(style:, layout:, columns:) { }` | Table with optional style, layout (`:auto`/`:fixed`), and column widths |
 | `tr { }` | Table row |
-| `td(text)` | Table cell with text |
-| `td { }` | Table cell with block content |
+| `td(text, width:)` | Table cell with text and optional width |
+| `td(width:) { }` | Table cell with block content and optional width |
 | `image(path, width:, height:)` | Insert image (PNG/JPEG). Dimensions: `"2in"`, `"5cm"`, `"100px"`, or integer pixels |
 
 ## Development

data/lib/notare/builder.rb

@@ -100,8 +100,8 @@ module Notare
       @current_list.add_item(item)
     end
 
-    def table(style: nil, &block)
-      tbl = Nodes::Table.new(style: resolve_table_style(style))
+    def table(style: nil, layout: nil, columns: nil, &block)
+      tbl = Nodes::Table.new(style: resolve_table_style(style), layout: layout, columns: columns)
       previous_table = @current_table
       @current_table = tbl
       block.call
@@ -118,8 +118,8 @@ module Notare
       @current_table.add_row(row)
     end
 
-    def td(text = nil, &block)
-      cell = Nodes::TableCell.new
+    def td(text = nil, width: nil, &block)
+      cell = Nodes::TableCell.new(width: width)
       if block
         with_target(cell, &block)
       elsif text

data/lib/notare/document.rb

@@ -88,13 +88,13 @@ module Notare
     def next_image_rid
       # rId1 = styles.xml (always present)
       # rId2 = numbering.xml (if lists present)
-      # rId3+ = images, then hyperlinks
+      # rId3+ = images and hyperlinks share the same ID space
       base = @has_lists ? 3 : 2
-      "rId#{base + @images.size}"
+      "rId#{base + @images.size + @hyperlinks.size}"
     end
 
     def next_hyperlink_rid
-      # Hyperlinks come after images
+      # Images and hyperlinks share the same ID space
       base = @has_lists ? 3 : 2
       "rId#{base + @images.size + @hyperlinks.size}"
     end

data/lib/notare/nodes/table.rb

@@ -3,12 +3,14 @@
 module Notare
   module Nodes
     class Table < Base
-      attr_reader :rows, :style
+      attr_reader :rows, :style, :layout, :columns
 
-      def initialize(style: nil)
+      def initialize(style: nil, layout: nil, columns: nil)
         super()
         @rows = []
         @style = style
+        @layout = layout
+        @columns = columns
       end
 
       def add_row(row)

data/lib/notare/nodes/table_cell.rb

@@ -3,11 +3,12 @@
 module Notare
   module Nodes
     class TableCell < Base
-      attr_reader :runs
+      attr_reader :runs, :width
 
-      def initialize
-        super
+      def initialize(width: nil)
+        super()
         @runs = []
+        @width = width
       end
 
       def add_run(run)

data/lib/notare/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Notare
-  VERSION = "0.0.4"
+  VERSION = "0.0.5"
 end

data/lib/notare/width_parser.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Notare
+  module WidthParser
+    TWIPS_PER_INCH = 1440
+    TWIPS_PER_CM = 567
+    PCT_MULTIPLIER = 50
+
+    ParsedWidth = Struct.new(:value, :type, keyword_init: true)
+
+    def self.parse(value)
+      case value
+      when :auto, nil
+        ParsedWidth.new(value: 0, type: "auto")
+      when Integer
+        ParsedWidth.new(value: value, type: "dxa")
+      when /\A(\d+(?:\.\d+)?)\s*in\z/i
+        twips = (::Regexp.last_match(1).to_f * TWIPS_PER_INCH).to_i
+        ParsedWidth.new(value: twips, type: "dxa")
+      when /\A(\d+(?:\.\d+)?)\s*cm\z/i
+        twips = (::Regexp.last_match(1).to_f * TWIPS_PER_CM).to_i
+        ParsedWidth.new(value: twips, type: "dxa")
+      when /\A(\d+(?:\.\d+)?)\s*%\z/
+        pct = (::Regexp.last_match(1).to_f * PCT_MULTIPLIER).to_i
+        ParsedWidth.new(value: pct, type: "pct")
+      else
+        raise ArgumentError, "Invalid width: #{value}. Use '2in', '5cm', '50%', :auto, or integer twips."
+      end
+    end
+  end
+end

data/lib/notare/xml/document_xml.rb

@@ -163,12 +163,12 @@ module Notare
       end
 
       def render_table(xml, table)
-        column_count = table.rows.first&.cells&.size || 1
-        col_width = 5000 / column_count
+        column_widths = compute_column_widths(table)
 
         xml["w"].tbl do
           xml["w"].tblPr do
-            xml["w"].tblW("w:w" => "5000", "w:type" => "pct")
+            render_table_width(xml, column_widths)
+            render_table_layout(xml, table.layout)
             if table.style
               xml["w"].tblStyle("w:val" => table.style.style_id)
             else
@@ -179,25 +179,89 @@ module Notare
               end
             end
           end
-          xml["w"].tblGrid do
-            column_count.times do
-              xml["w"].gridCol("w:w" => col_width.to_s)
-            end
+          render_table_grid(xml, column_widths)
+          table.rows.each { |row| render_table_row(xml, row, column_widths) }
+        end
+      end
+
+      def compute_column_widths(table)
+        if table.columns
+          table.columns.map { |c| WidthParser.parse(c) }
+        elsif table.layout == :auto
+          first_row = table.rows.first
+          cell_count = first_row&.cells&.size || 1
+          Array.new(cell_count) { WidthParser::ParsedWidth.new(value: 0, type: "auto") }
+        else
+          infer_widths_from_first_row(table)
+        end
+      end
+
+      def infer_widths_from_first_row(table)
+        first_row = table.rows.first
+        return [WidthParser::ParsedWidth.new(value: 5000, type: "pct")] unless first_row
+
+        cells = first_row.cells
+        has_explicit_widths = cells.any?(&:width)
+
+        if has_explicit_widths
+          cells.map do |cell|
+            cell.width ? WidthParser.parse(cell.width) : WidthParser::ParsedWidth.new(value: 0, type: "auto")
           end
-          table.rows.each { |row| render_table_row(xml, row, col_width) }
+        else
+          col_width = 5000 / cells.size
+          cells.map { WidthParser::ParsedWidth.new(value: col_width, type: "pct") }
         end
       end
 
-      def render_table_row(xml, row, col_width)
+      def render_table_width(xml, column_widths)
+        if column_widths.all? { |w| w.type == "pct" }
+          total = column_widths.sum(&:value)
+          xml["w"].tblW("w:w" => total.to_s, "w:type" => "pct")
+        elsif column_widths.all? { |w| w.type == "dxa" }
+          total = column_widths.sum(&:value)
+          xml["w"].tblW("w:w" => total.to_s, "w:type" => "dxa")
+        else
+          xml["w"].tblW("w:w" => "0", "w:type" => "auto")
+        end
+      end
+
+      def render_table_layout(xml, layout)
+        return unless layout
+
+        layout_type = layout == :auto ? "autofit" : "fixed"
+        xml["w"].tblLayout("w:type" => layout_type)
+      end
+
+      def render_table_grid(xml, column_widths)
+        xml["w"].tblGrid do
+          column_widths.each do |width|
+            grid_width = case width.type
+                         when "pct" then pct_to_approximate_dxa(width.value)
+                         when "auto" then 1440 # Default 1 inch for auto columns
+                         else width.value
+                         end
+            xml["w"].gridCol("w:w" => grid_width.to_s)
+          end
+        end
+      end
+
+      # Convert percentage (in fiftieths) to approximate twips
+      # Assumes 6.5 inch content width = 9360 twips
+      def pct_to_approximate_dxa(pct_value)
+        (pct_value * 9360 / 5000.0).to_i
+      end
+
+      def render_table_row(xml, row, column_widths)
         xml["w"].tr do
-          row.cells.each { |cell| render_table_cell(xml, cell, col_width) }
+          row.cells.each_with_index { |cell, idx| render_table_cell(xml, cell, column_widths[idx]) }
         end
       end
 
-      def render_table_cell(xml, cell, col_width)
+      def render_table_cell(xml, cell, column_width)
+        width = column_width || WidthParser::ParsedWidth.new(value: 0, type: "auto")
         xml["w"].tc do
           xml["w"].tcPr do
-            xml["w"].tcW("w:w" => col_width.to_s, "w:type" => "pct")
+            xml["w"].tcW("w:w" => width.value.to_s, "w:type" => width.type)
           end
           xml["w"].p do
             cell.runs.each { |run| render_run(xml, run) }

data/lib/notare/xml/styles_xml.rb

@@ -32,6 +32,8 @@ module Notare
               render_style(xml, style)
             end
 
+            render_table_normal_style(xml) if @table_styles.any?
+
             @table_styles.each_value do |style|
               render_table_style(xml, style)
             end
@@ -57,8 +59,12 @@ module Notare
         xml["w"].pPr do
           xml["w"].jc("w:val" => ALIGNMENT_MAP[style.align]) if style.align
           xml["w"].ind("w:left" => style.indent.to_s) if style.indent
-          xml["w"].spacing("w:before" => style.spacing_before.to_s) if style.spacing_before
-          xml["w"].spacing("w:after" => style.spacing_after.to_s) if style.spacing_after
+          if style.spacing_before || style.spacing_after
+            spacing_attrs = {}
+            spacing_attrs["w:before"] = style.spacing_before.to_s if style.spacing_before
+            spacing_attrs["w:after"] = style.spacing_after.to_s if style.spacing_after
+            xml["w"].spacing(spacing_attrs)
+          end
         end
       end
 
@@ -75,9 +81,24 @@ module Notare
         end
       end
 
+      def render_table_normal_style(xml)
+        xml["w"].style("w:type" => "table", "w:default" => "1", "w:styleId" => "TableNormal") do
+          xml["w"].name("w:val" => "Normal Table")
+          xml["w"].tblPr do
+            xml["w"].tblCellMar do
+              xml["w"].top("w:w" => "0", "w:type" => "dxa")
+              xml["w"].left("w:w" => "108", "w:type" => "dxa")
+              xml["w"].bottom("w:w" => "0", "w:type" => "dxa")
+              xml["w"].right("w:w" => "108", "w:type" => "dxa")
+            end
+          end
+        end
+      end
+
       def render_table_style(xml, style)
         xml["w"].style("w:type" => "table", "w:styleId" => style.style_id) do
           xml["w"].name("w:val" => style.display_name)
+          xml["w"].basedOn("w:val" => "TableNormal")
 
           xml["w"].tblPr do
             render_table_borders(xml, style.borders) if style.borders

data/lib/notare.rb

@@ -17,6 +17,7 @@ require_relative "notare/nodes/table_cell"
 require_relative "notare/image_dimensions"
 require_relative "notare/style"
 require_relative "notare/table_style"
+require_relative "notare/width_parser"
 require_relative "notare/xml/content_types"
 require_relative "notare/xml/relationships"
 require_relative "notare/xml/document_xml"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: notare
 version: !ruby/object:Gem::Version
-  version: 0.0.4
+  version: 0.0.5
 platform: ruby
 authors:
 - Mathias
@@ -135,6 +135,7 @@ files:
 - lib/notare/style.rb
 - lib/notare/table_style.rb
 - lib/notare/version.rb
+- lib/notare/width_parser.rb
 - lib/notare/xml/content_types.rb
 - lib/notare/xml/document_xml.rb
 - lib/notare/xml/numbering.rb