clin 0.3.0 → 0.4.0

data/spec/clin/text/table_row_spec.rb

@@ -0,0 +1,74 @@
+require 'spec_helper'
+
+RSpec.describe Clin::Text::TableRow do
+  def table_double(options)
+    double(:table, options.reverse_merge(column_length: {}, update_column_length: true,
+                                         separate_blank?: true))
+  end
+
+  describe '#each' do
+    let(:table) { table_double(column_length: double(:col_length, size: size)) }
+    subject { Clin::Text::TableRow.new(table, %w(a b c)) }
+
+    before do
+      allow(Clin::Text::TableCell).to receive(:new) do |_table, _index, val|
+        val
+      end
+    end
+    context 'when same number of column as cells' do
+      let(:size) { 3 }
+      it { expect { |b| subject.each(&b) }.to yield_control.exactly(size).times }
+      it { expect { |b| subject.each(&b) }.to yield_successive_args('a', 'b', 'c') }
+    end
+
+    context 'when there are more column that cells in the rows' do
+      let(:size) { 5 }
+      it { expect { |b| subject.each(&b) }.to yield_control.exactly(size).times }
+      it { expect { |b| subject.each(&b) }.to yield_successive_args('a', 'b', 'c', '', '') }
+    end
+  end
+
+  describe '#border' do
+    let(:table) { table_double(vertical_border: '|', border?: border) }
+    subject { Clin::Text::TableRow.new(table, []) }
+    context 'when border is enabled' do
+      let(:border) { true }
+
+      it { expect(subject.border('value')).to eq('|value|') }
+      it { expect(subject.border('value', ' ')).to eq('| value |') }
+    end
+
+    context 'when border is not enabled' do
+      let(:border) { false }
+
+      it { expect(subject.border('value')).to eq('value') }
+      it { expect(subject.border('value', ' ')).to eq('value') }
+    end
+  end
+
+  describe '#to_s' do
+    let(:table) { Clin::Text::Table.new(col_delim: delimiter, border: border) }
+    subject { Clin::Text::TableRow.new(table, %w(val1 val2 val3)) }
+
+    context 'when no border' do
+      let(:border) { false }
+      let(:delimiter) { ' [] ' }
+
+      it { expect(subject.to_s).to eq('val1 [] val2 [] val3') }
+    end
+
+    context 'when border' do
+      let(:border) { true }
+      let(:delimiter) { ' [] ' }
+
+      it { expect(subject.to_s).to eq('| val1 [] val2 [] val3 |') }
+    end
+
+    context 'when no border and specific delimiter' do
+      let(:border) { false }
+      let(:delimiter) { [' # ', ' $ '] }
+
+      it { expect(subject.to_s).to eq('val1 # val2 $ val3') }
+    end
+  end
+end

data/spec/clin/text/table_separator_row_spec.rb

