marktable 0.0.3 → 0.0.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5511339f01122f8adb6afe93a836eb2f5278786ab11d289682eca258f044567c
-  data.tar.gz: bb4ea8e3fd5e9bdbdf4b119c77da6907e225d4bdcae91281c3aab0514a665b7a
+  metadata.gz: a3e8c1a76daf4c3d03f628200baabad28e31008e444522fb2d6c7337f623bdd8
+  data.tar.gz: c83d7b0a83b21c2c292d5a76963f626ddeae5bebca42363f227f6bf65fed6dc2
 SHA512:
-  metadata.gz: 95d08a37b3e158597fc8c7b8d492aa618437010a4c72381b166952ba7fca5aeb9b4d55f993da2caec41524e1122fe162cb6cb2c2ba7cae5c818aa6038c2ae832
-  data.tar.gz: 55ccc61117f6e9d11097996716d76b0825f6e07329610e6b7fc6f063261cc0b1a482a5af92f787a830568c1533de02e5135bef97c448b65a7390dbb142b002cc
+  metadata.gz: f0f766d34db37402b6d4cbb52e37a1e33172175c5ba622051ce9899ded65de3c9fa045f7d21a234c9fc03856bfaefcf7b9b8d5f1fb346bd0c47efbee87e86236
+  data.tar.gz: 1a34281c031a0c47da3ff074f6206304fc569663a04ffab9246bd12a137eb7fd53a6745415991d6530d384f67e05eca480db02bdd9c49122687a9ae820475037

data/spec/support/matchers/markdown_matchers.rb

@@ -1,75 +1,155 @@
 # frozen_string_literal: true
 
+require 'capybara'
+require 'nokogiri'
+
 RSpec::Matchers.define :match_markdown do |expected_markdown|
   match do |actual|
-    # Handle markdown string, array of hashes, and Marktable::Table objects
-    actual_data = case actual
-                  when String
-                    Marktable.parse(actual)
-                  when Marktable::Table
-                    actual.to_a
-                  else
-                    actual
-                  end
-
-    expected_data = Marktable.parse(expected_markdown)
-    
-    # Normalize data by trimming whitespace in cell values
-    normalize = ->(data) {
-      data.map do |row|
-        if row.is_a?(Hash)
-          row.transform_values { |v| v.to_s.strip }
-        else
-          row.map { |v| v.to_s.strip }
-        end
-      end
-    }
-    
-    actual_data = normalize.call(actual_data)
-    expected_data = normalize.call(expected_data)
+    @actual_data = parse_input(actual)
+    @expected_data = parse_input(expected_markdown)
     
-    # Compare the parsed data structures
-    actual_data == expected_data
+    normalize(@actual_data) == normalize(@expected_data)
   end
 
   failure_message do |actual|
-    # Parse data for comparison output
-    actual_data = case actual
-                  when String
-                    Marktable.parse(actual)
-                  when Marktable::Table
-                    actual.to_a
-                  else
-                    actual
-                  end
-    expected_data = Marktable.parse(expected_markdown)
+    @actual_data = parse_input(actual)
+    @expected_data = parse_input(expected_markdown)
 
-    # Format both tables properly for display
-    actual_formatted = Marktable.table(actual_data).to_s
-    expected_formatted = Marktable.table(expected_data).to_s
+    format_failure_message(@expected_data, @actual_data)
+  end
 
+  failure_message_when_negated do |actual|
+    @actual_data = parse_input(actual)
+    
+    "Expected markdown tables to differ, but they match:\n\n" \
+    "#{format_as_markdown(@actual_data)}"
+  end
+  
+  private
+  
+  # Parse different types of inputs into a common data structure
+  def parse_input(input)
+    case input
+    when String
+      if looks_like_html?(input)
+        parse_html_table(input)
+      else
+        Marktable.parse(input)
+      end
+    when Marktable::Table
+      input.to_a
+    when Capybara::Node::Element
+      parse_capybara_element(input)
+    else
+      input
+    end
+  end
+  
+  def looks_like_html?(text)
+    text.include?('<table') || text.include?('<tr') || text.include?('<td')
+  end
+  
+  # Normalize data by trimming whitespace in cell values
+  def normalize(data)
+    data.map do |row|
+      if row.is_a?(Hash)
+        row.transform_values { |v| v.to_s.strip }
+      else
+        row.map { |v| v.to_s.strip }
+      end
+    end
+  end
+  
+  def format_failure_message(expected_data, actual_data)
+    expected_formatted = format_as_markdown(expected_data)
+    actual_formatted = format_as_markdown(actual_data)
+    
     "Expected markdown table to match:\n\n" \
     "Expected:\n#{expected_formatted}\n\n" \
     "Actual:\n#{actual_formatted}\n\n" \
     "Parsed expected data: #{expected_data.inspect}\n" \
     "Parsed actual data: #{actual_data.inspect}"
   end
