rtables 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 476b203d969073a14520ac1ea98765e688b211f5
+  data.tar.gz: 0b6436a04b12f9ca02d6f36653fec415cf19a917
+SHA512:
+  metadata.gz: fc21c375f9d192b9e50bc8dd2703298b65ba5e431df8544b6816911cf7d8a0bc520da5e0518422bf5c3a46bb2a8c5af5a17f04ab6add3ad04ca2fc0cb920e38e
+  data.tar.gz: 3ff2f50aed25777364d30e22238428ead2e851f117206fd52b2d9af29a4ea46469088a149d443f8c3c30aaed8c71a6be98330458cda431196233dbdc85feb39b

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 Jos 'Zarthus' Ahrens
+
+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,50 @@
+# Ruby Tables
+
+RTables (Ruby Tables) is a small library that helps you generate table output in various predefined formats.
+
+## Installation
+
+To install RTables, you can either `git clone` the GitHub repository, or simply run `gem install rtables`
+
+## Example Code
+
+```ruby
+require 'rtables'
+
+# Initialize the table you wish to use.
+table = RTables::Table::PlainTable.new
+
+# Add the table headers to the table. This will structure our table.
+table.add_column('Example')
+table.add_column('Second Column')
+
+# Start adding rows to the table.
+# For each column you have added, you need to pass another parameter.
+table.add_row('Hello', 'World!')
+table.add_row('Another day', 'Another row!')
+table.add_row('It\'s a beautiful day to be a table', 'Indeed.')
+
+# The final step, we either .render or .to_s our table.
+#  .render returns a line-separated array,
+#  .to_s calls render.join("\n").
+puts table.to_s
+```
+
+## Picking the right table format
+
+Tables are nice, but each table has their positive and negative things.
+
+The [documentation](docs/tables) explains the cons and pros of each table.
+
+## Support
+
+There are two primary means of support.
+
+- Leave an [issue](https://github.com/zarthus/rtables/issues/new) on the [GitHub Repository](https://github.com/zarthus/rtables)
+- Alternatively, you may ask your question through IRC on [EsperNet in #zarthus](https://webchat.esper.net?channels=zarthus)
+
+To allow us to help you, we suggest you seek out [the documentation](docs) and [contributing](CONTRIBUTING.md) files first.
+
+## License
+
+RTables is licensed under the [MIT license](LICENSE)

data/docs/making_your_own_table.md

@@ -0,0 +1,61 @@
+# Making your own table
+
+Making your own table is very easy.
+
+Your table needs to meet the following two conditions:
+
+- Extend `RTables::TableBuilder`
+- Have a `render` method that returns an array of lines.
+  - May call `raise_if_empty` in `render` to generate a `TableFormatError` when there is no content.
+
+Tables can make use of the following data included from `RTables::TableBuilder`:
+
+- `@columns` and `@rows` integer values with the number of columns and rows.
+- `@table_header` - an array of all columns.
+- `@table_content` - a list of arrays with table content.
+
+Refer to any of the existing tables for guidance on how you could use this to your benefit.
+
+## What it should roughly look like
+
+```ruby
+require 'rtables/tablebuilder'
+
+class MyTable < RTables::TableBuilder
+  def render
+    raise_if_empty
+
+    lines = []
+    i = 0
+
+    @table_content.each do |content|
+      line = []
+      @table_header.each do |header|
+        line << "#{header}: #{content[i]}"
+        i += 1
+      end
+      lines << line.join(', ')
+      i = 0
+    end
+
+    lines
+  end
+end
+
+# Elsewhere, where you need the table.
+table = MyTable.new
+
+table.add_column('First Name')
+table.add_column('Last Name')
+
+table.add_row('Max', 'Caulfield')
+table.add_row('Chloe', 'Price')
+
+puts table.to_s
+```
+
+Output:
+```
+First Name: Max, Last Name: Caulfield
+First Name: Chloe, Last Name: Price
+```

data/docs/tables/MonoTable.md

@@ -0,0 +1,42 @@
+# Small Monospace Table
+
+Code:
+
+```ruby
+require 'rtables/table/monotable'
+table = RTables::Table::MonoTable.new
+
+table.add_column('Example')
+table.add_column('Field')
+table.add_row('First', 'This is an example text')
+table.add_row('Small', 'Field')
+table.add_row('Very Large Field', 'With a large amount of text on it.')
+
+table.render
+```
+
+Looks like:
+
+```
++---------+------------------------------------+
+| Example | First                              |
+| Field   | This is an example text            |
++---------+------------------------------------+
+| Example | Small                              |
+| Field   | Field                              |
++---------+------------------------------------+
+| Example | Very Large Field                   |
+| Field   | With a large amount of text on it. |
++---------+------------------------------------+
+```
+
+## Positives
+
+- Easy to read
+- Perfect for key => value display
+
+## Negatives
+
+- Requires a Monospace font to render properly.
+- If field names are too long the table will look strange.
+  - Table::MonoTable solves this by making use of [`BigMonoTable`](BigMonoTable.md) dynamically when the content is too big.

data/docs/tables_in_2_minutes.md

@@ -0,0 +1,83 @@
+# Building a table
+
+A table exists of two components. Columns, and rows.
+
+In your source code, you will define the columns before adding any rows.
+
+Given the following example:
+```ruby
+require 'rtables'
+
+# Initialize the table you wish to use.
+table = RTables::Table::TableName.new
+
+# Add the table headers to the table. This will structure our table.
+table.add_column('Example')
+table.add_column('Second Column')
+
+# Start adding rows to the table.
+# For each column you have added, you need to pass another parameter.
+table.add_row('Hello', 'World!')
+table.add_row('Another day', 'Another row!')
+table.add_row('It\'s a beautiful day to be a table', 'Indeed.')
+
+# The final step, we either .render or .to_s our table.
+#  .render returns a line-separated array,
+#  .to_s calls render.join("\n").
+puts table.to_s
+```
+
+The following output may be generated:
+
+```
+# PlainTable - the most boring table, but also the one that is the most consistent
+
+Column: Row1 Value1, Column2: Row1 Value2, ...
+Column: Row2 Value1, Column2: Row2 Value2, ...
+Column: Row3 Value1, Column2: Row3 Value2, ...
+```
+
+```
+# SimpleTable - slightly less boring table, keeping the same level of consistency
+
+Column: Row1 Value1
+Column2: Row1 Value2
+----
+Column: Row2 Value1
+Column2: Row2 Value2
+----
+Column: Row3 Value1
+Column2: Row3 Value2
+
+```
+
+```
+# MonoTable - prettier, but requires a monospace font to function.
+
+```
+
+```
+# UnicodeMonoTable - the prettiest, but requires a monospace font to function.
+#  Makes use of non-ascii characters, so may cause rendering issues on some clients.
+
+```
+
+## Making your own table
+Your table needs to meet the following two conditions:
+
+- Extend `RTables::TableBuilder`
+- Have a `render` method that returns an array of lines.
+  - May call `raise_if_empty` in `render` to generate a `TableFormatError` when there is no content.
+
+### Base code
+
+```ruby
+require 'rtables/tablebuilder'
+
+class MyTable < RTables::TableBuilder
+  def render
+    raise_if_empty
+
+    # Logic that returns an array of lines ..
+  end
+end

data/lib/rtables/tablebuilder.rb

@@ -0,0 +1,63 @@
+module RTables
+  class TableBuilder
+    def initialize
+      @table_header = []
+      @table_content = []
+
+      @columns = 0
+      @rows = 0
+    end
+
+    attr_reader :table_header, :table_content, :columns, :rows
+
+    def add_column(name)
+      return false if column_exist?(name)
+      fail TableFormatError, 'Cannot add more columns after rows have been added.' if @rows != 0
+
+      @table_header.push(name)
+      @columns += 1
+      true
+    end
+
+    def add_row(*args)
+      if args.count != @columns
+        fail TableFormatError, "Number of arguments passed does not equal number of columns. [#{args.count} != #{@columns}]"
+      end
+
+      @table_content.push(args)
+      @rows += 1
+      true
+    end
+
+    def column_exist?(name)
+      @table_header.include?(name)
+    end
+
+    def raise_if_empty
+      fail TableFormatError, 'Table has no content to display.' if empty?
+    end
+
+    def empty?
+      @columns == 0 && @rows == 0
+    end
+
+    def render
+      fail TableFormatError, 'This table does not generate any output.'
+    end
+
+    def to_s
+      raise_if_empty
+
+      lines = render
+
+      lines.join("\n")
+    end
+
+    def inspect
+      "<Table columns=#{@columns} rows=#{@rows}>"
+    end
+  end
+
+  class TableFormatError < StandardError
+  end
+end

data/lib/rtables/tables/monotable.rb

@@ -0,0 +1,68 @@
+module RTables
+  module Table
+    class MonoTable < TableBuilder
+      def render
+        corner = '+'
+        line_horizontal = '-'
+        line_vertical = '|'
+
+        hlen = max_header_length
+        clen = max_content_length
+
+        row_sep = "#{corner}#{line_horizontal * (hlen + 2)}#{corner}#{line_horizontal * (clen + 2)}#{corner}"
+        line_fmt = "#{line_vertical} %{header} #{line_vertical} %{content} #{line_vertical}"
+        lines = []
+        i = 0
+
+        lines << row_sep
+        @table_content.each do |contents|
+          contents.each do |content|
+            lines << line_fmt % { header: pad_header(@table_header[i], hlen), content: pad_content(content, clen) }
+            i += 1
+          end
+
+          i = 0
+          lines << row_sep
+        end
+
+        lines
+      end
+
+      def pad_header(header, hlen)
+        spacing = hlen - header.length
+
+        header + (' ' * spacing)
+      end
+
+      def pad_content(content, clen)
+        spacing = clen - content.length
+
+        content + (' ' * spacing)
+      end
+
+      def max_content_length
+        max_len = 0
+
+        @table_content.each do |contents|
+          contents.each do |content|
+            len = content.length
+            max_len = len if max_len < len
+          end
+        end
+
+        max_len
+      end
+
+      def max_header_length
+        max_len = 0
+
+        @table_header.each do |head|
+          len = head.length
+          max_len = len if max_len < len
+        end
+
+        max_len
+      end
+    end
+  end
+end

data/lib/rtables/tables/plaintable.rb

@@ -0,0 +1,23 @@
+module RTables
+  module Table
+    class PlainTable < TableBuilder
+      def render
+        raise_if_empty
+
+        lines = []
+        i = 0
+
+        @table_content.each do |content|
+          @table_header.each do |header|
+            lines << "#{header}: #{content[i]}"
+            i += 1
+          end
+          lines << '----'
+          i = 0
+        end
+
+        lines
+      end
+    end
+  end
+end

data/lib/rtables/tables/simpletable.rb

@@ -0,0 +1,24 @@
+module RTables
+  module Table
+    class SimpleTable < TableBuilder
+      def render
+        raise_if_empty
+
+        lines = []
+        i = 0
+
+        @table_content.each do |content|
+          line = []
+          @table_header.each do |header|
+            line << "#{header}: #{content[i]}"
+            i += 1
+          end
+          lines << line.join(', ')
+          i = 0
+        end
+
+        lines
+      end
+    end
+  end
+end

data/lib/rtables/tables/unicodemonotable.rb

@@ -0,0 +1,85 @@
+module RTables
+  module Table
+    class UnicodeMonoTable < TableBuilder
+      CORNER_POS_LTOP = '┌'
+      CORNER_POS_RTOP = '┐'
+      CORNER_POS_MTOP = '┬'
+
+      CORNER_POS_LMID = '├'
+      CORNER_POS_RMID = '┤'
+      CORNER_POS_MMID = '┼'
+
+      CORNER_POS_LBOT = '└'
+      CORNER_POS_RBOT = '┘'
+      CORNER_POS_MBOT = '┴'
+
+      def render
+        line_horizontal = '─'
+        line_vertical = '│'
+
+        hlen = max_header_length
+        clen = max_content_length
+
+        row_sep_base = "#{line_horizontal * (hlen + 2)}%{tchar}#{line_horizontal * (clen + 2)}"
+        row_sep_top = "#{CORNER_POS_LTOP}#{row_sep_base % { tchar: CORNER_POS_MTOP }}#{CORNER_POS_RTOP}"
+        row_sep_mid = "#{CORNER_POS_LMID}#{row_sep_base % { tchar: CORNER_POS_MMID }}#{CORNER_POS_RMID}"
+        row_sep_bot = "#{CORNER_POS_LBOT}#{row_sep_base % { tchar: CORNER_POS_MBOT }}#{CORNER_POS_RBOT}"
+
+        line_fmt = "#{line_vertical} %{header} #{line_vertical} %{content} #{line_vertical}"
+        lines = []
+        i = 0
+
+        lines << row_sep_top
+        @table_content.each do |contents|
+          contents.each do |content|
+            lines << line_fmt % { header: pad_header(@table_header[i], hlen), content: pad_content(content, clen) }
+            i += 1
+          end
+
+          i = 0
+          lines << row_sep_mid
+        end
+        lines.pop
+        lines << row_sep_bot
+
+        lines
+      end
+
+      def pad_header(header, hlen)
+        spacing = hlen - header.length
+
+        header + (' ' * spacing)
+      end
+
+      def pad_content(content, clen)
+        spacing = clen - content.length
+
+        content + (' ' * spacing)
+      end
+
+      def max_content_length
+        max_len = 0
+
+        @table_content.each do |contents|
+          contents.each do |content|
+            len = content.length
+            max_len = len if max_len < len
+          end
+        end
+
+        max_len
+      end
+
+      def max_header_length
+        max_len = 0
+
+        @table_header.each do |head|
+          len = head.length
+          max_len = len if max_len < len
+        end
+
+        max_len
+      end
+    end
+  end
+end

data/lib/rtables/version.rb

@@ -0,0 +1,3 @@
+module RTables
+  VERSION = '1.0.0'.freeze
+end

data/lib/rtables.rb

@@ -0,0 +1,9 @@
+dir = File.dirname(__FILE__)
+$LOAD_PATH.unshift dir unless $LOAD_PATH.include?(dir)
+
+require 'rtables/tablebuilder'
+
+require 'rtables/tables/plaintable'
+require 'rtables/tables/simpletable'
+require 'rtables/tables/monotable'
+require 'rtables/tables/unicodemonotable'

metadata

@@ -0,0 +1,59 @@
+--- !ruby/object:Gem::Specification
+name: rtables
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Jos Ahrens
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-11-08 00:00:00.000000000 Z
+dependencies: []
+description: RTables allows you to generate your own table output in the least amount
+  of code.
+email: gems@zarth.us
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- docs/making_your_own_table.md
+- docs/tables/MonoTable.md
+- docs/tables/PlainTable.md
+- docs/tables/SimpleTable.md
+- docs/tables/UnicodeMonoTable.md
+- docs/tables_in_2_minutes.md
+- lib/rtables.rb
+- lib/rtables/tablebuilder.rb
+- lib/rtables/tables/monotable.rb
+- lib/rtables/tables/plaintable.rb
+- lib/rtables/tables/simpletable.rb
+- lib/rtables/tables/unicodemonotable.rb
+- lib/rtables/version.rb
+homepage: https://github.com/zarthus/rtables
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.5
+signing_key: 
+specification_version: 4
+summary: 'Ruby Tables: Generate tables fast and easy'
+test_files: []