@@ -0,0 +1,82 @@
+require 'spec_helper'
+
+RSpec.describe Clin::Text::TableSeparatorRow do
+  def table_double(options)
+    double(:table, options.reverse_merge(column_length: {}, update_column_length: true,
+                                         separate_blank?: true))
+  end
+
+  describe '#delimiter_at' do
+    let(:table) do
+      Clin::Text::Table.new do |t|
+        t.row %w(a b c d) # 4 columns(i.e. 3 Delimiters)
+        t.column_delimiter delimiter
+      end
+    end
+
+    subject { Clin::Text::TableSeparatorRow.new(table, '-', col_delimiter: include_column) }
+    context 'when not include column delimiter' do
+      let(:include_column) { false }
+      let(:delimiter) { ' | ' }
+
+      it { expect(subject.delimiter_at(0)).to eq('---') }
+      it { expect(subject.delimiter_at(1)).to eq('---') }
+      it { expect(subject.delimiter_at(2)).to eq('---') }
+      it { expect(subject.delimiter_at(3)).to eq('') }
+      it { expect(subject.delimiter_at(10)).to eq('') }
+
+    end
+    context 'when include column delimiter' do
+      let(:include_column) { true }
+
+      context 'when column delimiter is a global value' do
+        let(:delimiter) { ' # ' }
+        it { expect(subject.delimiter_at(0)).to eq(delimiter) }
+        it { expect(subject.delimiter_at(1)).to eq(delimiter) }
+        it { expect(subject.delimiter_at(2)).to eq(delimiter) }
+        it { expect(subject.delimiter_at(3)).to eq('') }
+        it { expect(subject.delimiter_at(10)).to eq('') }
+      end
+
+      context 'when column delimiter is a specific' do
+        let(:delimiter) { [' # ', ' | ', ' [] '] }
+        it { expect(subject.delimiter_at(0)).to eq(delimiter[0]) }
+        it { expect(subject.delimiter_at(1)).to eq(delimiter[1]) }
+        it { expect(subject.delimiter_at(2)).to eq(delimiter[2]) }
+        it { expect(subject.delimiter_at(3)).to eq('') }
+        it { expect(subject.delimiter_at(10)).to eq('') }
+      end
+    end
+  end
+
+  describe '#to_s' do
+    let(:delimiter) { ' | ' }
+    let(:table) do
+      Clin::Text::Table.new(col_delim: delimiter, border: border) do |t|
+        t.column_length = [4, 4, 4]
+      end
+    end
+    subject { Clin::Text::TableSeparatorRow.new(table, col_delimiter: include_column) }
+
+    context 'when not including column delimiter' do
+      let(:include_column) { false }
+      let(:border) { false }
+
+      it { expect(subject.to_s).to eq('------------------') }
+    end
+
+    context 'when including column delimiter' do
+      let(:include_column) { true }
+      let(:border) { false }
+
+      it { expect(subject.to_s).to eq('---- | ---- | ----') }
+    end
+
+    context 'when border' do
+      let(:include_column) { true }
+      let(:border) { true }
+
+      it { expect(subject.to_s).to eq('|----- | ---- | -----|') }
+    end
+  end
+end

data/spec/clin/text/table_spec.rb

