command_line_reporter 3.3.6 → 4.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 4a2787df26c02bb1e92edcdf6cb9bc01663cf7b5
-  data.tar.gz: ed36d67ef61f86542166a616f82f91b6176fc328
+  metadata.gz: 1024c56ad76f095c3f3778ec780c4427f184ab34
+  data.tar.gz: 60ddfd0b420dc8ce7692f7d1cd226ba437c4349f
 SHA512:
-  metadata.gz: b7482d1047e264db40d5bcc1b773c9105648324b8cf9c0f1cec553be7dd9ae89956703b251afeaa16113044d6b3465b7e83491bd05b0aba4a651cb403a6e007b
-  data.tar.gz: fb4aa21ac3e2879ca200a5a93996c6ce26450e272dbcdba40586a300931db1a56b39b50dc1332a4c4d5e0f66459b577a21d0d5b47a2e821d9b4f0bbebab685a9
+  metadata.gz: 040a9a4fad99322164d8b42225f7c06335f1747d4e387ceb6ddc7a483dc7375717f3f442123e85a9c7bd75a3e4937da125a4651fc4148afdf9c20f9a0b11ad04
+  data.tar.gz: 9c0ba99f7fc2ba37cadcc3d8cf15eb10b94f8da4f5de036952344ebeea80917a3e9c389d5810a2f7019ba98ae608833a1dac8bf8f3058e106bfe230ff58886e3

data/README.md

@@ -134,7 +134,7 @@ There are several methods the mixin provides that do not depend on the formatter
 
 ### License
 
-Copyright (c) 2011-2015 Wes Bailey
+Copyright (c) 2011-2017 Wes Bailey
 
 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,

data/lib/command_line_reporter.rb

@@ -8,17 +8,18 @@ require 'command_line_reporter/column'
 require 'command_line_reporter/table'
 require 'command_line_reporter/version'
 
+# rubocop:disable Metrics/ModuleLength
 module CommandLineReporter
   include OptionsValidator
 
   attr_reader :formatter
 
   DEFAULTS = {
-    :width => 100,
-    :align => 'left',
-    :formatter => 'nested',
-    :encoding => :unicode,
-  }
+    width: 100,
+    align: 'left',
+    formatter: 'nested',
+    encoding: :unicode
+  }.freeze
 
   def capture_output
     $stdout.rewind
@@ -38,7 +39,7 @@ module CommandLineReporter
   def formatter=(type = 'nested')
     return type if type.class != String
     name = type.capitalize + 'Formatter'
