marktable 0.0.3 → 0.0.4s

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5511339f01122f8adb6afe93a836eb2f5278786ab11d289682eca258f044567c
-  data.tar.gz: bb4ea8e3fd5e9bdbdf4b119c77da6907e225d4bdcae91281c3aab0514a665b7a
+  metadata.gz: '09cd0e8dca57fcd46c94f64c80ccba04609368bac7e7ddd6daf7c6d3ffd67320'
+  data.tar.gz: 90b6106afd8f92d4810fd786b58c925a21447738568afc3bcc344def6f6bcff6
 SHA512:
-  metadata.gz: 95d08a37b3e158597fc8c7b8d492aa618437010a4c72381b166952ba7fca5aeb9b4d55f993da2caec41524e1122fe162cb6cb2c2ba7cae5c818aa6038c2ae832
-  data.tar.gz: 55ccc61117f6e9d11097996716d76b0825f6e07329610e6b7fc6f063261cc0b1a482a5af92f787a830568c1533de02e5135bef97c448b65a7390dbb142b002cc
+  metadata.gz: 8fa4867f6bfd9b9d9dabf2087203d501f2149c381c91479f6d79f45f6431e2cfc3096078a8f1f06cdcff9bb0e4a397af64af6adbd16a9a6fd515cbbd9f2cec36
+  data.tar.gz: 1bc26eb0ca767b832c90f636b8001a3c3967bd0369e4745a302301063ff8536251a9bbc879c1c88707afd6a19185b6442fd2370514ad8aaa371740e219811b4f

data/spec/support/matchers/markdown_matchers.rb

@@ -1,75 +1,228 @@
 # frozen_string_literal: true
 
+require 'capybara'
+
 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
-    
-    # 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}"
+  
+  def format_as_markdown(data)
+    Marktable.table(data).to_s
+  end
+  
+  # Parse HTML table into rows of data
+  def parse_html_table(html)
+    if defined?(Nokogiri)
+      parse_html_with_nokogiri(html)
+    else
+      begin
+        require('nokogiri')
+        parse_html_with_nokogiri(html)
+      rescue LoadError
+        parse_html_without_nokogiri(html)
+      end
+    end
+  end
+  
+  def parse_html_with_nokogiri(html)
+    doc = Nokogiri::HTML(html)
+    
+    # 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 parse_html_without_nokogiri(html)
+    # Extract headers
+    headers = extract_headers_without_nokogiri(html)
+    
+    # Extract body rows
+    body_rows = extract_body_rows_without_nokogiri(html, headers)
+    
+    body_rows
+  end
+  
+  def extract_headers_without_nokogiri(html)
+    headers = []
+    
+    if html.include?('<thead')
+      # Extract headers from thead
+      thead_html = html[html.index('<thead')...(html.index('</thead>') + 8)]
+      headers = thead_html.scan(/<t[hd].*?>(.*?)<\/t[hd]>/im).map { |cell| cell[0].strip }
+    else
+      # No thead, get headers from first tr
+      first_tr = html.match(/<tr.*?>(.*?)<\/tr>/im)
+      if first_tr
+        headers = first_tr[1].scan(/<t[hd].*?>(.*?)<\/t[hd]>/im).map { |cell| cell[0].strip }
+      end
+    end
+    
+    headers
+  end
+  
+  def extract_body_rows_without_nokogiri(html, headers)
+    rows = []
+    has_thead = html.include?('<thead')
+    has_tbody = html.include?('<tbody')
+    in_tbody = false
+    
+    html.scan(/<tr.*?>(.*?)<\/tr>/im).each_with_index do |tr_content, index|
+      # Skip header rows
+      next if should_skip_header_row?(html, tr_content[0], index, has_thead, has_tbody)
+      
+      # For tables with thead/tbody, only include tbody rows
+      if has_thead && has_tbody
+        in_tbody = html[0..html.index(tr_content[0])].include?('<tbody') unless in_tbody
+        in_tbody = false if html[0..html.index(tr_content[0])].include?('</tbody')
+        next unless in_tbody
+      end
+      
+      cells = tr_content[0].scan(/<t[hd].*?>(.*?)<\/t[hd]>/im).map { |cell_content| cell_content[0].strip }
+      
+      if cells.any? && headers.any?
+        rows << row_to_hash(cells, headers)
+      end
+    end
+    
+    rows
+  end
+  
+  def should_skip_header_row?(html, tr_content, index, has_thead, has_tbody)
+    (has_thead && html[0..html.index(tr_content)].include?('<thead') && 
+     !html[0..html.index(tr_content)].include?('</thead')) ||
+     (!has_thead && !has_tbody && index == 0)
+  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.4s
 platform: ruby
 authors:
 - Francois Gaspard