marktable 0.0.5 → 0.1.0

data/lib/marktable/row.rb

@@ -2,97 +2,109 @@
 
 module Marktable
   class Row
-    attr_reader :data, :headers
+    attr_reader :values, :headers
 
-    def initialize(data = {}, headers: nil)
+    def initialize(data, headers: nil)
       @headers = headers
-      
-      if data.is_a?(Hash)
-        # Ensure all hash values are strings
-        @data = data.transform_values(&:to_s)
-      elsif data.is_a?(Array)
-        # Ensure all array elements are strings
-        data_strings = data.map(&:to_s)
-        
-        @data = if headers && !headers.empty?
-          # Convert array to hash using headers
-          headers.each_with_index.each_with_object({}) do |(header, i), hash|
-            hash[header] = i < data_strings.length ? data_strings[i] : ''
-          end
+      @values = extract_values(data)
+    end
+
+    # Format the row as a markdown table row
+    def to_markdown(column_widths)
+      vals = @values
+
+      # Limit values to either headers count or column_widths size, whichever is appropriate
+      max_cols = @headers ? @headers.size : column_widths.size
+
+      formatted_values = column_widths.take(max_cols).map.with_index do |width, i|
+        if i < vals.size
+          vals[i].to_s.ljust(width)
         else
-          # Keep as array when no headers
-          data_strings
+          ''.ljust(width)
         end
-      else
-        @data = headers ? {} : []
       end
+
+      "| #{formatted_values.join(' | ')} |"
     end
 
+    # Access a value by index or header
     def [](key)
-      if @data.is_a?(Hash)
-        @data[key]
-      elsif key.is_a?(Integer) && key < @data.length
-        @data[key]
-      else
-        nil
+      if key.is_a?(Integer)
+        @values[key]
+      elsif @headers
+        idx = @headers.index(key)
+        idx ? @values[idx] : nil
       end
     end
 
+    # Set a value by index or header
     def []=(key, value)
-      if @data.is_a?(Hash)
-        @data[key] = value.to_s
-      elsif key.is_a?(Integer)
-        @data[key] = value.to_s
+      if key.is_a?(Integer)
+        @values[key] = value if key >= 0 && key < @values.size
+      elsif @headers
+        idx = @headers.index(key)
+        @values[idx] = value if idx && idx < @values.size
       end
     end
 
-    def values
-      @data.is_a?(Hash) ? @data.values : @data
-    end
-
-    def keys
-      @data.is_a?(Hash) ? @data.keys : (0...@data.size).to_a
-    end
-
-    def to_h
-      return @data if @data.is_a?(Hash)
-      return {} if @data.empty? || @headers.nil? || @headers.empty?
-      
-      @headers.each_with_index.each_with_object({}) do |(header, i), hash|
-        hash[header] = i < @data.length ? @data[i] : ''
-      end
+    # Check if this row uses headers
+    def headers?
+      !@headers.nil?
     end
 
-    def to_a
-      @data.is_a?(Array) ? @data : @data.values
-    end
+    # Convert row data to a hash using headers as keys
+    def to_hash
+      return {} unless @headers
 
-    # Convert a row to markdown format with specified column widths
-    def to_markdown(column_widths)
-      vals = values
-      formatted_values = vals.each_with_index.map do |val, i|
-        val.to_s.ljust(column_widths[i] || val.to_s.length)
+      result = {}
+      @values.each_with_index do |value, i|
+        # Only include values that have a corresponding header
+        if i < @headers.size
+          header = @headers[i]
+          result[header] = value if header
+        end
       end
-      "| #{formatted_values.join(' | ')} |"
+      result
     end
 
     # Parse a markdown row string into an array of values
     def self.parse(row_string)
-      row_string.strip.sub(/^\|/, '').sub(/\|$/, '').split('|').map(&:strip)
+      # Skip if nil or empty
+      return [] if row_string.nil? || row_string.strip.empty?
+
+      # Remove leading/trailing pipes and split by pipe
+      cells = row_string.strip.sub(/^\|/, '').sub(/\|$/, '').split('|')
+
+      # Trim whitespace from each cell
+      cells.map(&:strip)
     end
 
-    # Check if a row string represents a separator row
+    # Check if a row is a separator row
     def self.separator?(row_string)
-      row_string.strip.gsub(/[\|\-\s]/, '').empty?
+      # Skip if nil or empty
+      return false if row_string.nil? || row_string.strip.empty?
+
+      # Remove pipes and strip whitespace
+      content = row_string.gsub('|', '').strip
+
+      # Check if it contains only dashes and colons (separator characters)
+      content.match?(/^[\s:,-]+$/) && content.include?('-')
     end
 
-    # Generate a separator row for markdown table with specified widths
-    def self.separator_row(column_widths)
-      separators = column_widths.map do |width|
-        '-' * [3, width].max
+    private
+
+    def extract_values(data)
+      case data
+      when Hash
+        if @headers
+          @headers.map { |h| data[h] || '' }
+        else
+          data.values
+        end
+      else
+        # Array or other enumerable
+        Array(data)
       end
-      
-      ["| #{separators.join(' | ')} |", column_widths]
     end
   end
 end

data/lib/marktable/table.rb

@@ -1,154 +1,84 @@
 # frozen_string_literal: true
 
+require_relative 'formatters/base'
+
 module Marktable
   class Table
     include Enumerable
-    
+
     attr_reader :headers
 
