marktable 0.0.4s → 0.1.0

data/lib/marktable.rb

@@ -1,140 +1,24 @@
 # frozen_string_literal: true
 
+require_relative 'marktable/version'
 require_relative 'marktable/row'
+require_relative 'marktable/tables/base'
 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)
-    Table.new(markdown_table, headers: headers).to_a
-  end
-
-  # Parse a single markdown row into an array of cell values
-  def self.parse_line(markdown_row)
-    Row.parse(markdown_row)
-  end
-
-  # Iterate through each row of a markdown table
-  def self.foreach(markdown_table, headers: true)
-    table = Table.new(markdown_table, headers: headers)
-    return Enumerator.new do |yielder|
-      table.each do |row|
-        yielder << row.data
-      end
-    end unless block_given?
-    
-    table.each do |row|
-      yield row.data
-    end
-  end
-
-  # Generate a markdown table from provided data
-  def self.generate(headers: nil)
-    result = []
-    markdown_table = ''
-    
-    if block_given?
-      table_data = []
-      yield table_data
-      
-      unless table_data.empty?
-        # Ensure all data is stringified
-        string_data = table_data.map do |row|
-          if row.is_a?(Hash)
-            row.transform_values(&:to_s)
-          else
-            row.map(&:to_s)
-          end
-        end
-        
-        # Create a Table object
-        table = table(string_data, headers: headers.nil? ? true : headers)
-        
-        markdown_table = table.generate
-      end
-    end
-    
-    markdown_table
-  end
-
-  # Read a markdown table from a file
-  def self.read(path, headers: true)
-    content = File.read(path)
-    Table.new(content, headers: headers)
-  end
-
-  # Write a markdown table to a file
-  def self.write(path, table_or_data)
-    content = if table_or_data.is_a?(Table)
-                table_or_data.to_s
-              else
-                table(table_or_data).to_s
-              end
-    
-    File.write(path, content)
+  def self.from_markdown(table, headers: nil)
+    Table.new(table, type: :markdown, headers:)
   end
 
-  # Convert an array to a Marktable::Table
-  def self.table(array, headers: true)
-    table = Table.new([], headers: headers)
-    
-    # Ensure all data values are strings
-    string_array = array.map do |row|
-      # Handle Row instances by extracting their data
-      if row.is_a?(Row)
-        row.data
-      elsif row.is_a?(Hash)
-        row.transform_values(&:to_s)
-      else
-        row.map(&:to_s)
-      end
-    end
-    
-    if headers && string_array.first.is_a?(Hash)
-      header_keys = string_array.first.keys
-      table.instance_variable_set(:@header_row, header_keys.each_with_object({}) { |k, h| h[k] = k })
-      table.instance_variable_set(:@rows, string_array.map { |row_data| Row.new(row_data, headers: header_keys) })
-    else
-      table.instance_variable_set(:@rows, string_array.map { |row_data| Row.new(row_data, headers: nil) })
-    end
-    
-    table
+  def self.from_csv(table, headers: nil)
+    Table.new(table, type: :csv, headers:)
   end
 
-  # Filter rows matching a pattern
-  def self.filter(markdown_table, pattern, headers: true)
-    table = Table.new(markdown_table, headers: headers)
-    filtered_rows = table.to_a.select do |row|
-      if row.is_a?(Hash)
-        row.values.any? { |v| v.to_s.match?(pattern) }
-      else
-        row.any? { |v| v.to_s.match?(pattern) }
-      end
-    end
-    
-    table(filtered_rows, headers: headers)
+  def self.from_array(table, headers: nil)
+    Table.new(table, type: :array, headers:)
   end
 
-  # Map over rows (all values will be converted to strings)
-  def self.map(markdown_table, headers: true)
-    table = Table.new(markdown_table, headers: headers)
-    mapped_rows = []
-    
-    table.each do |row|
-      result = yield(row)
-      # Ensure result is string-compatible
-      if result.is_a?(Hash)
-        result = result.transform_values(&:to_s)
-      elsif result.is_a?(Array)
-        result = result.map(&:to_s)
-      end
-      mapped_rows << result
-    end
-    
-    table(mapped_rows, headers: headers)
+  def self.from_html(table)
+    Table.new(table, type: :html)
   end
 end

data/spec/support/matchers/markdown_matchers.rb

@@ -1,228 +1,57 @@
 # frozen_string_literal: true
 
 require 'capybara'
+require 'nokogiri'
 
 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)
+  chain :with_format do |format|
+    @format = format
   end
 
-  failure_message do |actual|
-    @actual_data = parse_input(actual)
-    @expected_data = parse_input(expected_markdown)
+  match do |actual|
+    @expected_data = parse_input(expected_markdown, :markdown)
+    @format ||= infer_format(actual)
+    @actual_data = parse_input(actual, @format)
 
+    # Compare data using to_a for consistent comparison
+    @actual_data.to_a == @expected_data.to_a
+  end
+
+  failure_message do
     format_failure_message(@expected_data, @actual_data)
   end
 
-  failure_message_when_negated do |actual|
-    @actual_data = parse_input(actual)
-    
+  failure_message_when_negated do
     "Expected markdown tables to differ, but they match:\n\n" \
-    "#{format_as_markdown(@actual_data)}"
+    "#{@actual_data.to_md}"
   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
+
+  def parse_input(input, format = nil)
+    return input if input.is_a?(Marktable::Table)
+
+    Marktable::Table.new(input, type: format)
+  end
+
+  def infer_format(data)
+    case data
+    when Array
+      :array
+    when CSV::Table
+      :csv
     when Marktable::Table
-      input.to_a
-    when Capybara::Node::Element
-      parse_capybara_element(input)
+      :markdown
     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
+      :markdown
     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) }
+    "Expected:\n#{expected_data.to_md}\n\n" \
+    "Actual:\n#{actual_data.to_md}\n\n" \
+    "Parsed expected data: #{expected_data.to_a.inspect}\n" \
+    "Parsed actual data: #{actual_data.to_a.inspect}"
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: marktable
 version: !ruby/object:Gem::Version
-  version: 0.0.4s
+  version: 0.1.0
 platform: ruby
 authors:
 - Francois Gaspard
@@ -9,6 +9,34 @@ bindir: bin
 cert_chain: []
 date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: csv
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.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'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -34,8 +62,18 @@ files:
 - LICENSE
 - README.md
 - lib/marktable.rb
+- lib/marktable/formatters/base.rb
+- lib/marktable/formatters/csv.rb
+- lib/marktable/formatters/html.rb
+- lib/marktable/formatters/markdown.rb
 - lib/marktable/row.rb
 - lib/marktable/table.rb
+- lib/marktable/tables/array.rb
+- lib/marktable/tables/base.rb
+- lib/marktable/tables/csv.rb
+- lib/marktable/tables/html.rb
+- lib/marktable/tables/markdown.rb
+- lib/marktable/version.rb
 - spec/support/matchers/markdown_matchers.rb
 homepage: https://github.com/Francois-gaspard/marktable
 licenses: