marktable 0.1.0 → 0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f4dc7dda731d7cbac0c2b155c3c572c44954ca2f65281f3cf976b05ba9cd1532
-  data.tar.gz: 1261f5a0afd0bbf45a16d8e9d369ef61b8e9313e83788a1b5e10be8871fac962
+  metadata.gz: e7f873538494ff9b1c7c9a5f74b25560c0a329e13ae77ab2648cedbe46dba1e7
+  data.tar.gz: 0bfc592905ad86578cf9fcfd953ffd589aebada3120d1f460e0c61818a5bea44
 SHA512:
-  metadata.gz: 8127ab236b08a55f8d8d2fafcb116996d347527085af2dc1e71632b55930d326eae6e6b8bbac2e55c33965effa4d14863b4741e80c70297b2079bf715153dab6
-  data.tar.gz: 8400c3fbb70a9330d2db6c36f23599161ae35e4766c614597f773f38305ae9bf62708d053477d5e727d7cf51dee76490bb23743c0c77aca76a4a87997795e9be
+  metadata.gz: da0ff6b0f29523c3b7cd99d31fe08d4cf0c79fb52bca4eb2603096396c560cf1734bf33b21990ba449c73a3b476d71d9985c62e743e8cd3525bd72d45c605937
+  data.tar.gz: cb6f9e8813e96393110f52a591d7a61a5b4e66d407db33fee2a8a52f347a934cb9586838d801195248b441b8999cee817819bfda83410faf7db0ff48d2738d0b

data/README.md

@@ -1,27 +1,26 @@
 # Marktable
 
+Marktable is a Ruby gem for easily converting between different table formats and testing table content in your specs.
 
-A powerful Ruby library for parsing, manipulating, and generating Markdown tables with an elegant and intuitive API.
+## Table of Contents
 
