marktable 0.0.2 → 0.0.4s

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 662b8c0026118b8a9a8cbfcefc4e22ca2d245020672b04e9dc17e923356b60cd
-  data.tar.gz: 1307c073aeea515d89ee1e40c5d3a6753f6de815c7ae2f72f1ed042c9a733436
+  metadata.gz: '09cd0e8dca57fcd46c94f64c80ccba04609368bac7e7ddd6daf7c6d3ffd67320'
+  data.tar.gz: 90b6106afd8f92d4810fd786b58c925a21447738568afc3bcc344def6f6bcff6
 SHA512:
-  metadata.gz: 8fe53f45c22f224efece661fcdbcd4fbd61426211f331d592e93dfa33953344b64e73b1d8558d5640f01fd13d67f71f80fc63c42e55b7212f6326da7497911b4
-  data.tar.gz: e50d5d8cc11159dd809adb47b4f44a71116dab221a70b1c7a73495f7c4377601a6f7a59dc1afef9b67e7943758a86adaa1006460f02f4fe0f55fe9bd5387237d
+  metadata.gz: 8fa4867f6bfd9b9d9dabf2087203d501f2149c381c91479f6d79f45f6431e2cfc3096078a8f1f06cdcff9bb0e4a397af64af6adbd16a9a6fd515cbbd9f2cec36
+  data.tar.gz: 1bc26eb0ca767b832c90f636b8001a3c3967bd0369e4745a302301063ff8536251a9bbc879c1c88707afd6a19185b6442fd2370514ad8aaa371740e219811b4f

data/lib/marktable.rb

@@ -3,6 +3,10 @@
 require_relative 'marktable/row'
 require_relative 'marktable/table'
 
+if defined?(RSpec)
+  require_relative '../spec/support/matchers/markdown_matchers'
+end
+
 module Marktable
   # Parse a markdown table string into an array of rows
   def self.parse(markdown_table, headers: true)

data/spec/support/matchers/markdown_matchers.rb

@@ -0,0 +1,228 @@
+# frozen_string_literal: true
+
+require 'capybara'
+
+RSpec::Matchers.define :match_markdown do |expected_markdown|
+  match do |actual|
+    @actual_data = parse_input(actual)
+    @expected_data = parse_input(expected_markdown)
+    
+    normalize(@actual_data) == normalize(@expected_data)
+  end
+
+  failure_message do |actual|
+    @actual_data = parse_input(actual)
+    @expected_data = parse_input(expected_markdown)
+
+    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
+  
+  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.2
+  version: 0.0.4s
 platform: ruby
 authors:
 - Francois Gaspard
@@ -36,6 +36,7 @@ files:
 - lib/marktable.rb
 - lib/marktable/row.rb
 - lib/marktable/table.rb
+- spec/support/matchers/markdown_matchers.rb
 homepage: https://github.com/Francois-gaspard/marktable
 licenses:
 - MIT