marktable 0.0.5 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a3e8c1a76daf4c3d03f628200baabad28e31008e444522fb2d6c7337f623bdd8
-  data.tar.gz: c83d7b0a83b21c2c292d5a76963f626ddeae5bebca42363f227f6bf65fed6dc2
+  metadata.gz: 776f59a6e0c0ee0b8e52f3fd4b9dd7a8ae8e1acbb93ff98504bb382dfecc93e9
+  data.tar.gz: 8df1d4b723562ced9f83e172165ed07d934e95fe2d9fe7c39411371b960dadfb
 SHA512:
-  metadata.gz: f0f766d34db37402b6d4cbb52e37a1e33172175c5ba622051ce9899ded65de3c9fa045f7d21a234c9fc03856bfaefcf7b9b8d5f1fb346bd0c47efbee87e86236
-  data.tar.gz: 1a34281c031a0c47da3ff074f6206304fc569663a04ffab9246bd12a137eb7fd53a6745415991d6530d384f67e05eca480db02bdd9c49122687a9ae820475037
+  metadata.gz: ed5b2e94ca382771d81d5c6423fa43e38dded1cbfe315c6fedd098b0f77efc66d18b7e62372f8ac2e16884a3d3495f5631fee13b96623d8575276e8b6827b619
+  data.tar.gz: 28d859a6e6c1709ee0be5c3ff7f63fd91f87688d6c5169d0193790889e590ce4b0602afa7c1a5f48693227bf963cca9396a26900f037899351d4c54c69783833

data/README.md

@@ -1,6 +1,24 @@
 # Marktable
 
-Marktable is a Ruby gem for ...
+Marktable is a Ruby gem for easily converting between different table formats and testing table content in your specs.
+
+## Table of Contents
+
+- [Features](#features)
+- [Installation](#installation)
+- [Basic Usage](#basic-usage)
+- [Documentation](#documentation)
+- [License](#license)
+
+## Features
+
+* RSpec matchers to compare tables across formats
+* Convert between multiple table formats:
+  - Markdown tables
+  - Arrays of arrays
+  - Arrays of hashes
+  - CSV
+  - HTML tables
 
 ## Installation
 
@@ -12,23 +30,59 @@ gem 'marktable'
 
 And then execute:
 
-```bash
-bundle install
+```
+$ bundle install
+```
+
+Or install it yourself:
+
+```
+$ gem install marktable
 ```
 
-Or install it yourself as:
+## Basic Usage
 
-```bash
-gem install marktable
+### RSpec Matchers
+
+```ruby
+# In your spec_helper.rb
+require 'marktable/rspec'
+
+# In your specs - compare tables across formats
+expect(markdown_table).to match_markdown(expected_markdown)
+
+html_table = page.find('#users-table')
+expect(html_table).to match_markdown(expected_markdown)
 ```
 
-## Usage
+### Converting Between Formats
 
 ```ruby
-require 'marktable'
-# Example usage here
+# From markdown to other formats
+markdown = <<~MARKDOWN
+  | Name | Age  |
+  |------|----- |
+  | Alice | 30  |
+  | Bob   | 25  |
+MARKDOWN
+
+table = Marktable.from_markdown(markdown)
+
+table.to_a # Array of hashes
+table.to_csv # CSV string
+table.to_html # HTML table
+
+# From arrays or hashes to markdown
+data = [{ 'Name' => 'Alice', 'Age' => '30' }]
+Marktable.from_array(data).to_md # Markdown table
 ```
 
-## Development
+## Documentation
+
+* [Full Examples](docs/examples.md) - Detailed usage examples
+* [API Documentation](docs/api_documentation.md) - Complete API reference
+
+## License
 
-After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests.
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+`

data/lib/marktable/formatters/base.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require_relative 'markdown'
+# require_relative "array"
+require_relative 'csv'
+require_relative 'html'
+
+module Marktable
+  module Formatters
+    class Base
+      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
+    end
+  end
+end

data/lib/marktable/formatters/csv.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require 'csv'
+
+module Marktable
+  module Formatters
+    class CSV
+      def self.format(rows, headers = nil)
+        return '' if rows.empty? && headers.nil?
+
+        ::CSV.generate do |csv|
+          csv << headers if headers
+          rows.each do |row|
+            csv << format_row(row)
+          end
+        end
+      end
+
+      def self.format_row(row)
+        row.values.map { |val| val unless val.to_s.empty? }
+      end
+    end
+  end
+end

data/lib/marktable/formatters/html.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require 'nokogiri'
+
+module Marktable
+  module Formatters
+    class HTML
+      def self.format(rows, headers = nil)
+        return '' if rows.empty? && headers.nil?
+
+        builder = Nokogiri::HTML::Builder.new do |doc|
+          doc.table do
+            if headers
+              doc.thead do
+                doc.tr do
+                  headers.each do |header|
+                    doc.th { doc.text header }
+                  end
+                end
+              end
+            end
+
+            doc.tbody do
+              rows.each do |row|
+                doc.tr do
+                  row.values.each do |cell|
+                    doc.td do
+                      cell_text = cell.to_s
+                      if cell_text.include?('\n')
+                        cell_text.split('\n').each_with_index do |line, index|
+                          doc.br if index.positive?
+                          doc.text line
+                        end
+                      else
+                        doc.text cell_text
+                      end
+                    end
+                  end
+                end
+              end
+            end
+          end
+        end
+
+        # Extract just the table element to avoid including DOCTYPE
+        builder.doc.at_css('table').to_html
+      end
+    end
+  end
+end

data/lib/marktable/formatters/markdown.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module Marktable
+  module Formatters
+    class Markdown
+      def self.format(rows, headers = nil)
+        return '' if rows.empty? && headers.nil?
+
+        # Calculate column widths
+        widths = calculate_column_widths(rows, headers)
+
+        lines = []
+
+        # Add header row if we have headers
+        if headers
+          lines << Row.new(headers).to_markdown(widths)
+          lines << separator_row(widths)
+        end
+
+        # Add data rows
+        rows.each do |row|
+          lines << row.to_markdown(widths)
+        end
+
+        lines.join("\n")
+      end
+
+      def self.calculate_column_widths(rows, headers)
+        # Determine the maximum number of columns to consider
+        max_cols = headers ? headers.size : 0
+
+        if headers.nil?
+          # Without headers, find the maximum number of values across all rows
+          rows.each do |row|
+            max_cols = [max_cols, row.values.size].max
+          end
+        end
+
+        # Initialize widths array with zeros
+        widths = Array.new(max_cols, 0)
+
+        # Process headers if available
+        headers&.each_with_index do |header, i|
+          width = header.to_s.length
+          widths[i] = width if width > widths[i]
+        end
+
+        # Process row values, but only up to the max_cols
+        rows.each do |row|
+          values = row.values.take(max_cols)
+          values.each_with_index do |value, i|
+            width = value.to_s.length
+            widths[i] = width if width > widths[i]
+          end
+        end
+
+        widths
+      end
+
+      def self.separator_row(widths)
+        separator_parts = widths.map { |width| '-' * width }
+        "| #{separator_parts.join(' | ')} |"
+      end
+    end
+  end
+end

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