termline 1.1.1 → 1.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a07c43d93ed4574a6264d64b32f29fccc25dd0e98f6cf86ec851e8c367c7a026
-  data.tar.gz: 8347c016ceea2947a30ca216a38d8f9fc23b1f946e2421a7e5c320675871558a
+  metadata.gz: 1b593daa817cc923186c32b2f3170ba26038d3a8dde434ab9b47dd6ebc87511b
+  data.tar.gz: '048cced682cad7f691f3e2f37bf0e2ea53fa4ed3a8417a351abd8e7c692747b1'
 SHA512:
-  metadata.gz: 18586ea12b6729ae4b0688d59437c322946982124cd75319acf8c89a980c113d671ce97a22b37ace1b134a7348be22811ed63dd3272d47702554dac3bc4d984d
-  data.tar.gz: d7820e373323cf76f2660379874cf8e416441083e46a40cdea2abebbc2ac49d33c4c72e8de3f1c5119f9beb154888aeee041df1fc449e9441d0bff13a021f9e0
+  metadata.gz: f50437c2d6fdf48228d60cc086c6ef687ad0e8700aa36b2375fcd040e7cef3b7e6ec16d87f4347c89128cd358ecda03d52ba35b7e528d7a849de0316d926a615
+  data.tar.gz: d64e15285ad6cdd6f3266d1afc2b1b8a97a9518a306b560dc44276802671c746e353b47ecac984e3df8fb0876da9a73c2facf1bb991143be3ab1a053b74a1150

data/lib/termline/details.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module Termline
+    module Details
+        class << self
+            def builder(data=nil, color: :blue, separator: ": ", icon: nil, icons: nil, **additional_data)
+                data = additional_data if data.nil?
+                data = data.merge(additional_data) if !additional_data.empty? && data.respond_to?(:merge)
+
+                unless data.respond_to?(:each_pair)
+                    raise ArgumentError, "Details data must be a hash-like object"
+                end
+
+                pairs = data.each_pair.to_a
+                return "" if pairs.empty?
+
+                icon_map = normalize_icon_map(icons)
+                show_icon_column = !icon.nil? || !icon_map.empty?
+                key_width = pairs.map { |key, _value| key.to_s.length }.max
+
+                pairs.map do |key, value|
+                    row_icon = icon_map.fetch(key.to_s, icon)
+                    icon_prefix = format_icon(row_icon, color, show_icon_column)
+                    label = Style.colorize(key.to_s.ljust(key_width), color)
+                    "#{icon_prefix}#{label}#{separator}#{format_value(value)}"
+                end.join("\n")
+            end
+
+            private
+
+            def format_value(value)
+                case value
+                when nil
+                    "nil"
+                when String
+                    value
+                else
+                    value.to_s
+                end
+            end
+
+            def normalize_icon_map(icons)
+                return {} if icons.nil?
+
+                unless icons.respond_to?(:each_pair)
+                    raise ArgumentError, "Details icons must be a hash-like object"
+                end
+
+                icons.each_pair.each_with_object({}) do |(key, value), normalized|
+                    normalized[key.to_s] = value
+                end
+            end
+
+            def format_icon(icon, color, show_icon_column)
+                return "" unless show_icon_column
+                return "  " if icon.nil?
+
+                "#{Style.colorize(Style.icon(icon), color)} "
+            end
+        end
+    end
+end

data/lib/termline/list.rb

@@ -33,8 +33,26 @@ Building a better future, one line of code at a time.
 module Termline 
     module List 
         class << self
-            def builder(items, icon:, color:)
-                items.each { |item| puts("  #{Style.colorize(Style.icon(icon), color)} #{ item }" )}
+            def builder(items, icon: :debug, color: :default, ordered: false, start: 1)
+                first_number = integer_start(start)
+
+                items.each_with_index.map do |item, index|
+                    marker = if ordered
+                        Style.colorize("#{first_number + index}.", color)
+                    else
+                        Style.colorize(Style.icon(icon), color)
+                    end
+
+                    "  #{marker} #{item}"
+                end.join("\n")
+            end
+
+            private
+
+            def integer_start(value)
+                Integer(value)
+            rescue ArgumentError, TypeError
+                raise ArgumentError, "List start must be an integer"
             end
         end
     end

data/lib/termline/msg.rb

@@ -40,21 +40,31 @@ module Termline
                 icon: nil,
                 color: :default, 
                 bgcolor: :default, 
-                timestamp: Time.now.strftime('%H:%M:%S:%L'), data:nil)
+                timestamp: nil,
+                time:nil,
+                data:nil)
 
+                unless time.nil? || time == true || time == false
+                    raise ArgumentError, "Message time must be true, false, or nil"
+                end
+
+                show_time = time.nil? ? Termline.timestamps? : time
                 parts = []
-                parts << "[#{timestamp}]" if timestamp
+                parts << "[#{timestamp || current_timestamp}]" if show_time
                 parts << Style.colorize(Style.icon(icon), color) if icon
                 parts << Style.colorize(tag, color) if tag
-                parts << message
+                parts << if bgcolor == :default
+                    message
+                else
+                    Style.colorize(message, color, bgcolor)
+                end
                 parts << data_text(data, color) if data
 
                 parts.compact.map(&:to_s).reject(&:empty?).join(" ").strip
             end
 
-            def alert message
-                puts("\e[5m#{message}\e[0m")
-                puts("\e[5m#{Style.colorize(message,:red)}\e[0m")
+            def alert(message)
+                Style.colorize(" #{message} ", :white, :red)
             end
 
             private 
@@ -70,7 +80,11 @@ module Termline
 
             def data_text(data, color)
                 return nil if data.nil? || data.empty?
-                data.map { |key, value| "#{key}#{Style.colorize('=>', color)}#{format_value(value)}" }.join(" ")            
+                data.map { |key, value| "#{Style.colorize(key, color)}=#{format_value(value)}" }.join(" ")
+            end
+
+            def current_timestamp
+                Time.now.strftime(Termline.timestamp_format)
             end
         end
     end

data/lib/termline/space.rb

@@ -33,19 +33,34 @@ Building a better future, one line of code at a time.
 module Termline 
     module Space 
         class << self
-            def builder(character, count)
+            def builder(character, count=8)
                 character * count
             end
-            def br count=1
-                puts("\n" * count);
-            end 
-        
-            def line count=8
-                puts('-·-     ' * count)
+
+            def line(character, width)
+                character = character.to_s
+                raise ArgumentError, "Separator character cannot be empty" if character.empty?
+
+                width = positive_width(width)
+
+                (character * ((width.to_f / character.length).ceil))[0, width]
+            end
+
+            def color(color)
+                return "" unless Termline.terminal.ansi?
+
+                Style.pretty("", :black, color)
             end
 
-            def color color
-                Config.pretty("", :black, color)
+            private
+
+            def positive_width(value)
+                width = Integer(value)
+                raise ArgumentError unless width.positive?
+
+                width
+            rescue ArgumentError, TypeError
+                raise ArgumentError, "Separator width must be a positive integer"
             end
         end
     end

data/lib/termline/style.rb

@@ -48,19 +48,19 @@ module Termline
         # standard color palette for texts
         COLORS = { 
             skyblue: '96',
-            default: '38', 
+            default: '39',
             yellow: '1;33',
             white: '1;37', 
             green: '32',  
             black: '30', 
             gray: '90',
-            blue: '36', 
+            blue: '34',
             red: '31'
         }.freeze
     
         # standard color palette for backgrounds
         BG_COLORS = { 
-            default: '0', 
+            default: '49',
             yellow: '103', 
             white: '107', 
             green: '42', 
@@ -68,39 +68,33 @@ module Termline
             blue: '44',
             red: '41'
         }.freeze
-    
-    
-        # calculate the console width
-        # tputcols is not available on windows
-        WIDTH = begin
-            term = ENV['TERM']
-            term ? `tput cols`.to_i : 1
-        rescue
-            1
-        end
-
         class << self 
-            def icon icon
-                ICONS[icon]
+            def icon(icon)
+                ICONS.fetch(icon) do
+                    raise ArgumentError, "Unknown icon: #{icon.inspect}. Available icons: #{ICONS.keys.join(', ')}"
+                end
             end
 
             # Concat color to text
             def colorize(text, colour = :default, bg_colour = :default)
-                colour_code = COLORS[colour]
-                bg_colour_code = BG_COLORS[bg_colour]
-                return "\e[#{bg_colour_code};#{colour_code}m#{text}\e[0m".squeeze(';')
+                colour_code = COLORS.fetch(colour) do
+                    raise ArgumentError, "Unknown color: #{colour.inspect}. Available colors: #{COLORS.keys.join(', ')}"
+                end
+                bg_colour_code = BG_COLORS.fetch(bg_colour) do
+                    raise ArgumentError, "Unknown background color: #{bg_colour.inspect}. Available background colors: #{BG_COLORS.keys.join(', ')}"
+                end
+                return text.to_s unless Termline.terminal.ansi?
+
+                return "\e[#{colour_code};#{bg_colour_code}m#{text}\e[0m"
             end
 
             # Format text
             def pretty(message, colour = :default, bg_colour = :default)
-                width = 1
-        
-                unless bg_colour == :default
-                    width = WIDTH - message.length - 4
-                    width = 1 if width.negative?
-                end
-        
-                return colorize("#{ message } #{"\ " * width}", colour, bg_colour)
+                text = message.to_s
+                return colorize(text, colour, bg_colour) if bg_colour == :default
+
+                padding = [Termline.terminal.width - text.length, 0].max
+                colorize("#{text}#{" " * padding}", colour, bg_colour)
             end
         end
     end 

data/lib/termline/table.rb

@@ -33,58 +33,180 @@ Building a better future, one line of code at a time.
 module Termline 
     module Table 
         class << self
-            def builder data, header:true
+            ALIGNMENTS = [:auto, :left, :center, :right].freeze
 
-                return if Gem.win_platform?
-                return unless data.size > 0
+            def builder(data, header:true, align: :auto)
+                # Convert every supported input into a predictable matrix first.
+                # Rendering can then stay independent from Active Record and hashes.
+                source = normalize_source(data)
+                return "" if source.empty?
 
-                table_from_array = true if data.first.class == Array
-                header = false if table_from_array
+                keys, rows, hash_rows = normalize_rows(source)
+                return "" if rows.empty? || rows.first.empty?
 
-                if data.class.name == "ActiveRecord::Relation"
-                    data = data.to_a.map(&:serializable_hash) 
+                headers = hash_rows && header ? keys.map { |key| key.to_s.upcase } : nil
+                text_rows = rows.map { |row| row.map { |value| normalize_value(value) } }
+
+                # Widths are calculated from visible text before padding or borders
+                # are added, so the completed line never exceeds the terminal width.
+                widths = column_widths(text_rows, headers, Termline.terminal.width)
+                return "" unless widths
+
+                alignments = widths.each_index.map do |index|
+                    column_alignment(align, index, keys[index], rows.map { |row| row[index] })
+                end
+
+                separator = render_separator(widths)
+                lines = []
+
+                if headers
+                    lines << render_row(headers, widths, alignments)
+                    lines << separator
+                else
+                    lines << separator
+                end
+
+                text_rows.each do |row|
+                    lines << render_row(row, widths, alignments)
+                end
+
+                lines << separator unless headers
+                lines.join("\n")
+            end
+
+            private
+
+            def normalize_source(data)
+                # A single hash is one row. Active Record support is detected only
+                # when Active Record is already loaded, keeping it an optional dependency.
+                return [] if data.nil?
+                return [data] if data.is_a?(Hash)
+
+                if active_record_relation?(data)
+                    return data.to_a.map(&:serializable_hash)
+                end
+
+                unless data.respond_to?(:to_a)
+                    raise ArgumentError, "Table data must be a hash or collection of rows"
+                end
+
+                data.to_a
+            end
+
+            def active_record_relation?(data)
+                defined?(::ActiveRecord::Relation) && data.is_a?(::ActiveRecord::Relation)
+            end
+
+            def normalize_rows(source)
+                if source.all? { |row| row.is_a?(Hash) }
+                    # Use the union of keys in insertion order. This preserves columns
+                    # that appear only in later rows and leaves missing values blank.
+                    keys = source.flat_map(&:keys).uniq
+                    rows = source.map { |row| keys.map { |key| row[key] } }
+                    return [keys, rows, true]
+                end
+
+                unless source.all? { |row| row.is_a?(Array) }
+                    raise ArgumentError, "Table rows must all be hashes or all be arrays"
                 end
 
-                # get the available characters in terminal width
-                #terminal_width = `tput cols`.to_i
-                terminal_width = Style::WIDTH
+                # Array rows have no column names. Pad short rows so every rendered
+                # row has the same number of cells and borders remain aligned.
+                column_count = source.map(&:length).max.to_i
+                rows = source.map { |row| row + Array.new(column_count - row.length) }
+                [Array.new(column_count) { |index| index }, rows, false]
+            end
+
+            def normalize_value(value)
+                # Tables are intentionally single-line components; embedded whitespace
+                # is collapsed instead of allowing one value to break the layout.
+                value.nil? ? "" : value.to_s.gsub(/\s+/, " ").strip
+            end
 