@@ -0,0 +1,259 @@
+require 'spec_helper'
+
+RSpec.describe Clin::Text::Table do
+  describe '#row' do
+    before do
+      subject.row(%w(a b c))
+      subject.row(%w(a2 b2 c2))
+    end
+
+    it { expect(subject.rows.size).to be 2 }
+    it { expect(subject.rows.first).to be_a Clin::Text::TableRow }
+    it { expect(subject.rows.first.cells.size).to be 3 }
+  end
+
+  describe '#header' do
+    before do
+      subject.header(%w(a b c))
+    end
+
+    it { expect(subject.rows).to be_empty }
+    it { expect(subject.header).to be_a Clin::Text::TableRow }
+    it { expect(subject.header.cells.size).to be 3 }
+  end
+
+  describe '#separator' do
+    before do
+      subject.row(%w(a b c))
+      subject.separator
+      subject.separator('=')
+    end
+
+    it { expect(subject.rows.size).to be 3 }
+    it { expect(subject.rows[1]).to be_a Clin::Text::TableSeparatorRow }
+    it { expect(subject.rows[2]).to be_a Clin::Text::TableSeparatorRow }
+    it { expect(subject.rows[2].char).to eq '=' }
+  end
+
+  describe '#align' do
+    it 'set global alignment' do
+      subject.align(:center)
+      expect(subject.alignment).to eq :center
+    end
+
+    it 'set column alignment' do
+      subject.align(*[:center, :left, :right])
+      expect(subject.alignment).to eq [:center, :left, :right]
+    end
+  end
+
+  describe '#column_delimiter' do
+    it 'set global delimiter' do
+      subject.column_delimiter(' # ')
+      expect(subject.column_delimiters).to eq(' # ')
+    end
+
+    it 'set column delimiter' do
+      subject.column_delimiter(*[' # ', ' O ', ' [] '])
+      expect(subject.column_delimiters).to eq [' # ', ' O ', ' [] ']
+    end
+  end
+
+  describe '#update_column_length' do
+    it 'set the value' do
+      subject.update_column_length(1, 12)
+      expect(subject.column_length).to eq({1 => 12})
+    end
+
+    it 'set overwrite smaller value' do
+      subject.update_column_length(1, 12)
+      subject.update_column_length(1, 24)
+      expect(subject.column_length).to eq({1 => 24})
+    end
+
+    it 'set keep larger value' do
+      subject.update_column_length(1, 12)
+      subject.update_column_length(1, 6)
+      expect(subject.column_length).to eq({1 => 12})
+    end
+  end
+
+  describe '#sym_or_array' do
+    it 'return symbol when symbol given' do
+      expect(subject.send(:sym_or_array, :sym)).to eq(:sym)
+    end
+
+    it 'return array when multiple arguments given' do
+      expect(subject.send(:sym_or_array, :sym1, :sym2, :sym3)).to eq([:sym1, :sym2, :sym3])
+    end
+
+    it 'return array when array given' do
+      expect(subject.send(:sym_or_array, [:sym1, :sym2, :sym3])).to eq([:sym1, :sym2, :sym3])
+    end
+
+    it 'return array when array and arguments given' do
+      expect(subject.send(:sym_or_array, [:sym1, :sym2], :sym3)).to eq([:sym1, :sym2, :sym3])
+    end
+  end
+
+  describe '#add_border' do
+    let(:text) { double(:text, line: true, prefix: true) }
+    let (:line) { '====----====' }
+    before do
+      allow(Clin::Text::TableSeparatorRow).to receive(:new).and_return(line)
+      subject.send(:add_border, text)
+    end
+    it { expect(text).to have_received(:line).with(line) }
+    it { expect(text).to have_received(:prefix).with(line) }
+  end
+
+  describe '#to_text' do
+    let(:header) { %w(Header1 Header2 Header3) }
+    let(:row1) { %w(First1 First2 First3) }
+    let(:row2) { %w(Second1 Second2 SecondThird) }
+
+    before do
+      subject.border = false
+      subject.row row1
+      subject.row row2
+    end
+
+    it 'make a text with only the given row' do
+      expect(subject.to_text._lines.size).to be 2
+    end
+
+    it 'add 2 rows for header' do
+      subject.header header
+      expect(subject.to_text._lines.size).to be 4
+    end
+
+    it 'add 2 rows for border' do
+      subject.border = true
+      expect(subject.to_text._lines.size).to be 4
+    end
+  end
+
+
+  describe '#delimiter_at' do
+    before do
+      subject.row %w(a b c d) # 4 columns(i.e. 3 Delimiters)
+      subject.column_delimiter delimiter
+    end
+    context 'when delimiter is a global value' do
+      let(:delimiter) { ' # ' }
+      it { expect(subject.delimiter_at(0)).to eq(delimiter) }
+      it { expect(subject.delimiter_at(3)).to eq('') }
+      it { expect(subject.delimiter_at(10)).to eq('') }
+    end
+
+    context 'when delimiter is a global value' do
+      let(:delimiter) { ' # ' }
+      it { expect(subject.delimiter_at(0)).to eq(delimiter) }
+      it { expect(subject.delimiter_at(1)).to eq(delimiter) }
+      it { expect(subject.delimiter_at(2)).to eq(delimiter) }
+      it { expect(subject.delimiter_at(3)).to eq('') }
+      it { expect(subject.delimiter_at(10)).to eq('') }
+    end
+
+    context 'when delimiter is a specific' do
+      let(:delimiter) { [' # ', ' | ', ' [] '] }
+      it { expect(subject.delimiter_at(0)).to eq(delimiter[0]) }
+      it { expect(subject.delimiter_at(1)).to eq(delimiter[1]) }
+      it { expect(subject.delimiter_at(2)).to eq(delimiter[2]) }
+      it { expect(subject.delimiter_at(3)).to eq('') }
+      it { expect(subject.delimiter_at(10)).to eq('') }
+    end
+  end
+
+  describe '#to_s' do
+    subject do
+      Clin::Text::Table.new(border: false) do |t|
+        t.align :right, :center, :left
+        # t.column_delimiter ' - ', ' # '
+        t.header %w(First Last Email)
+
+        t.row %w(Timothee Guerin timothee.guerin@outlook.com)
+        t.row %w(Some Guy Some.Guy@outlook.com)
+
+        t.separator
+
+        t.row %w(VeryLongFirstName Guy Some.Other@outlook.com)
+      end
+    end
+
+    context 'when include border' do
+      it 'build the table' do
+        subject.border = true
+        expect(subject.to_s).to eq <<table
+|----------------------------------------------------------|
+|             First |  Last  | Email                       |
+|------------------ | ------ | ----------------------------|
+|          Timothee | Guerin | timothee.guerin@outlook.com |
+|              Some |  Guy   | Some.Guy@outlook.com        |
+|------------------ | ------ | ----------------------------|
+| VeryLongFirstName |  Guy   | Some.Other@outlook.com      |
+|----------------------------------------------------------|
+table
+      end
+    end
+
+    context 'when no border' do
+      before do
+        subject.border = false
+      end
+
+      it 'build the table' do
+        out = <<table
+            First |  Last  | Email
+----------------- | ------ | ---------------------------
+         Timothee | Guerin | timothee.guerin@outlook.com
+             Some |  Guy   | Some.Guy@outlook.com
+----------------- | ------ | ---------------------------
+VeryLongFirstName |  Guy   | Some.Other@outlook.com
+table
+        # Need to rstrip because trailing whitespace are being removed automatically by editor
+        expect(subject.to_s.split("\n").map(&:rstrip)).to eq out.split("\n").map(&:rstrip)
+      end
+    end
+
+    context 'when custom column delimiter' do
+      before do
+        subject.border = true
+        subject.column_delimiter ' - ', ' # '
+      end
+
+      it 'build the table' do
+        expect(subject.to_s).to eq <<table
+|----------------------------------------------------------|
+|             First -  Last  # Email                       |
+|------------------ - ------ # ----------------------------|
+|          Timothee - Guerin # timothee.guerin@outlook.com |
+|              Some -  Guy   # Some.Guy@outlook.com        |
+|------------------ - ------ # ----------------------------|
+| VeryLongFirstName -  Guy   # Some.Other@outlook.com      |
+|----------------------------------------------------------|
+table
+      end
+    end
+
+    context 'when align all to the right' do
+      before do
+        subject.border = true
+        subject.align :right
+      end
+
+      it 'build the table' do
+        expect(subject.to_s).to eq <<table
+|----------------------------------------------------------|
+|             First |   Last |                       Email |
+|------------------ | ------ | ----------------------------|
+|          Timothee | Guerin | timothee.guerin@outlook.com |
+|              Some |    Guy |        Some.Guy@outlook.com |
+|------------------ | ------ | ----------------------------|
+| VeryLongFirstName |    Guy |      Some.Other@outlook.com |
+|----------------------------------------------------------|
+table
+      end
+    end
+  end
+end