-    klass = %W{CommandLineReporter #{name}}.inject(Kernel) {|s,c| s.const_get(c)}
+    klass = %W[CommandLineReporter #{name}].inject(Kernel) { |a, e| a.const_get(e) }
 
     # Each formatter is a singleton that responds to #instance
     @formatter = klass.instance
@@ -72,14 +73,14 @@ module CommandLineReporter
     char = options[:char].is_a?(String) ? options[:char] : use_char
     width = options[:width] || DEFAULTS[:width]
 
-    aligned(char * width, :width => width, :color => options[:color], :bold => options[:bold])
+    aligned(char * width, width: width, color: options[:color], bold: options[:bold])
   end
 
   def vertical_spacing(lines = 1)
     lines = Integer(lines)
 
     # because puts "\n" * 0 produces an unwanted newline
-    if lines == 0
+    if lines.zero?
       print "\0"
     else
       puts "\n" * lines
@@ -89,40 +90,24 @@ module CommandLineReporter
   def datetime(options = {})
     validate_options(options, :align, :width, :format, :color, :bold)
 
-    format = options[:format] || '%Y-%m-%d - %l:%M:%S%p'
-    align = options[:align] || DEFAULTS[:align]
-    width = options[:width] || DEFAULTS[:width]
-
+    format = default_options_date_format(options[:format])
     text = Time.now.strftime(format)
 
-    raise Exception if text.size > width
-
-    aligned(text, :align => align, :width => width, :color => options[:color], :bold => options[:bold])
+    aligned(text, options)
   end
 
   def aligned(text, options = {})
-    validate_options(options, :align, :width, :color, :bold)
+    validate_options(options, :align, :width, :format, :color, :bold)
 
-    align = options[:align] || DEFAULTS[:align]
-    width = options[:width] || DEFAULTS[:width]
-    color = options[:color]
-    bold = options[:bold] || false
+    options[:align] = default_options_align(options[:align])
+    options[:width] = default_options_width(options[:width])
+    options[:bold] = default_options_bold(options[:bold])
 
-    line = case align
-           when 'left'
-             text
-           when 'right'
-             text.rjust(width)
-           when 'center'
-             text.rjust((width - text.size)/2 + text.size)
-           else
-             raise ArgumentError
-           end
+    raise Exception if text.size > options[:width]
 
-    line = line.send(color) if color
-    line = line.send('bold') if bold
+    line = align_line(text, options)
 
-    puts line
+    puts apply_color(line, options)
   end
 
   def table(options = {})
@@ -145,36 +130,98 @@ module CommandLineReporter
 
   private
 
+  def align_line(text, options)
+    case options[:align]
+    when 'left'
+      text
+    when 'right'
+      text.rjust(options[:width])
+    when 'center'
+      text.rjust((options[:width] - text.size) / 2 + text.size)
+    end
+  end
+
+  def apply_color(line, options)
+    line = line.send(options[:color]) if options[:color]
+    line = line.send('bold') if options[:bold]
+    line
+  end
+
+  # def default_datetime_options(options)
+  #   format = define_format(options)
+  #   align = default_options_align(options[:align])
+  #   width = default_options_width(options[:width])
+  #   [format, align, width]
+  # end
+
+  def default_options_date_format(format)
+    format || '%Y-%m-%d - %l:%M:%S%p'
+  end
+
   def section(type, options)
-    title, width, align, lines, color, bold = assign_section_properties(options)
+    options = define_section_values(options)
 
-    # This also ensures that width is a Fixnum
-    raise ArgumentError if title.size > width
+    raise ArgumentError if options[:title].size > options[:width]
 
-    if type == :footer
-      vertical_spacing(lines)
-      horizontal_rule(:char => options[:rule], :width => width, :color => color, :bold => bold) if options[:rule]
-    end
+    print_header(type, options)
+    print_body(options)
+    print_footer(type, options)
+  end
+
+  def print_header(type, options)
+    return unless type == :header
+    vertical_spacing(options[:lines])
+    horizontal_rule(char: options[:rule], width: options[:width], color: options[:color], bold: options[:bold]) if options[:rule]
+  end
 
-    aligned(title, :align => align, :width => width, :color => color, :bold => bold)
-    datetime(:align => align, :width => width, :color => color, :bold => bold) if options[:timestamp]
+  def print_body(options)
+    aligned(options[:title], align: options[:align], width: options[:width], color: options[:color], bold: options[:bold])
+    datetime(align: options[:align], width: options[:width], color: options[:color], bold: options[:bold]) if options[:timestamp]
+  end
 
-    if type == :header
-      horizontal_rule(:char => options[:rule], :width => width, :color => color, :bold => bold) if options[:rule]
-      vertical_spacing(lines)
-    end
+  def print_footer(type, options)
+    return unless type == :footer
+    horizontal_rule(char: options[:rule], width: options[:width], color: options[:color], bold: options[:bold]) if options[:rule]
+    vertical_spacing(options[:lines])
   end
 
-  def assign_section_properties options
+  def define_section_values(options)
     validate_options(options, :title, :width, :align, :spacing, :timestamp, :rule, :color, :bold)
 
-    title = options[:title] || 'Report'
-    width = options[:width] || DEFAULTS[:width]
-    align = options[:align] || DEFAULTS[:align]
-    lines = options[:spacing] || 1
-    color = options[:color]
-    bold = options[:bold] || false
+    options[:title] = default_options_title(options[:title])
+    options[:width] = default_options_width(options[:width])
+    options[:align] = default_options_align(options[:align])
+    options[:lines] = default_options_lines(options[:spacing])
+    options[:bold] = default_options_bold(options[:bold])
+
+    options
+  end
+
+  def default_options_title(title)
+    title || 'Report'
+  end
+
+  def default_options_width(width)
+    width ||= DEFAULTS[:width]
+    Integer(width)
+    width
+  end
+
+  def default_options_align(align)
+    align ||= DEFAULTS[:align]
+    validate_align(align)
+    align
+  end
+
+  def default_options_lines(lines)
+    lines || 1
+  end
+
+  def default_options_bold(bold)
+    bold || false
+  end
 
-    return [title, width, align, lines, color, bold]
+  def validate_align(align)
+    raise ArgumentError unless %i[left center right].include?(align.to_sym)
   end
 end

data/lib/command_line_reporter/column.rb

@@ -4,71 +4,82 @@ module CommandLineReporter
   class Column
     include OptionsValidator
 
-    VALID_OPTIONS = [:width, :padding, :align, :color, :bold, :underline, :reversed]
+    VALID_OPTIONS = %i[width padding align color bold underline reversed span].freeze
     attr_accessor :text, :size, *VALID_OPTIONS
 
     def initialize(text = nil, options = {})
-      self.validate_options(options, *VALID_OPTIONS)
+      validate_options(options, *VALID_OPTIONS)
+      assign_alignment_defaults(options)
+      assign_color_defaults(options)
 
       self.text = text.to_s
-
-      self.width = options[:width]  || 10
-      self.align = options[:align] || 'left'
-      self.padding = options[:padding] || 0
-      self.color = options[:color] || nil
-      self.bold = options[:bold] || false
-      self.underline = options[:underline] || false
-      self.reversed = options[:reversed] || false
-
-      raise ArgumentError unless self.width > 0
-      raise ArgumentError unless self.padding.to_s.match(/^\d+$/)
     end
 
     def size
-      self.width - 2 * self.padding
+      width - (2 * padding) + (3 * (span - 1))
     end
 
     def required_width
-      self.text.to_s.size + 2 * self.padding
+      text.to_s.size + 2 * padding
     end
 
     def screen_rows
-      if self.text.nil? || self.text.empty?
-        [' ' * self.width]
+      if text.nil? || text.empty?
+        [' ' * width]
       else
-        self.text.scan(/.{1,#{self.size}}/m).map {|s| to_cell(s)}
+        text.scan(/.{1,#{size}}/m).map { |s| to_cell(s) }
       end
     end
 
     private
 
+    def assign_alignment_defaults(options)
+      self.span = options[:span] || 1
+
+      self.width = options[:width] || 10
+      self.width = Integer(width)
+      self.width *= span
+
+      self.align = options[:align] || 'left'
+
+      self.padding = options[:padding] || 0
+      self.padding = Integer(padding)
+    end
+
+    def assign_color_defaults(options)
+      self.color = options[:color] || nil
+      self.bold = options[:bold] || false
+      self.underline = options[:underline] || false
+      self.reversed = options[:reversed] || false
+    end
+
     def to_cell(str)
       # NOTE: For making underline and reversed work Change so that based on the
       # unformatted text it determines how much spacing to add left and right
       # then colorize the cell text
       cell =  str.empty? ? blank_cell : aligned_cell(str)
-      padding_str = ' ' * self.padding
+      padding_str = ' ' * padding
       padding_str + colorize(cell) + padding_str
     end
 
     def blank_cell
-      ' ' * self.size
+      ' ' * size
     end
 
     def aligned_cell(str)
-      case self.align
+      case align
       when 'left'
-        str.ljust(self.size)
+        str.ljust(size)
       when 'right'
-        str.rjust(self.size)
+        str.rjust(size)
       when 'center'
-        str.ljust((self.size - str.size)/2.0 + str.size).rjust(self.size)
+        str.ljust((size - str.size) / 2.0 + str.size).rjust(size)
       end
     end
 
     def colorize(str)
-      str = str.send(color) if self.color
-      str = str.send('bold') if self.bold
+      str = str.send(color) if color
+      str = str.send('bold') if bold
       str
     end
   end

data/lib/command_line_reporter/formatter/nested.rb

@@ -6,18 +6,18 @@ module CommandLineReporter
     include Singleton
     include OptionsValidator
 
-    VALID_OPTIONS = [:message, :type, :complete, :indent_size, :color, :bold]
+    VALID_OPTIONS = %i[message type complete indent_size color bold].freeze
     attr_accessor :indent_size, :complete_string, :message_string, :color, :bold
 
     def format(options, block)
-      self.validate_options(options, *VALID_OPTIONS)
+      validate_options(options, *VALID_OPTIONS)
 
       indent_level :incr
 
-      padding = ' ' * @indent_level * (options[:indent_size] || self.indent_size)
+      padding = ' ' * @indent_level * (options[:indent_size] || indent_size)
 
-      message_str = padding + (options[:message] || self.message_string)
-      complete_str = options[:complete] || self.complete_string
+      message_str = padding + (options[:message] || message_string)
+      complete_str = options[:complete] || complete_string
 
       if options[:type] == 'inline'
         colorize("#{message_str}...", true, options)
@@ -51,17 +51,13 @@ module CommandLineReporter
       str = str.send(options[:color]) if options[:color]
       str = str.bold if options[:bold]
 
-      if inline
-        print str
-      else
-        puts str
-      end
+      inline ? print(str) : puts(str)
     end
 
     def indent_level(value)
       case value
       when :incr
-        @indent_level = (@indent_level) ? @indent_level + 1 : 0
+        @indent_level = @indent_level ? @indent_level + 1 : 0
       when :decr
         @indent_level -= 1
       end

data/lib/command_line_reporter/formatter/progress.rb

@@ -6,11 +6,11 @@ module CommandLineReporter
     include Singleton
     include OptionsValidator
 
-    VALID_OPTIONS = [:indicator, :color, :bold]
+    VALID_OPTIONS = %i[indicator color bold].freeze
     attr_accessor *VALID_OPTIONS
 
     def format(options, block)
-      self.validate_options(options, *VALID_OPTIONS)
+      validate_options(options, *VALID_OPTIONS)
 
       self.indicator = options[:indicator] if options[:indicator]
       self.color = options[:color]
@@ -22,10 +22,10 @@ module CommandLineReporter
     end
 
     def progress(override = nil)
-      str = override || self.indicator
+      str = override || indicator
 
-      str = str.send(self.color) if self.color
-      str = str.send('bold') if self.bold
+      str = str.send(color) if color
+      str = str.send('bold') if bold
 
       print str
     end

data/lib/command_line_reporter/row.rb

@@ -2,11 +2,11 @@ module CommandLineReporter
   class Row
     include OptionsValidator
 
-    VALID_OPTIONS = [:header, :color, :bold, :encoding]
+    VALID_OPTIONS = %i[header color bold encoding].freeze
     attr_accessor :columns, :border, *VALID_OPTIONS
 
     def initialize(options = {})
-      self.validate_options(options, *VALID_OPTIONS)
+      validate_options(options, *VALID_OPTIONS)
 
       self.columns = []
       self.border = false
@@ -17,29 +17,23 @@ module CommandLineReporter
     end
 
     def add(column)
-      if column.color.nil? && self.color
-        column.color = self.color
-      end
-
-      if self.bold || self.header
-        column.bold = true
-      end
-
-      self.columns << column
+      column.color = color if column.color.nil? && color
+      column.bold = true if bold || header
+      columns << column
     end
 
     def output
       screen_count.times do |sr|
         border_char = use_utf8? ? "\u2503" : '|'
 
-        line = (self.border) ? "#{border_char} " : ''
+        line = border ? "#{border_char} " : ''
 
-        self.columns.size.times do |mc|
-          col = self.columns[mc]
+        columns.size.times do |mc|
+          col = columns[mc]
           # Account for the fact that some columns will have more screen rows than their
           # counterparts in the row.  An example being:
-          # c1 = Column.new('x' * 50, :width => 10)
-          # c2 = Column.new('x' * 20, :width => 10)
+          # c1 = Column.new('x' * 50, width: 10)
+          # c2 = Column.new('x' * 20, width: 10)
           #
           # c1.screen_rows.size == 5
           # c2.screen_rows.size == 2
@@ -58,12 +52,12 @@ module CommandLineReporter
           if col.screen_rows[sr].nil?
             line << ' ' * col.width << ' '
           else
-            line << self.columns[mc].screen_rows[sr] << ' '
+            line << columns[mc].screen_rows[sr] << ' '
           end
 
-          if self.border
+          if border
             line << border_char
-            line << ' ' if mc < self.columns.size - 1
+            line << ' ' if mc < columns.size - 1
           end
         end
 
@@ -74,11 +68,11 @@ module CommandLineReporter
     private
 
     def screen_count
-      @sc ||= self.columns.inject(0) {|max,column| column.screen_rows.size > max ? column.screen_rows.size : max}
+      @sc ||= columns.inject(0) { |a, e| e.screen_rows.size > a ? e.screen_rows.size : a }
     end
 
     def use_utf8?
-      self.encoding == :unicode && "\u2501" != "u2501"
+      encoding == :unicode && "\u2501" != 'u2501'
     end
   end
 end