-                # get the number of columns to print base on the data hash
-                cols = data.first.length + 1
+            def column_widths(rows, headers, terminal_width)
+                column_count = rows.first.length
 
-                # get the available space for every column
-                col_width = (terminal_width / cols) - 1
+                # Each column contributes two padding spaces and one separator.
+                # The final `+ 1` accounts for the closing border.
+                available = terminal_width - ((column_count * 3) + 1)
+                return nil if available < column_count
 
-                # validate that we have minimum space to render the table
-                return if col_width <= 0
+                widths = Array.new(column_count, 1)
+                column_count.times do |index|
+                    values = rows.map { |row| row[index].length }
+                    values << headers[index].length if headers
+                    widths[index] = values.max
+                end
 
-                # separator for every column and row
-                separator = ('| ' << ('- ' * (col_width / 2)))
+                # Repeatedly shrink the widest column. This favors compact columns
+                # while sharing scarce space fairly between long text columns.
+                while widths.sum > available
+                    index = widths.each_index.select { |position| widths[position] > 1 }.max_by { |position| widths[position] }
+                    break unless index
 
-                # add extra blank spaces to adjust the col_width only if col_width not a even number
-                separator += (' ') if (col_width - separator.size).odd?
+                    widths[index] -= 1
+                end
+
+                widths
+            end
 
-                # only for table header
-                if header
+            def column_alignment(align, index, key, values)
+                # Alignment may be global, positional, or keyed by the original hash
+                # key. Missing per-column settings fall back to automatic alignment.
+                requested = case align
+                when Hash
+                    align.fetch(key) do
+                        align.fetch(key.to_s) { align.fetch(index, :auto) }
+                    end
+                when Array
+                    align[index] || :auto
+                else
+                    align
+                end
 
-                    # print table titles
-                    puts '| ' << data.first.keys.map { |key| key.to_s.upcase.ljust(col_width) }.join('| ')
-                end 
+                requested = requested.to_sym if requested.respond_to?(:to_sym)
+                unless ALIGNMENTS.include?(requested)
+                    raise ArgumentError, "Unknown table alignment: #{requested.inspect}. Available alignments: #{ALIGNMENTS.join(', ')}"
+                end
 
-                # print header separators, only for visible columns
-                puts separator * (cols - 1)
+                return requested unless requested == :auto
 
-                # print data as table :)
-                data.each_with_index do |row, index|
+                # A column is numeric only when all of its non-nil source values are
+                # numeric. Numeric-looking strings remain left-aligned intentionally.
+                printable_values = values.compact
+                printable_values.any? && printable_values.all? { |value| value.is_a?(Numeric) } ? :right : :left
+            end
 
-                    # join hash values as a line and justify every value to print value in its own column
-                    puts '| ' << row.values.map { |value| value.to_s.ljust(col_width) }.join('| ') unless table_from_array
+            def render_separator(widths)
+                "|#{widths.map { |width| "-" * (width + 2) }.join("|")}|"
+            end
 
-                    # print simple value from the array data
-                    puts '| ' << row.map { |value| value.to_s.ljust(col_width) }.join('| ') if table_from_array
+            def render_row(row, widths, alignments)
+                cells = row.each_index.map do |index|
+                    text = truncate(row[index], widths[index])
+                    align_text(text, widths[index], alignments[index])
                 end
 
-                puts separator * (cols - 1) unless header
+                "| #{cells.join(' | ')} |"
+            end
+
+            def truncate(text, width)
+                return text if text.length <= width
+                return "…" if width == 1
+
+                # Reserve the final cell for an ellipsis so truncation is visible.
+                "#{text[0, width - 1]}…"
+            end
+
+            def align_text(text, width, alignment)
+                case alignment
+                when :right
+                    text.rjust(width)
+                when :center
+                    text.center(width)
+                else
+                    text.ljust(width)
+                end
             end
         end
     end

data/lib/termline/terminal.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+require "io/console"
+
+module Termline
+    class Terminal
+        DEFAULT_WIDTH = 80
+        ANSI_MODES = [true, false, :auto].freeze
+
+        attr_reader :ansi
+
+        def initialize(output: nil, ansi: :auto, width: nil)
+            self.output = output
+            self.ansi = ansi
+            self.width = width
+        end
+
+        def output
+            @output || $stdout
+        end
+
+        def output=(io)
+            unless io.nil? || io.respond_to?(:puts)
+                raise ArgumentError, "Output must respond to #puts"
+            end
+
+            @output = io
+        end
+
+        def ansi=(mode)
+            unless ANSI_MODES.include?(mode)
+                raise ArgumentError, "ANSI mode must be true, false, or :auto"
+            end
+
+            @ansi = mode
+        end
+
+        def ansi?
+            return ansi if ansi == true || ansi == false
+
+            output.respond_to?(:tty?) && output.tty? && !ENV.key?("NO_COLOR") && ENV["TERM"] != "dumb"
+        end
+
+        def width
+            return @width if @width
+
+            width_from(output) || environment_width || width_from(IO.console) || DEFAULT_WIDTH
+        end
+
+        def width=(value)
+            if value.nil?
+                @width = nil
+                return
+            end
+
+            width = Integer(value)
+            raise ArgumentError, "Terminal width must be greater than zero" unless width.positive?
+
+            @width = width
+        rescue ArgumentError, TypeError
+            raise ArgumentError, "Terminal width must be a positive integer"
+        end
+
+        private
+
+        def environment_width
+            value = Integer(ENV.fetch("COLUMNS", 0))
+            value if value.positive?
+        rescue ArgumentError, TypeError
+            nil
+        end
+
+        def width_from(io)
+            return unless io.respond_to?(:winsize)
+
+            value = io.winsize.last.to_i
+            value if value.positive?
+        rescue IOError, SystemCallError
+            nil
+        end
+    end
+end

data/lib/termline/text.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Termline
+    module Text
+        class << self
+            def title(text, color: :blue, character: "─", width: Termline.terminal.width)
+                character = character.to_s
+                raise ArgumentError, "Title character cannot be empty" if character.empty?
+
+                width = positive_width(width)
+                prefix = "#{character * 2} #{text}"
+                plain = fit_title(prefix, character, width)
+
+                Style.colorize(plain, color)
+            end
+
+            private
+
+            def fit_title(prefix, character, width)
+                return truncate(prefix, width) if prefix.length >= width
+
+                remaining = width - prefix.length - 1
+                "#{prefix} #{fill(character, remaining)}"
+            end
+
+            def fill(character, width)
+                return "" unless width.positive?
+
+                (character * ((width.to_f / character.length).ceil))[0, width]
+            end
+
+            def truncate(text, width)
+                return text if text.length <= width
+                return "…" if width == 1
+
+                "#{text[0, width - 1]}…"
+            end
+
+            def positive_width(value)
+                width = Integer(value)
+                raise ArgumentError unless width.positive?
+
+                width
+            rescue ArgumentError, TypeError
+                raise ArgumentError, "Text width must be a positive integer"
+            end
+        end
+    end
+end

data/lib/termline/version.rb

@@ -1,6 +1,8 @@
 =begin
 
-Copyright (c) 2022, Lesli Technologies, S. A.
+Lesli
+
+Copyright (c) 2026, Lesli Technologies, S. A.
 
 This program is free software: you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
@@ -13,23 +15,22 @@ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
-along with this program. If not, see <http://www.gnu.org/licenses/>.
+along with this program. If not, see http://www.gnu.org/licenses/.
 
-Lesli Ruby Messages - Message utilities for the Ruby console
+Lesli · Ruby on Rails SaaS Development Framework.
 
-Powered by https://www.lesli.tech
+Made with ♥ by LesliTech
 Building a better future, one line of code at a time.
 
-@contact  <hello@lesli.tech>
-@website  <https://www.lesli.tech>
+@contact  hello@lesli.tech
+@website  https://www.lesli.tech
 @license  GPLv3 http://www.gnu.org/licenses/gpl-3.0.en.html
-@author   The Lesli Development Team
 
-// · ~·~     ~·~     ~·~     ~·~     ~·~     ~·~     ~·~     ~·~     ~·~     ~·~     ~·~     ~·~
+// · ~·~     ~·~     ~·~     ~·~     ~·~     ~·~     ~·~     ~·~     ~·~
 // · 
 =end
 
 module Termline
-    VERSION = "1.1.1"
-    BUILD = "1775000800"
+    VERSION = "1.1.3"
+    BUILD = ""
 end