-## 📚 Overview
+- [Features](#features)
+- [Installation](#installation)
+- [Basic Usage](#basic-usage)
+- [Documentation](#documentation)
+- [License](#license)
 
-Marktable allows you to seamlessly work with Markdown tables using familiar Ruby data structures. Whether you're parsing tables from Markdown documents, generating tables for documentation, or manipulating tabular data, Marktable provides simple yet powerful tools for all your Markdown table needs.
+## Features
 
-## ✨ Features
+* RSpec matchers to compare tables across formats
+* Convert between multiple table formats:
+  - Markdown tables
+  - Arrays of arrays
+  - Arrays of hashes
+  - CSV
+  - HTML tables
 
-- **Custom RSpec matcher** for testing Markdown-like data structures (including html tables) against expected Markdown output
-- **Parse** Markdown tables into Ruby data structures (arrays or hashes)
-- **Generate** beautifully formatted Markdown tables from Ruby objects
-- **Filter** and **transform** table data with Ruby's familiar block syntax
-- **Auto-detect** headers from properly formatted Markdown tables
-- **Handle** tables with or without headers
-- **Support** for mismatched columns and keys in data
-- **Convert** between array-based and hash-based representations
-
-## Not supported
-- Non-string values (E.g. complex objects) in the table rows. 
-
-## 📦 Installation
+## Installation
 
 Add this line to your application's Gemfile:
 
@@ -31,343 +30,59 @@ gem 'marktable'
 
 And then execute:
 
-```bash
-bundle install
-```
-
-Or install it yourself as:
-
-```bash
-gem install marktable
-```
-
-## 🚀 Quick Start
-
-### Main use case (Rspec only at this time)
-
-This gem started as a pet project aiming at:
-- Simplifying the process of testing html table content
-- Making these specs more developer-friendly, with a very readable format
-
-
-```ruby
-visit my_path
-actual_table = page.find('#my-table')
-expected_table = <<~MARKDOWN
-  | Name  | Age | City     |
-  | ----- | --- | -------- |
-  | John  | 30  | New York |
-  | Jane  | 25  | Boston   |
-  | Bob   | 17  | Chicago  |
-MARKDOWN
-
-expect(actual_table).to match_markdown(expected_table)
-```
-
-In case of semantical mismatch, the matcher will show an easy to verify markdown representation of the tables:
-
-```markdown
-        Expected markdown table to match:
-        
-        Expected:
-        | Name  | Age | City     |
-        | ----- | --- | -------- |
-        | John  | 30  | New York |
-        | Jane  | 25  | Boston   |
-        | Bob   | 17  | Chicago  |
-        
-        Actual:
-        | Name | Age |
-        | ---- | --- |
-        | John | 31  |
-        | Jane | 25  |
-        
-        Parsed expected data: [{"Name" => "John", "Age" => "30"}, {"Name" => "Jane", "Age" => "25"}, {"Name" => "Bob", "Age" => "17"}]
-        Parsed actual data: [{"Name" => "John", "Age" => "31"}, {"Name" => "Jane", "Age" => "25"}]
 ```
-
-
-
-### Parsing a Markdown Table
-
-```ruby
-require 'marktable'
-
-markdown_table = <<~MARKDOWN
-  | Name  | Age | City     |
-  | ----- | --- | -------- |
-  | John  | 30  | New York |
-  | Jane  | 25  | Boston   |
-MARKDOWN
-
-# Parse into an array of hashes (with auto-detected headers)
-data = Marktable.parse(markdown_table)
-# => [
-#      {"Name"=>"John", "Age"=>"30", "City"=>"New York"},
-#      {"Name"=>"Jane", "Age"=>"25", "City"=>"Boston"}
-#    ]
-
-# Access data easily
-puts data.first["Name"]  # => "John"
+$ bundle install
 ```
 
-### Generating a Markdown Table
-
-```ruby
-# Create a new table and add rows
-table = Marktable.generate do |t|
-  t << {"Name" => "John", "Age" => "30", "City" => "New York"}
-  t << {"Name" => "Jane", "Age" => "25", "City" => "Boston"}
-  t << {"Name" => "Bob", "Age" => "17", "City" => "Chicago"}
-end
+Or install it yourself:
 
-puts table
-# | Name | Age | City     |
-# | ---- | --- | -------- |
-# | John | 30  | New York |
-# | Jane | 25  | Boston   |
-# | Bob  | 17  | Chicago  |
 ```
-
-## 📖 Usage Guide
-
-### Working with Table Objects
-
-Create a table object for more advanced operations:
-
-```ruby
-# Create from a markdown string
-table = Marktable.new(markdown_table)
-
-# Or create from array data
-array_data = [
-  ["Name", "Age", "City"],
-  ["John", "30", "New York"],
-  ["Jane", "25", "Boston"],
-  ["Bob", "17", "Chicago"]
-]
-table = Marktable.new(array_data, headers: true)
-
-# Or with auto-detected headers
-array_data = [
-  { "Name" => "John", "Age" => "30", "City" => "New York" },
-  { "Name" => "Jane", "Age" => "25", "City" => "Boston" },
-  { "Name" => "Bob", "Age" => "17", "City" => "Chicago" }
-]
-table = Marktable.new(array_data)
+$ gem install marktable
 ```
 
-### Filtering Rows
+## Basic Usage
 
-Filter rows using pattern matching or blocks:
-
-```ruby
-# Filter with a regex pattern
-nyc_residents = table.filter(/New York/)
-
-# Filter with a block
-adults = table.filter do |row|
-  row["Age"].to_i >= 18
-end
-
-puts adults
-# | Name | Age | City     |
-# | ---- | --- | -------- |
-# | John | 30  | New York |
-# | Jane | 25  | Boston   |
-```
-
-### Transforming Data
-
-Transform table data with the map method:
-
-```ruby
-# Add 5 years to everyone's age
-older = table.map do |row|
-  row.merge("Age" => (row["Age"].to_i + 5).to_s)
-end
-
-puts older
-# | Name | Age | City     |
-# | ---- | --- | -------- |
-# | John | 35  | New York |
-# | Jane | 30  | Boston   |
-# | Bob  | 22  | Chicago  |
-```
-
-### Working with Arrays
-
-Use arrays instead of hashes for row data:
-
-```ruby
-# Create a table with array rows
-table = Marktable.new([], headers: false)
-table << ["John", "30", "New York"]
-table << ["Jane", "25", "Boston"]
-
-puts table
-# | John | 30  | New York |
-# | Jane | 25  | Boston   |
-```
-
-### Mixed Row Types
-
-Marktable can handle mixed row types (arrays and hashes):
-
-```ruby
-table = Marktable.generate do |t|
-  t << {"Name" => "John", "Age" => "30", "City" => "New York"}
-  t << ["Jane", "25", "Boston"]  # Array with same column count
-end
-
-puts table
-# | Name | Age | City     |
-# | ---- | --- | -------- |
-# | John | 30  | New York |
-# | Jane | 25  | Boston   |
-```
-
-## 🧪 Testing with Custom Matchers
-
-Marktable includes a custom RSpec matcher, `match_markdown`, to make testing Markdown-compatible data structures simple and reliable.
-
-### Using the `match_markdown` Matcher
-
-First, require the matcher in your spec_helper.rb or in the specific test file:
+### RSpec Matchers
 
 ```ruby
+# In your spec_helper.rb
 require 'marktable/rspec'
-```
 
-#### Testing Markdown Table Output
+# In your specs - compare tables across formats
+expect(markdown_table).to match_markdown(expected_markdown)
 
-```ruby
-RSpec.describe ReportGenerator do
-  describe "#generate_customer_table" do
-    it "generates the expected customer table" do
-      actual = ReportGenerator.new(customers).generate_table
-      # Presume actual contains:
-      # [
-      #   { id: 1, name: "John Smith", status: "Active" },
-      #   { id: 2, name: "Jane Doe", status: "Pending" }
-      # ]
-      
-      expected = <<~MARKDOWN
-        | ID | Name       | Status  |
-        | -- | ---------- | ------- |
-        | 1  | John Smith | Active  |
-        | 2  | Jane Doe   | Pending |
-      MARKDOWN
-      
-      expect(result).to match_markdown(expected)
-    end
-  end
-end
+html_table = page.find('#users-table')
+expect(html_table).to match_markdown(expected_markdown)
 ```
 
-#### Testing HTML Table Output
-
-The `match_markdown` matcher can also compare HTML tables by extracting their semantic content:
+### Converting Between Formats
 
 ```ruby
-RSpec.describe HtmlReportGenerator do
-  describe "#generate_sales_report" do
-    it "generates the expected HTML table" do
-      sales_data = [
-        { product: "Widget A", quantity: 150, revenue: "$3,000" },
-        { product: "Widget B", quantity: 75, revenue: "$1,875" }
-      ]
-      
-      generator = HtmlReportGenerator.new(sales_data)
-      html_output = generator.generate_sales_report
-      
-      # The matcher extracts the data structure from both the HTML and expected markdown
-      expected = <<~MARKDOWN
-        | Product  | Quantity | Revenue |
-        | -------- | -------- | ------- |
-        | Widget A | 150      | $3,000  |
-        | Widget B | 75       | $1,875  |
-      MARKDOWN
-      
-      # This will pass even though one is HTML and one is Markdown!
-      expect(html_output).to match_markdown(expected)
-    end
-  end
-end
-```
+# From markdown to other formats
+markdown = <<~MARKDOWN
+  | Name  | Age |
+  |------ | --- |
+  | Alice | 30  |
+  | Bob   | 25  |
+MARKDOWN
 
-#### Testing API JSON Responses
+table = Marktable.from_markdown(markdown)
 
-The matcher is also helpful when testing APIs that return tabular data:
+table.to_a # Array of hashes
+table.to_csv # CSV string
+table.to_html # HTML table
 
-```ruby
-RSpec.describe "Products API" do
-  describe "GET /api/products" do
-    it "returns products in the expected format" do
-      # Setup test data and make request
-      get "/api/products"
-      
-      # Parse JSON response
-      json_response = JSON.parse(response.body)
-      
-      # Convert API response to a table
-      table = Marktable.new(json_response)
-      
-      expected = <<~MARKDOWN
-        | id | name        | category | price  |
-        | -- | ----------- | -------- | ------ |
-        | 1  | Product One | Books    | $19.99 |
-        | 2  | Product Two | Games    | $59.99 |
-      MARKDOWN
-      
-      expect(table).to match_markdown(expected)
-    end
-  end
-end
+# From arrays or hashes to markdown
+data = [{ 'Name' => 'Alice', 'Age' => '30' }]
+Marktable.from_array(data).to_md # Markdown table
 ```
 
-The `match_markdown` matcher compares tables semantically rather than character-by-character, which means:
-
-- It ignores differences in whitespace padding
-- It handles different column ordering in hash-based tables
-- It works with both HTML and Markdown table formats
-- It provides clear error messages showing the differences between tables
-
-## 📋 API Reference
-
-### Class Methods
-
-- `Marktable.parse(table, headers: nil)` - Parse table string or array into an array of hashes/arrays
-- `Marktable.new(table, headers: nil)` - Create a new Table object
-- `Marktable.parse_line(row)` - Parse a single markdown row into an array
-- `Marktable.generate { |t| ... }` - Generate a table with a block
-
-### Instance Methods
-
-- `table.to_a` - Convert table to array of hashes/arrays
-- `table.to_s` / `table.generate` - Generate markdown representation
-- `table.empty?` - Check if table is empty
-- `table.column_count` - Get column count
-- `table << row_data` - Add a row to the table
-- `table.filter(pattern = nil) { |row| ... }` - Filter rows by pattern or block
-- `table.map { |row| ... }` - Transform rows with a block
-
-## 🧪 Development
-
-After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
-
-To install this gem onto your local machine, run `bundle exec rake install`.
-
-## 🤝 Contributing
-
-Bug reports and pull requests are welcome on GitHub at https://github.com/yourusername/marktable. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [code of conduct](https://github.com/yourusername/marktable/blob/main/CODE_OF_CONDUCT.md).
+## Documentation
 
-1. Fork the repository
-2. Create your feature branch: `git checkout -b my-new-feature`
-3. Commit your changes: `git commit -am 'Add some feature'`
-4. Push to the branch: `git push origin my-new-feature`
-5. Submit a pull request
+* [Full Examples](docs/examples.md) - Detailed usage examples
+* [API Documentation](docs/api_documentation.md) - Complete API reference
 
-## 📄 License
+## License
 
 The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+`

data/lib/marktable/formatters/html.rb

@@ -23,7 +23,7 @@ module Marktable
             doc.tbody do
               rows.each do |row|
                 doc.tr do
-                  row.each_value do |cell|
+                  row.values.each do |cell|
                     doc.td do
                       cell_text = cell.to_s
                       if cell_text.include?('\n')

data/lib/marktable/rspec/init.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require_relative '../rspec'

data/lib/marktable/rspec.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+require 'capybara'
+require 'nokogiri'
+require 'marktable'
+
+# Register the matchers if RSpec is defined
+if defined?(RSpec)
+  RSpec::Matchers.define :match_markdown do |expected_markdown|
+    chain :with_format do |format|
+      @format = format
+    end
+
+    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
+      "Expected markdown tables to differ, but they match:\n\n" \
+      "#{@actual_data.to_md}"
+    end
+
+    private
+
+    def parse_input(input, format = nil)
+      return input if input.is_a?(Marktable::Table)
+
+      # Handle both Capybara::Node::Element and Capybara::Node::Simple
+      if capybara?(input)
+        # Convert Capybara element to Nokogiri element or HTML
+        input = input.native
+        format = :html
+      end
+
+      # Handle Nokogiri elements
+      if nokogiri?(input)
+        input = input.to_html
+        format = :html
+      end
+
+      Marktable::Table.new(input, type: format)
+    end
+
+    def html?(data)
+      nokogiri?(data) || capybara?(data)
+    end
+
+    def capybara?(data)
+      defined?(Capybara::Node::Base) && data.is_a?(Capybara::Node::Base) ||
+        defined?(Capybara::Node::Simple) && data.is_a?(Capybara::Node::Simple) ||
+        defined?(Capybara::Node::Element) && data.is_a?(Capybara::Node::Element)
+    end
+
+    def nokogiri?(data)
+      defined?(Nokogiri::XML::Node) && data.is_a?(Nokogiri::XML::Node)
+    end
+
+    def infer_format(data)
+      case data
+      when Array
+        :array
+      when CSV::Table
+        :csv
+      when Marktable::Table
+        :markdown
+      when html?(data)
+        :html
+      else
+        :markdown
+      end
+    end
+
+    def format_failure_message(expected_data, actual_data)
+      "Expected markdown table to match:\n\n" \
+      "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
+end

data/lib/marktable/tables/html.rb

@@ -14,7 +14,7 @@ module Marktable
       end
 
       def parse
-        return blank if table.nil? || rows.empty?
+        return Tables::Base.blank if table.nil? || rows.empty?
 
         if has_headers?
           headers = extract_row_cells(first_row)
@@ -48,7 +48,31 @@ module Marktable
       end
 
       def extract_row_cells(row)
-        row.css('th, td').map(&:text)
+        row.css('th, td').map do |cell|
+          # Get text content
+          text = cell.text
+          
+          # Handle JSON content specially to preserve important whitespace
+          if text.include?('{') && text.include?('}')
+            # Process JSON content more carefully
+            # 1. Remove newlines
+            # 2. Preserve spaces between JSON delimiters
+            # 3. Normalize other whitespace
+            json_content = text.gsub(/\r?\n/, ' ')        # Replace newlines with spaces
+                              .gsub(/(\{)\s*/, '\1 ')     # Ensure exactly one space after opening brace
+                              .gsub(/\s*(\})/, ' \1')     # Ensure exactly one space before closing brace
+                              .gsub(/\s+/, ' ')           # Collapse other consecutive whitespace
+                              .gsub(/\A\s+|\s+\z/, '')    # Trim leading/trailing whitespace
+                              .gsub(/\u00A0/, ' ')        # Replace   with spaces
+            json_content
+          else
+            # For regular content
+            text.gsub(/\r?\n/, '')          # Remove all newlines completely
+                .gsub(/\s+/, ' ')           # Collapse consecutive whitespace
+                .gsub(/\A\s+|\s+\z/, '')    # Trim leading/trailing whitespace
+                .gsub(/\u00A0/, ' ')        # Replace   with spaces
+          end
+        end
       end
 
       def first_row

data/lib/marktable/version.rb

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

data/lib/marktable.rb

@@ -22,3 +22,5 @@ module Marktable
     Table.new(table, type: :html)
   end
 end
+
+require_relative 'marktable/rspec' if defined?(RSpec) || defined?(::RSpec::Core)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: marktable
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.2
 platform: ruby
 authors:
 - Francois Gaspard
@@ -67,6 +67,8 @@ files:
 - lib/marktable/formatters/html.rb
 - lib/marktable/formatters/markdown.rb
 - lib/marktable/row.rb
+- lib/marktable/rspec.rb
+- lib/marktable/rspec/init.rb
 - lib/marktable/table.rb
 - lib/marktable/tables/array.rb
 - lib/marktable/tables/base.rb
@@ -74,7 +76,6 @@ files:
 - 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:
 - MIT

data/spec/support/matchers/markdown_matchers.rb

@@ -1,57 +0,0 @@
-# frozen_string_literal: true
-
-require 'capybara'
-require 'nokogiri'
-
-RSpec::Matchers.define :match_markdown do |expected_markdown|
-  chain :with_format do |format|
-    @format = format
-  end
-
-  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
-    "Expected markdown tables to differ, but they match:\n\n" \
-    "#{@actual_data.to_md}"
-  end
-
-  private
-
-  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
-      :markdown
-    else
-      :markdown
-    end
-  end
-
-  def format_failure_message(expected_data, actual_data)
-    "Expected markdown table to match:\n\n" \
-    "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