-
-  failure_message_when_negated do |actual|
-    # Parse data for comparison output
-    actual_data = case actual
-                  when String
-                    Marktable.parse(actual)
-                  when Marktable::Table
-                    actual.to_a
-                  else
-                    actual
-                  end
+  
+  def format_as_markdown(data)
+    Marktable.table(data).to_s
+  end
+  
+  # Parse HTML table into rows of data using Nokogiri
+  def parse_html_table(html)
+    doc = Nokogiri::HTML(html)
     
-    # Generate properly formatted markdown for display
-    actual_formatted = Marktable.table(actual_data).to_s
-
-    "Expected markdown tables to differ, but they match:\n\n" \
-    "#{actual_formatted}"
+    # Extract headers
+    headers = extract_headers_with_nokogiri(doc)
+    
+    # Extract body rows
+    body_rows = extract_body_rows_with_nokogiri(doc)
+    
+    # Convert rows to hashes using the headers
+    body_rows.map do |row|
+      row_to_hash(row, headers)
+    end
+  end
+  
+  def extract_headers_with_nokogiri(doc)
+    headers = doc.css('thead th, thead td').map(&:text)
+    if headers.empty? && doc.css('tr').any?
+      headers = doc.css('tr:first-child th, tr:first-child td').map(&:text)
+    end
+    headers
+  end
+  
+  def extract_body_rows_with_nokogiri(doc)
+    tbody_rows = doc.css('tbody tr').map { |tr| tr.css('th, td').map(&:text) }
+    
+    # If no tbody, use all rows after the first (assuming first is header)
+    if tbody_rows.empty?
+      tbody_rows = doc.css('tr')[1..-1].to_a.map { |tr| tr.css('th, td').map(&:text) }
+    end
+    
+    tbody_rows
+  end
+  
+  def row_to_hash(cells, headers)
+    row_hash = {}
+    headers.each_with_index do |header, i|
+      row_hash[header] = i < cells.length ? cells[i] : ''
+    end
+    row_hash
+  end
+  
+  def parse_capybara_element(element)
+    # Extract headers
+    headers = extract_headers_from_capybara(element)
+    
+    # Extract body rows
+    body_rows = extract_body_rows_from_capybara(element)
+    
+    # Convert rows to hashes using the headers
+    body_rows.map do |cells|
+      row_to_hash(cells, headers)
+    end
+  end
+  
+  def extract_headers_from_capybara(element)
+    thead = element.first('thead') rescue nil
+    if thead
+      thead.all('th, td').map(&:text)
+    else
+      first_row = element.first('tr')
+      first_row ? first_row.all('th, td').map(&:text) : []
+    end
+  end
+  
+  def extract_body_rows_from_capybara(element)
+    body_rows = element.all('tbody tr')
+    
+    # If no tbody, assume first row is header and skip it
+    if body_rows.empty?
+      all_rows = element.all('tr')
+      body_rows = all_rows[1..]
+    end
+    
+    body_rows.map { |tr| tr.all('th, td').map(&:text) }
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: marktable
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 0.0.5
 platform: ruby
 authors:
 - Francois Gaspard
@@ -23,6 +23,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '13.0'
+- !ruby/object:Gem::Dependency
+  name: nokogiri
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.14'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.14'
 description: Provides a row-based object model and utility methods for creating, parsing,
   transforming, and exporting Markdown tables in Ruby.
 email: