clin 0.3.0 → 0.4.0

data/lib/clin/text/table.rb

@@ -0,0 +1,270 @@
+require 'clin'
+require 'clin/text'
+
+# Table text builder
+class Clin::Text
+  # Helper class to display tables
+  class Table
+    # Header row(Nil for no header)
+    attr_writer :header
+
+    # List of rows in the table
+    attr_accessor :rows
+
+    # Column delimiters
+    # Can be either:
+    #  * 1 string: All the column delimiter will use this.
+    #  * list of string: The delimiters will be this list of string.
+    #    The size must be the column size - 1
+    attr_accessor :column_delimiters
+
+    # Global Row delimiter
+    # All the separator will default to this value
+    attr_accessor :row_delim
+
+    # Boolean if yes or no outside border shall be included
+    attr_accessor :border
+
+    # Column alignment. Can either be a global value(i.e. [Symbol])
+    # or a column specific with an array of [Symbol]
+    # * :left
+    # * :center
+    # * :right
+    attr_accessor :alignment
+
+    # If blank cell should be separated with the column separator.
+    attr_accessor :separate_blank
+
+    attr_accessor :column_length
+
+    # Create a new table
+    # @param col_delim [String] Set the column delimiter @see #column_delimiters
+    # @param row_delim [String] Set the row delimiter @see #row_delim
+    # @param border [String] Set border @see #border
+    # @param align [String] Set alignment @see #align
+    # @param separate_blank [Boolean] If the column separator should be added near blank cells
+    # @param block [Proc] Block with self passed as param.
+    def initialize(col_delim: ' | ', row_delim: '-',
+                   border: true, align: :left, separate_blank: true, &block)
+      @rows = []
+      @header = nil
+      @column_length = {}
+      @column_delimiters = col_delim
+      @row_delim = row_delim
+      @border = border
+      @separate_blank = separate_blank
+      @alignment = align
+      block.call(self) if block_given?
+    end
+
+    # Add a new row
+    # @param cells [Array<String>] Cells.
+    def row(*cells)
+      @rows << TableRow.new(self, cells)
+    end
+
+    # Set or get the header row.
+    # @param cells [Array<String>] Cells.
+    def header(*cells)
+      @header = TableRow.new(self, cells) if cells.any?
+      @header
+    end
+
+    # Add a separator row
+    # @param char [Char] Separator char. If nil will use the default row delimiter
+    def separator(char = nil)
+      @rows << TableSeparatorRow.new(self, char)
+    end
+
+    # Set or get the the column alignment
+    # @param args [Array|Symbol] List of alignment.
+    # ```
+    # t.align :center # => All column will be centered
+    # t.align :left, :center, :right #=> First column will be align left, second center, ...
+    # t.align []:left, :center, :right] #=> Equivalent
+    # ```
+    # @see #alignment
+    def align(*args)
+      @alignment = sym_or_array(*args) if args.any?
+      @alignment
+    end
+
+    # Set a specific column delimiter for all the column
+    def column_delimiter(*args)
+      @column_delimiters = sym_or_array(*args)
+    end
+
+    def border?
+      @border
+    end
+
+    def separate_blank?
+      separate_blank
+    end
+
+    def vertical_border
+      '|'
+    end
+
+    # Build the text object for this table.
+    def to_text
+      t = Clin::Text.new
+      unless @header.nil?
+        t.line @header.to_s
+        t.line TableSeparatorRow.new(self).to_s
+      end
+      t.lines @rows.map(&:to_s)
+      add_border(t) if border?
+      t
+    end
+
+    def to_s
+      to_text.to_s
+    end
+
+    def update_column_length(index, cell_length)
+      @column_length[index] ||= 0
+      @column_length[index] = [cell_length, @column_length[index]].max
+    end
+
+    def delimiter_at(index)
+      return '' if index >= @column_length.size - 1
+      if @column_delimiters.is_a? Array
+        @column_delimiters[index]
+      else
+        @column_delimiters
+      end
+    end
+
+    protected def sym_or_array(*args)
+      return args if args.empty?
+      args.flatten!
+      args.size == 1 ? args.first : args
+    end
+
+    # Add the top and bottom border to the lines
+    protected def add_border(text)
+      line = TableSeparatorRow.new(self, col_delimiter: false).to_s
+      text.prefix(line)
+      text.line line
+      text
+    end
+  end
+
+  # Table Row container class
+  class TableRow
+    include Enumerable
+
+    # List of cells in the row.
+    attr_accessor :cells
+
+    def initialize(table, cells)
+      @table = table
+      @cells = cells.flatten.each_with_index.map { |x, i| TableCell.new(table, i, x) }
+    end
+
+    def each(&block)
+      @table.column_length.size.times.each do |i|
+        block.call(@cells[i] || '')
+      end
+    end
+
+    def border(text, separator = '')
+      return text unless @table.border?
+      @table.vertical_border + separator + text + separator + @table.vertical_border
+    end
+
+    # Get the delimiter to insert after the cell at +index+
+    # @param index [Integer] Cell index.
+    # Will return the corresponding delimiter and for the last cell will return ''
+    def delimiter_at(index)
+      delim = @table.delimiter_at(index)
+      if !@table.separate_blank? && (@cells[index].blank? || @cells[index + 1].blank?)
+        delim = ' ' * delim.size
+      end
+      delim
+    end
+
+    def to_s
+      out = ''
+      each_with_index do |cell, i|
+        out << cell.to_s
+        out << delimiter_at(i)
+      end
+      border(out, ' ')
+    end
+  end
+
+  # Table row that is filled with the same character
+  class TableSeparatorRow < TableRow
+    # Char used for separation.
+    attr_accessor :char
+
+    def initialize(table, char = nil, col_delimiter: true)
+      super(table, [])
+      @char = char || @table.row_delim
+      @include_column_delimiter = col_delimiter
+    end
+
+    def delimiter_at(index)
+      col_delim = super(index)
+      @include_column_delimiter ? col_delim : (@char * col_delim.size)
+    end
+
+    def to_s
+      out = ''
+      each_with_index do |_, i|
+        out << @char * @table.column_length[i]
+        out << delimiter_at(i)
+      end
+      border(out, @char)
+    end
+  end
+
+  # Table cell container class
+  class TableCell
+    def initialize(table, index, value)
+      @table = table
+      @index = index
+      @value = value.to_s
+      @table.update_column_length(index, @value.length)
+    end
+
+    # Get the length of the cell
+    # @return [Integer]
+    def length
+      @table.column_length[@index]
+    end
+
+    def blank?
+      @value.blank?
+    end
+
+    # Get the alignment for this cell
+    # @return [Symbol]
+    # Can be:
+    # * :left
+    # * :center
+    # * :right
+    def align
+      return @table.align if @table.align.is_a? Symbol
+      fail Clin::Error, 'Align must either be a symbol or an Array!' unless @table.align.is_a? Array
+      @table.align[@index]
+    end
+
+    # Convert the cell to_s using the length of the column and the column alignment
+    # @return [String]
+    def to_s
+      case align
+      when :left
+        @value.to_s.ljust(length)
+      when :right
+        @value.to_s.rjust(length)
+      when :center
+        @value.to_s.center(length)
+      else
+        fail Clin::Error, "Invalid align #{align}"
+      end
+    end
+  end
+end

data/lib/clin/text.rb

@@ -0,0 +1,152 @@
+require 'clin'
+
+# Text builder class.
+# Text is designed for building dynamic text that need multiple lines
+# Help message and documentation are easily built with this.
+# ```
+# text = Clin::Text.new do
+#   line 'Usage:'
+#   indent 2 do
+#     line 'display Message'
+#     line 'print Message'
+#   end
+#   line 'Description: '
+#   line 'This is a description', indent: 3
+#   blank
+#   line 'Examples:'
+#   indent ' -' do
+#     line 'display Message'
+#     line 'print Message'
+#   end
+# end
+# puts text # =>
+# $ Usage:
+#     display Message
+#     print Message
+#   Description:
+#      This is a description
+#
+#   Examples:
+#    -display Message
+#    -print Message
+#
+# ```
+class Clin::Text
+  attr_accessor :_lines
+
+  # All the lines added to this text will be indented with this.
+  attr_accessor :global_indent
+
+  # List of block that listen for line added to the next builder.
+  attr_accessor :listeners
+
+  def initialize(indent: '', &block)
+    @_lines = []
+    @inital_indent = compute_indent(indent)
+    @global_indent = @inital_indent
+    @listeners = []
+    block.call(self) if block_given?
+  end
+
+  # Add a new line
+  # @param text [String] line to add
+  # @param indent [String|Integer] Indent the line with x spaces or the given text
+  # ```
+  # line('Some line')                 #=> 'Some line'
+  # line('Some line', indent: 3)      #=> '   Some line'
+  # line('Some line', indent: '- ')   #=> '- Some line'
+  # ```
+  def line(text, indent: '')
+    l = process_line(text, indent: indent)
+    @_lines << l
+    broadcast(l)
+    l
+  end
+
+  # Add a line at the beginning of the text
+  # @param text [String] line to add
+  # @param indent [String|Integer] Indent the line with x spaces or the given text
+  def prefix(text, indent: '')
+    l = process_line(text, indent: indent)
+    @_lines.unshift l
+    l
+  end
+
+  # Add a blank line n times
+  # @param times [Integer] Number of times to add the line.
+  def blank(times = 1)
+    @_lines += [''] * times
+    times.times.each { broadcast('') }
+  end
+
+  # Add a list of string as lines or get the existing lines.
+  # @param array [Array<String>] List of lines to add.
+  # @param indent [String|Integer] Indent each line. @see #line
+  # @return list of lines
+  def lines(array = [], indent: '')
+    array.each do |l|
+      line(l, indent: indent)
+    end
+    @_lines
+  end
+
+  # Add the content of another Clin::Text object
+  # @param text [Clin::Text]
+  # @param indent [String|Integer] Indent the content
+  def text(text, indent: '')
+    lines(text._lines, indent: indent)
+  end
+
+  # Indent all the content inside this block.
+  # @param indent [String|Integer] indent value
+  # @param block [Proc] Callback.
+  def indent(indent, &block)
+    previous_indent = @global_indent
+    @global_indent += compute_indent(indent)
+    block.call(self)
+    @global_indent = previous_indent
+  end
+
+  def table(indent: '', **options, &block)
+    text Clin::Text::Table.new(**options, &block).to_text, indent: indent
+  end
+
+  # Join the lines together to form the output
+  # @return [String]
+  def to_s
+    "#{@_lines.join("\n")}\n"
+  end
+
+  def process_line(text, indent: '')
+    indent = compute_indent(indent)
+    "#{global_indent}#{indent}#{text}"
+  end
+
+  def on(&block)
+    @listeners << block
+  end
+
+  # Call the the listener with the newly added line
+  def broadcast(line)
+    @listeners.each do |block|
+      block.call(line)
+    end
+  end
+
+  def ==(other)
+    return to_s == other if other.is_a? String
+    return false unless other.is_a? Clin::Text
+    @_lines == other._lines && @global_indent == other.global_indent
+  end
+
+  alias_method :eql?, :==
+
+  # Process the indent.
+  # If the indent is an integer it will return +indent+ spaces
+  # @return [String.]
+  protected def compute_indent(indent)
+    indent.is_a?(Integer) ? ' ' * indent : indent
+  end
+end
+
+require 'clin/text/table'