data/spec/clin/text_spec.rb

@@ -0,0 +1,158 @@
+require 'spec_helper'
+
+RSpec.describe Clin::Text do
+  describe '#process_line' do
+    let (:line) { Faker::Lorem::sentence }
+    context 'when global indent is not set' do
+      subject { Clin::Text.new }
+
+      it 'return the same line with no indent' do
+        expect(subject.process_line(line)).to eq(line)
+      end
+
+      it 'add a new line and indent' do
+        expect(subject.process_line(line, indent: 2)).to eq("  #{line}")
+      end
+    end
+
+    context 'when global indent is set' do
+      subject { Clin::Text.new(indent: '**') }
+
+      it 'add line with global indent' do
+        expect(subject.process_line(line)).to eq("**#{line}")
+      end
+
+      it 'add line with global indent and method indent' do
+        expect(subject.process_line(line, indent: 2)).to eq("**  #{line}")
+      end
+    end
+  end
+
+  describe '#line' do
+    let (:line1) { Faker::Lorem::sentence }
+    let (:line2) { Faker::Lorem::sentence }
+
+    before do
+      subject.line(line1)
+      subject.line(line2)
+    end
+
+    it { expect(subject.lines.size).to be 2 }
+    it { expect(subject.lines[0]).to eq line1 }
+    it { expect(subject.lines[1]).to eq line2 }
+  end
+
+  describe '#prefix' do
+    let (:line1) { Faker::Lorem::sentence }
+    let (:line2) { Faker::Lorem::sentence }
+
+    before do
+      subject.line(line1)
+      subject.prefix(line2)
+    end
+
+    it { expect(subject.lines.size).to be 2 }
+    it { expect(subject.lines[0]).to eq line2 }
+    it { expect(subject.lines[1]).to eq line1 }
+  end
+
+  describe '#blank' do
+    it 'add 1 blank line' do
+      subject.blank
+      expect(subject.lines).to eq([''])
+    end
+
+    it 'add multiple blank line' do
+      subject.blank(3)
+      expect(subject.lines).to eq(['', '', ''])
+    end
+  end
+
+  describe '#lines' do
+    let (:lines) { [Faker::Lorem::sentence, Faker::Lorem::sentence] }
+    it 'add lines' do
+      subject.lines(lines)
+      expect(subject.lines).to eq(lines)
+    end
+
+    it 'add lines and indent' do
+      subject.lines(lines, indent: '**')
+      expect(subject.lines).to eq(lines.map { |x| "**#{x}" })
+    end
+  end
+
+  describe '#text' do
+    let (:lines) { [Faker::Lorem::sentence, Faker::Lorem::sentence] }
+
+    let (:text) do
+      text_lines = lines
+      Clin::Text.new do |t|
+        t.lines(text_lines)
+      end
+    end
+
+    it 'add text' do
+      subject.text(text)
+      expect(subject.lines).to eq(lines)
+    end
+
+    it 'add text and indent' do
+      subject.text(text, indent: '**')
+      expect(subject.lines).to eq(lines.map { |x| "**#{x}" })
+    end
+  end
+
+  describe '#indent' do
+    let (:line) { Faker::Lorem::sentence }
+
+    it 'add an indented line inside block' do
+      subject.indent 2 do
+        subject.line(line)
+      end
+      expect(subject.lines).to eq(["  #{line}"])
+    end
+
+    it 'add line with nested indent' do
+      subject.indent 2 do
+        subject.line(line)
+        subject.indent '***' do
+          subject.line(line)
+        end
+        subject.line(line)
+      end
+      expect(subject.lines).to eq(["  #{line}", "  ***#{line}", "  #{line}"])
+    end
+  end
+
+
+  describe '#to_s' do
+    let (:line1) { Faker::Lorem::sentence }
+    let (:line2) { Faker::Lorem::sentence }
+    let (:line3) { Faker::Lorem::sentence }
+
+    it 'join line with \n' do
+      subject.line line1
+      subject.line line2
+      subject.prefix line3
+      expect(subject.to_s).to eq("#{line3}\n#{line1}\n#{line2}\n")
+    end
+  end
+
+  describe '#on' do
+    it 'register a new callback' do
+      b = proc { |line|}
+      subject.on(&b)
+      expect(subject.listeners).to eq([b])
+    end
+  end
+
+  describe '#broadcast' do
+    it 'register a new callback' do
+      b = proc { |line|}
+      subject.on(&b)
+      subject.on(&b)
+      expect(b).to receive(:call).with('some line').twice
+      subject.broadcast('some line')
+    end
+  end
+end

