marktable 0.0.5 → 0.1.1

data/lib/marktable/tables/array.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require_relative 'base'
+
+module Marktable
+  module Tables
+    class Array
+      def initialize(array, headers)
+        @array = array
+        @headers_flag = headers
+      end
+
+      def parse
+        return Tables::Base.blank if @array.empty?
+
+        # Determine if this is an array of hashes or array of arrays
+        if @array.first.is_a?(Hash)
+          parse_array_of_hashes
+        else
+          parse_array_of_arrays
+        end
+      end
+
+      private
+
+      def parse_array_of_hashes
+        # Extract all unique keys from all hashes to handle mismatched keys
+        headers = @array.flat_map(&:keys).uniq
+
+        # Create Row objects for each hash
+        rows = @array.map do |hash|
+          Row.new(hash, headers: headers)
+        end
+
+        Tables::Base::Result.new(rows:, headers:)
+      end
+
+      def parse_array_of_arrays
+        # Arrays of arrays can have an optional header row
+        if @headers_flag
+          headers = @array.first
+          data_rows = @array[1..]
+        else
+          headers = nil
+          data_rows = @array
+        end
+
+        # Create Row objects for each array
+        rows = data_rows.map do |values|
+          Row.new(values, headers: headers)
+        end
+
+        Tables::Base::Result.new(rows:, headers:)
+      end
+    end
+  end
+end

data/lib/marktable/tables/base.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require_relative 'markdown'
+require_relative 'array'
+require_relative 'csv'
+require_relative 'html'
+
+module Marktable
+  module Tables
+    class Base
+      Result = Struct.new(:rows, :headers, keyword_init: true)
+
+      def self.for(type)
+        case type.to_sym
+        when :markdown
+          Markdown
+        when :array
+          Array
+        when :csv
+          CSV
+        when :html
+          HTML
+        else
+          raise ArgumentError, "Unknown table type: #{type}"
+        end
+      end
+
+      def self.blank
+        Result.new(rows: [], headers: nil)
+      end
+    end
+  end
+end

data/lib/marktable/tables/csv.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require 'csv'
+require_relative 'base'
+
+module Marktable
+  module Tables
+    class CSV
+      def initialize(csv_data, headers)
+        @csv_data = csv_data
+        @headers_flag = headers
+      end
+
+      def parse
+        csv_table = parse_csv
+
+        if with_headers?
+          parse_with_headers(csv_table)
+        else
+          parse_without_headers(csv_table)
+        end
+      end
+
+      private
+
+      def parse_csv
+        case @csv_data
+        when ::CSV::Table
+          @csv_data
+        when String
+          ::CSV.parse(@csv_data, headers: @headers_flag)
+        else
+          raise ArgumentError, "Cannot parse CSV from #{@csv_data.class}"
+        end
+      end
+
+      def with_headers?
+        @headers_flag || (@csv_data.is_a?(::CSV::Table) && @csv_data.headers.any?)
+      end
+
+      def parse_with_headers(csv_table)
+        headers = csv_table.headers
+        rows = []
+
+        csv_table.each do |csv_row|
+          # Convert CSV::Row to hash then to our Row
+          row_data = csv_row.to_h
+          rows << Row.new(row_data, headers: headers)
+        end
+
+        Tables::Base::Result.new(rows:, headers:)
+      end
+
+      def parse_without_headers(csv_table)
+        rows = []
+
+        if csv_table.is_a?(::CSV::Table)
+          csv_table.each do |csv_row|
+            rows << Row.new(csv_row.fields)
+          end
+        else
+          csv_table.each do |fields|
+            rows << Row.new(fields)
+          end
+        end
+
+        Tables::Base::Result.new(rows:, headers: nil)
+      end
+    end
+  end
+end

data/lib/marktable/tables/html.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+require 'nokogiri'
+require_relative 'base'
+
+module Marktable
+  module Tables
+    class HTML
+      private attr_reader :table
+
+      def initialize(html_data, headers = nil)
+        @table = extract_table_node(html_data)
+        @headers_flag = headers
+      end
+
+      def parse
+        return blank if table.nil? || rows.empty?
+
+        if has_headers?
+          headers = extract_row_cells(first_row)
+          data_rows = rows[1..]
+        else
+          headers = nil
+          data_rows = rows
+        end
+
+        # Extract data from rows
+        parsed_rows = data_rows.map do |row|
+          Row.new(extract_row_cells(row), headers:)
+        end
+
+        Tables::Base::Result.new(rows: parsed_rows, headers:)
+      end
+
+      private
+
+      def extract_table_node(html_data)
+        case html_data
+        when String
+          return nil if html_data.strip.empty?
+
+          Nokogiri::HTML(html_data).at_css('table')
+        when Nokogiri::XML::Element, Nokogiri::XML::NodeSet
+          html_data.name == 'table' ? html_data : html_data.at_css('table')
+        else
+          Nokogiri::HTML(html_data.to_s).at_css('table')
+        end
+      end
+
+      def extract_row_cells(row)
+        row.css('th, td').map(&:text)
+      end
+
+      def first_row
+        @first_row ||= rows.first
+      end
+
+      def has_headers?
+        @has_headers ||= first_row.css('th').any? || @headers_flag
+      end
+
+      def rows
+        @rows ||= table.css('tr')
+      end
+    end
+  end
+end

data/lib/marktable/tables/markdown.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+require_relative 'base'
+
+module Marktable
+  module Tables
+    class Markdown
+      # @param [table] [String] The markdown table string.
+      # @param [headers] [boolean] Whether the table has headers or not.
+      #  If nil, it will be inferred from the table content.
+      def initialize(table, headers)
+        @headers_flag = headers
+        @markdown_rows = extract_rows(table)
+      end
+
+      def parse
+        if with_headers?
+          parse_with_headers
+        else
+          parse_without_headers
+        end
+      end
+
+      private
+
+      def extract_rows(table)
+        return [] if table.nil? || table.empty?
+
+        table.split("\n").map(&:strip).reject(&:empty?)
+      end
+
+      def infer_headers
+        # At least 2 rows with the second being a separator
+        @markdown_rows.size >= 2 && Row.separator?(@markdown_rows[1])
+      end
+
+      def extract_header_values
+        Row.parse(@markdown_rows.first)
+      end
+
+      def with_headers?
+        # If headers flag is explicitly provided, use it
+        # Otherwise infer from the table structure
+        return @headers_flag unless @headers_flag.nil?
+
+        infer_headers
+      end
+
+      def parse_with_headers
+        return [[], []] if @markdown_rows.empty?
+
+        header_values = extract_header_values
+        rows = []
+
+        @markdown_rows.each_with_index do |row_string, index|
+          # Skip header row and separator row
+          next if index.zero? || Row.separator?(row_string)
+
+          values = Row.parse(row_string)
+          rows << Row.new(values, headers: header_values)
+        end
+
+        Tables::Base::Result.new(rows:, headers: header_values)
+      end
+
+      def parse_without_headers
+        rows = []
+
+        @markdown_rows.each do |row_string|
+          # Skip separator rows
+          next if Row.separator?(row_string)
+
+          # Parse the row into values
+          values = Row.parse(row_string)
+          rows << Row.new(values)
+        end
+
+        Tables::Base::Result.new(rows:, headers: nil)
+      end
+    end
+  end
+end

data/lib/marktable/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Marktable
+  VERSION = '0.1.1'
+end

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

@@ -4,152 +4,54 @@ 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 using Nokogiri
-  def parse_html_table(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 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