data/lib/clin/version.rb

@@ -1,4 +1,4 @@
 # Clin version
 module Clin
-  VERSION = '0.3.0'
+  VERSION = '0.4.0'
 end

data/lib/clin.rb

@@ -1,6 +1,5 @@
 require 'active_support'
 require 'active_support/core_ext'
-require 'optparse'
 require 'readline'
 require 'clin/version'
 
@@ -13,6 +12,9 @@ module Clin
     # Set the command when comparing 2 files(Used in the shell)
     attr_writer :diff_cmd
 
+    # If the line reader should use Readline(For autocomplete and history)
+    attr_writer :use_readline
+
     def default_exe_name
       'command'
     end
@@ -26,11 +28,16 @@ module Clin
     def diff_cmd
       @diff_cmd ||= 'diff -u'
     end
+
+    def use_readline?
+      @use_readline ||= !ENV['CLIN_NO_READLINE']
+    end
   end
 end
 
 require 'clin/command_mixin'
 require 'clin/command'
+require 'clin/option_parser'
 require 'clin/command_parser'
 require 'clin/general_option'
 require 'clin/command_dispatcher'
@@ -38,4 +45,6 @@ require 'clin/common/help_options'
 require 'clin/errors'
 require 'clin/option'
 require 'clin/option_list'
+require 'clin/text'
 require 'clin/shell'
+require 'clin/line_reader'

data/spec/clin/command_dispacher_spec.rb

@@ -57,7 +57,7 @@ RSpec.describe Clin::CommandDispatcher do
 
     context 'when first command return FixedArgumentError' do
       before do
-        allow(cmd1).to receive(:parse) { fail Clin::FixedArgumentError, :some }
+        allow(cmd1).to receive(:parse) { fail Clin::RequiredArgumentError, :some }
         subject.parse(args)
       end
       it { expect(cmd1).to have_received(:parse).with(args, fallback_help: false) }

data/spec/clin/command_mixin/options_spec.rb

@@ -43,25 +43,48 @@ RSpec.describe Clin::CommandMixin::Options do
     it { expect(subject.general_options.values.first).to eq(true) }
   end
 
-  describe '#register_options' do
+  describe '#options' do
     subject { new_subject }
-    let(:opt1) { double(:option, register: true) }
-    let(:opt2) { double(:option, register: true) }
-    let(:g_opt_cls) { double(:general_option_class, register_options: true) }
-    let(:g_opt) { double(:general_option, class: g_opt_cls) }
-    let(:opts) { double(:options) }
-    let(:out) { double(:out) }
-    before do
-      subject.add_option(opt1)
-      subject.add_option(opt2)
-      subject.general_options = {g_opt_cls => g_opt}
+    let(:option1) { double(:option1) }
+    let(:option2) { double(:option2) }
+    let(:option3) { double(:option3) }
+    let(:option4) { double(:option4) }
+    let(:general_option1) do
+      opt = Class.new(Clin::GeneralOption)
+      opt.add_option option3
+      opt.add_option option4
+      opt
+    end
+
+    let(:general_option2) do
+      opt = Class.new(Clin::GeneralOption)
+      opt.general_option general_option1
+      opt
+    end
 
-      subject.register_options(opts, out)
+    it 'get every options' do
+      subject.add_option option1
+      subject.add_option option2
+      expect(subject.options).to eq([option1, option2])
     end
 
-    it { expect(opt1).to have_received(:register).with(opts, out) }
-    it { expect(opt2).to have_received(:register).with(opts, out) }
-    it { expect(g_opt_cls).to have_received(:register_options).with(opts, out) }
+    it 'get every general option options' do
+      subject.general_option general_option1
+      expect(subject.options).to eq([option3, option4])
+    end
+
+    it 'get every options and general option options' do
+      subject.add_option option1
+      subject.add_option option2
+      subject.general_option general_option1
+      expect(subject.options).to eq([option1, option2, option3, option4])
+    end
 
+    it 'get nested general options' do
+      subject.add_option option1
+      subject.add_option option2
+      subject.general_option general_option2
+      expect(subject.options).to eq([option1, option2, option3, option4])
+    end
   end
 end

data/spec/clin/command_parser_spec.rb

@@ -12,10 +12,15 @@ RSpec.describe Clin::CommandParser do
     subject { Clin::CommandParser.new(@command, []) }
 
     it 'raise argument when option value is missing' do
-      expect { subject.parse_options(%w(--name)) }.to raise_error(OptionParser::MissingArgument)
+      subject.parse_options(%w(--name))
+      expect(subject.valid?).to be false
+      expect(subject.errors.first).to be_a(Clin::MissingOptionArgumentError)
     end
-    it 'raise error when unknown option' do
-      expect { subject.parse_options(%w(--other)) }.to raise_error(Clin::OptionError)
+
+    it 'add error when unknown option' do
+      subject.parse_options(%w(--other))
+      expect(subject.errors.size).to be 1
+      expect(subject.errors.first).to be_a(Clin::OptionError)
     end
 
     it { expect(subject.parse_options(%w(--name MyName))).to eq(name: 'MyName') }
@@ -25,7 +30,7 @@ RSpec.describe Clin::CommandParser do
 
     it { expect(subject.parse_options(%w(-v))).to eq(verbose: true) }
 
-    it { expect(subject.parse_options(%w(--echo))).to eq(echo: nil) }
+    it { expect(subject.parse_options(%w(--echo))).to eq(echo: true) }
     it { expect(subject.parse_options(%w(-e EchoThis))).to eq(echo: 'EchoThis') }
   end
 
@@ -39,14 +44,21 @@ RSpec.describe Clin::CommandParser do
     subject { Clin::CommandParser.new(@command, []) }
 
     it 'raise argument when fixed in different' do