data/spec/examples/list_option_spec.rb

@@ -6,8 +6,12 @@ RSpec.describe 'list_option.rb' do
   it { expect(ListCommand.parse('').params).to eq(echo: [], line: 0) }
   it { expect(ListCommand.parse('--echo msg').params).to eq(echo: ['msg'], line: 0) }
   it { expect(ListCommand.parse('--line').params).to eq(echo: [], line: 1) }
-  it { expect(ListCommand.parse('--line --line').params).to eq(echo: [], line: 2) }
-  it { expect(ListCommand.parse('-lll').params).to eq(echo: [], line: 3) }
+  it {
+    expect(ListCommand.parse('--line --line').params).to eq(echo: [], line: 2)
+  }
+  it {
+    expect(ListCommand.parse('-lll').params).to eq(echo: [], line: 3)
+  }
   it do
     expect(ListCommand.parse('--echo msg1 --echo msg2').params)
       .to eq(echo: %w(msg1 msg2), line: 0)

data/spec/examples/reusable_options_spec.rb

@@ -0,0 +1,21 @@
+require 'spec_helper'
+require 'examples/reusable_options'
+
+RSpec.describe 'reusable_options.rb' do
+  def parse(str)
+    ReusableOptionCommand.parse(str).params
+  end
+
+  suppress_puts
+  it { expect(parse('--verbose')).to eq(verbose: true) }
+  it { expect(parse('--echo "Hello world!"')).to eq(echo: 'Hello world!') }
+  it { expect(parse('--source "~/source"')).to eq(source: '~/source') }
+  it { expect(parse('--echo "Hello world!" --source "~/source"'))
+         .to eq(echo: 'Hello world!', source: '~/source') }
+  it { expect(parse('--source "~/source" -v --echo "Hello world!"'))
+         .to eq(echo: 'Hello world!', verbose: true, source: '~/source') }
+  it { expect(parse('-s"~/source" -v --echo "Hello world!"'))
+         .to eq(echo: 'Hello world!', verbose: true, source: '~/source') }
+
+
+end