-    def initialize(markdown_table = '', headers: true)
-      @headers = headers
-      @rows = []
-      @header_row = nil
-      parse_content(markdown_table) unless markdown_table.empty?
+    def initialize(source, type: :markdown, headers: nil)
+      parser = Tables::Base.for(type).new(source, headers)
+      result = parser.parse
+      @rows = result.rows
+      @headers = result.headers
+      # Validate headers if present
+      validate_headers if @headers
+      # Fix: Initialize @has_headers based on whether @headers is present
+      @has_headers = !@headers.nil?
     end
 
-    def each
-      if block_given?
-        @rows.each { |row| yield(row) }
-      else
-        @rows.each
-      end
-    end
+    # Iteration support
+    def each(&block)
+      return enum_for(:each) unless block_given?
 
-    def to_a
-      @rows.map { |row| row.data }
-    end
-
-    def to_s
-      generate
+      @rows.each(&block)
     end
 
-    def generate
-      return "" if @rows.empty?
-
-      # Extract header keys or use first row data for header
-      keys = header_keys
-      
-      # Calculate column widths considering both headers and all row values
-      all_values = [keys] + @rows.map { |row| row.values }
-      column_widths = calculate_column_widths(all_values)
-      
-      # Build the markdown table
-      build_markdown_table(keys, column_widths)
-    end
-
-    private
-
-    def header_keys
-      if @headers && @header_row
-        @header_row.keys
-      elsif @rows.first&.data.is_a?(Hash)
-        @rows.first.data.keys
+    # Returns the table as an Array of Hashes if headers are present
+    # or Array of Arrays if no headers
+    def to_a
+      if @has_headers
+        # Convert rows to hashes, which will automatically exclude values without headers
+        @rows.map(&:to_hash)
       else
-        @rows.first&.values || []
+        # When no headers, return array of arrays with consistent length
+        max_length = @rows.map { |row| row.values.length }.max || 0
+        @rows.map do |row|
+          values = row.values
+          values + Array.new(max_length - values.length, '')
+        end
       end
     end
 
-    def build_markdown_table(keys, column_widths)
-      result = []
-      
-      # Add header row
-      result << row_to_markdown(keys, column_widths)
-      
-      # Add separator row
-      separator, _ = Row.separator_row(column_widths)
-      result << separator
-      
-      # Add data rows
-      rows_to_render.each do |row|
-        result << row.to_markdown(column_widths)
-      end
-      
-      result.join("\n")
+    def to_html
+      Formatters::Base.for(:html).format(@rows, @headers)
     end
 
-    def rows_to_render
-      if !@headers && !@rows.first&.data.is_a?(Hash) && @rows.size > 1
-        @rows[1..-1]
-      else
-        @rows
-      end
+    # Generate markdown representation
+    def to_md
+      Formatters::Base.for(:markdown).format(@rows, @headers)
     end
+    alias generate to_md
 
-    def parse_content(markdown_table)
-      # Split content into rows
-      rows = markdown_table.split("\n").map(&:strip).reject(&:empty?)
-      return if rows.empty?
-
-      if @headers
-        parse_with_headers(rows)
-      else
-        parse_without_headers(rows)
-      end
+    # Generate CSV representation
+    def to_csv
+      Formatters::Base.for(:csv).format(@rows, @headers)
     end
 
-    def parse_with_headers(rows)
-      # Extract headers from first row
-      header_values = Row.parse(rows.first)
-      @header_row = header_values.each_with_object({}) { |val, hash| hash[val] = val }
-
-      # Process each data row
-      rows.each_with_index do |row, index|
-        # Skip header row and separator rows
-        next if index == 0 || Row.separator?(row)
-
-        # Parse the row into values
-        values = Row.parse(row)
-
-        # Create a hash mapping headers to values
-        row_hash = {}
-        header_values.each_with_index do |header, i|
-          row_hash[header] = i < values.length ? values[i] : ''
-        end
-
-        @rows << Row.new(row_hash, headers: header_values)
-      end
+    # Support for accessing by index like table[0]
+    def [](index)
+      @rows[index]
     end
 
-    def parse_without_headers(rows)
-      # When headers: false, store array of arrays
-      rows.each do |row|
-        # Skip separator rows
-        next if Row.separator?(row)
-
-        # Parse the row into values
-        values = Row.parse(row)
-        @rows << Row.new(values, headers: nil)
-      end
+    # Returns the number of rows
+    def size
+      @rows.size
     end
+    alias length size
 
-    # Calculate the maximum width of each column
-    def calculate_column_widths(arrays_of_values)
-      max_column_count = arrays_of_values.map { |row| row.size }.max || 0
-      column_widths = Array.new(max_column_count, 0)
-      
-      arrays_of_values.each do |row|
-        row.each_with_index do |cell, i|
-          cell_width = cell.to_s.length
-          column_widths[i] = [column_widths[i], cell_width].max
-        end
-      end
-      
-      column_widths
+    def empty?
+      @rows.empty?
     end
 
-    # Generate markdown row from array of values with proper spacing
-    def row_to_markdown(values, column_widths)
-      formatted_values = values.each_with_index.map do |val, i|
-        val.to_s.ljust(column_widths[i])
-      end
-      "| #{formatted_values.join(' | ')} |"
+    private
+
+    def validate_headers
+      duplicates = @headers.group_by { |h| h }.select { |_, v| v.size > 1 }.keys
+      return unless duplicates.any?
+
+      raise ArgumentError, "Duplicate headers are not allowed: #{duplicates.join(', ')}"
     end
   end
 end

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.0'
+end