-      expect { subject.parse_arguments(%w(other val opt)) }.to raise_error(Clin::CommandLineError)
+      subject.parse_arguments(%w(other val opt))
+      expect(subject.valid?).to be false
+      expect(subject.errors.first).to be_a Clin::CommandLineError
     end
+
     it 'raise error when too few arguments' do
-      expect { subject.parse_arguments(['fix']) }.to raise_error(Clin::CommandLineError)
+      subject.parse_arguments(%w(fix))
+      expect(subject.valid?).to be false
+      expect(subject.errors.first).to be_a Clin::CommandLineError
     end
+
     it 'raise error when too much argument' do
-      expect { subject.parse_arguments(%w(other val opt more)) }
-        .to raise_error(Clin::CommandLineError)
+      subject.parse_arguments(%w(other val opt more))
+      expect(subject.valid?).to be false
+      expect(subject.errors.first).to be_a Clin::CommandLineError
     end
 
     it 'map arguments' do
@@ -58,43 +70,6 @@ RSpec.describe Clin::CommandParser do
     end
   end
 
-  describe '#skipped_options' do
-    def skipped_options(argv)
-      Clin::CommandParser.new(@command, argv).skipped_options
-    end
-
-    before :all do
-      @command = Class.new(Clin::Command)
-      @command.skip_options true
-    end
-
-    context 'when all options should be skipped' do
-      it { expect(skipped_options(%w(pos arg))).to eq([]) }
-
-      it { expect(skipped_options(%w(pos arg --ignore -t))).to eq(%w(--ignore -t)) }
-
-      it { expect(skipped_options(%w(pos arg --ignore value -t))).to eq(%w(--ignore value -t)) }
-
-    end
-    context 'when option are define they should not be skipped' do
-      before :all do
-        @command.flag_option :verbose, 'Verbose'
-      end
-
-      it { expect(skipped_options(%w(pos arg --ignore value -t -v))).to eq(%w(--ignore value -t)) }
-
-      it do
-        expect(skipped_options(%w(pos arg --verbose --ignore value -t)))
-          .to eq(%w(--ignore value -t))
-      end
-
-      it do
-        expect(skipped_options(%w(pos arg --ignore value --verbose -t)))
-          .to eq(%w(--ignore value -t))
-      end
-    end
-  end
-
   describe '.handle_dispatch' do
     let(:args) { [Faker::Lorem.word, Faker::Lorem.word] }
     before :all do
@@ -132,12 +107,14 @@ RSpec.describe Clin::CommandParser do
     context 'when using commands' do
       let(:cmd1) { double(:command_mixin) }
       let(:cmd2) { double(:command_mixin) }
+      let(:dispatcher) { double(:dispatcher, parse: true) }
       before do
         @command.dispatch :args, commands: [cmd1, cmd2]
-        allow_any_instance_of(Clin::CommandDispatcher).to receive(:initialize)
       end
+
       it 'call the command dispatcher with the right arguments' do
-        expect_any_instance_of(Clin::CommandDispatcher).to receive(:initialize).once.with([cmd1, cmd2])
+        expect(Clin::CommandDispatcher)
+          .to receive(:new).once.with([cmd1, cmd2]).and_return(dispatcher)
         subject.redispatch(remote: 'remote', args: args)
       end
     end
@@ -146,19 +123,18 @@ RSpec.describe Clin::CommandParser do
       let(:new_message) { Faker::Lorem.sentence }
       before do
         @command.dispatch :args
-        allow_any_instance_of(Clin::CommandDispatcher).to receive(:initialize)
+        allow_any_instance_of(Clin::CommandDispatcher).to receive(:new)
         allow_any_instance_of(Clin::CommandDispatcher).to receive(:parse) do
           fail Clin::HelpError, 'Dispatcher error'
         end
-        allow(@command).to receive(:option_parser).and_return(new_message)
+        allow(@command).to receive(:help).and_return(new_message)
       end
       it do
         expect { subject.redispatch(remote: 'remote', args: args) }
           .to raise_error(Clin::HelpError)
       end
       it do
-        expect { subject.redispatch(remote: 'remote', args: args) }
-          .to raise_error(new_message)
+        expect { subject.redispatch(remote: 'remote', args: args) }.to raise_error(new_message)
       end
     end
   end