data/spec/examples/simple_spec.rb

@@ -4,28 +4,28 @@ require 'examples/simple'
 RSpec.describe 'simple_spec.rb' do
   suppress_puts
   it { expect(SimpleCommand.parse('display Some').params).
-      to eq(display: 'display', message: 'Some') }
+    to eq(display: 'display', message: 'Some') }
   it { expect(SimpleCommand.parse('display "Message with spaces"').params).
-      to eq(display: 'display', message: 'Message with spaces') }
+    to eq(display: 'display', message: 'Message with spaces') }
 
   it { expect(SimpleCommand.parse('display Some -e More').params).
-      to eq(display: 'display', message: 'Some', echo: 'More') }
+    to eq(display: 'display', message: 'Some', echo: 'More') }
 
   it { expect(SimpleCommand.parse('display Some -eMore').params).
-      to eq(display: 'display', message: 'Some', echo: 'More') }
+    to eq(display: 'display', message: 'Some', echo: 'More') }
 
   it { expect(SimpleCommand.parse('display Some -e "Even More"').params).
-      to eq(display: 'display', message: 'Some', echo: 'Even More') }
+    to eq(display: 'display', message: 'Some', echo: 'Even More') }
 
   it { expect(SimpleCommand.parse('display Some --echo More').params).
-      to eq(display: 'display', message: 'Some', echo: 'More') }
+    to eq(display: 'display', message: 'Some', echo: 'More') }
 
   it { expect(SimpleCommand.parse('display Some --echo=More').params).
-      to eq(display: 'display', message: 'Some', echo: 'More') }
+    to eq(display: 'display', message: 'Some', echo: 'More') }
 
   it { expect(SimpleCommand.parse('display Some --echo "Even More"').params).
-      to eq(display: 'display', message: 'Some', echo: 'Even More') }
+    to eq(display: 'display', message: 'Some', echo: 'Even More') }
 
   it { expect { SimpleCommand.parse('').params }.to raise_error(Clin::HelpError) }
   it { expect { SimpleCommand.parse('-h').params }.to raise_error(Clin::HelpError) }
-end
+end

data/spec/spec_helper.rb

@@ -1,5 +1,6 @@
-require 'coveralls'
-Coveralls.wear!
+require 'codeclimate-test-reporter'
+CodeClimate::TestReporter.start
+
 $LOAD_PATH.push File.expand_path('../..', __FILE__)
 $LOAD_PATH.push File.expand_path('../../lib', __FILE__)
 require 'rspec'