marktable 0.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 662b8c0026118b8a9a8cbfcefc4e22ca2d245020672b04e9dc17e923356b60cd
+  data.tar.gz: 1307c073aeea515d89ee1e40c5d3a6753f6de815c7ae2f72f1ed042c9a733436
+SHA512:
+  metadata.gz: 8fe53f45c22f224efece661fcdbcd4fbd61426211f331d592e93dfa33953344b64e73b1d8558d5640f01fd13d67f71f80fc63c42e55b7212f6326da7497911b4
+  data.tar.gz: e50d5d8cc11159dd809adb47b4f44a71116dab221a70b1c7a73495f7c4377601a6f7a59dc1afef9b67e7943758a86adaa1006460f02f4fe0f55fe9bd5387237d

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Your Name
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,34 @@
+# Marktable
+
+Marktable is a Ruby gem for ...
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'marktable'
+```
+
+And then execute:
+
+```bash
+bundle install
+```
+
+Or install it yourself as:
+
+```bash
+gem install marktable
+```
+
+## Usage
+
+```ruby
+require 'marktable'
+# Example usage here
+```
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests.

data/lib/marktable/row.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+module Marktable
+  class Row
+    attr_reader :data, :headers
+
+    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
+        else
+          # Keep as array when no headers
+          data_strings
+        end
+      else
+        @data = headers ? {} : []
+      end
+    end
+
+    def [](key)
+      if @data.is_a?(Hash)
+        @data[key]
+      elsif key.is_a?(Integer) && key < @data.length
+        @data[key]
+      else
+        nil
+      end
+    end
+
+    def []=(key, value)
+      if @data.is_a?(Hash)
+        @data[key] = value.to_s
+      elsif key.is_a?(Integer)
+        @data[key] = value.to_s
+      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
+    end
+
+    def to_a
+      @data.is_a?(Array) ? @data : @data.values
+    end
+
+    # 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)
+      end
+      "| #{formatted_values.join(' | ')} |"
+    end
+
+    # Parse a markdown row string into an array of values
+    def self.parse(row_string)
+      row_string.strip.sub(/^\|/, '').sub(/\|$/, '').split('|').map(&:strip)
+    end
+
+    # Check if a row string represents a separator row
+    def self.separator?(row_string)
+      row_string.strip.gsub(/[\|\-\s]/, '').empty?
+    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
+      end
+      
+      ["| #{separators.join(' | ')} |", column_widths]
+    end
+  end
+end

data/lib/marktable/table.rb

@@ -0,0 +1,154 @@
+# frozen_string_literal: true
+
+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?
+    end
+
+    def each
+      if block_given?
+        @rows.each { |row| yield(row) }
+      else
+        @rows.each
+      end
+    end
+
+    def to_a
+      @rows.map { |row| row.data }
+    end
+
+    def to_s
+      generate
+    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
+      else
+        @rows.first&.values || []
+      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")
+    end
+
+    def rows_to_render
+      if !@headers && !@rows.first&.data.is_a?(Hash) && @rows.size > 1
+        @rows[1..-1]
+      else
+        @rows
+      end
+    end
+
+    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
+    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
+    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
+    end
+
+    # 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
+    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(' | ')} |"
+    end
+  end
+end

data/lib/marktable.rb

@@ -0,0 +1,136 @@
+# frozen_string_literal: true
+
+require_relative 'marktable/row'
+require_relative 'marktable/table'
+
+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)
+  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
+  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)
+  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)
+  end
+end

metadata

@@ -0,0 +1,60 @@
+--- !ruby/object:Gem::Specification
+name: marktable
+version: !ruby/object:Gem::Version
+  version: 0.0.2
+platform: ruby
+authors:
+- Francois Gaspard
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+description: Provides a row-based object model and utility methods for creating, parsing,
+  transforming, and exporting Markdown tables in Ruby.
+email:
+- fr@ncois.email
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- lib/marktable.rb
+- lib/marktable/row.rb
+- lib/marktable/table.rb
+homepage: https://github.com/Francois-gaspard/marktable
+licenses:
+- MIT
+metadata: {}
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.4'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.7
+specification_version: 4
+summary: Read, write, parse, and filter Markdown tables easily.
+test_files: []