cliprompt 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 03cc6802622eb3c7eb64f31d500a384f5d1ef049
-  data.tar.gz: 20bdbb38baf9f01106dc7f969346467ac6b20a61
+  metadata.gz: 8f310eea2a9640504286446d80f3fe6d22a65607
+  data.tar.gz: 187a52dd0480192fe77571d0b937f8c2b4c66c4c
 SHA512:
-  metadata.gz: 58a33b33150b6dd8722725ba1be6c55c77c9b9fb36b9b1ebaad9b7b183c5c3da84e020d065c701d59a092f68550d089044ef1294870b7beb7a43cf7ab2d3881f
-  data.tar.gz: cbb7e51ad1548c61b8c4c33c2ae2ecebd9bbe4e8732fd7abae7146dbc3ad2cd34cef5a3774a536992c1b1ae52212e42736774f434af5710409d06662df3d3468
+  metadata.gz: e74304a82d4c37c39f3d5d2289cb8239635ec57738e4bf36d250745dcdb032ae8cd20494901fa8ad2870a01c4010678d0c9385968910574abf1b05b4f7a968cf
+  data.tar.gz: 2b7acdb26a178e024213beac9a4be22f5e6f08f6ae5cbc7ebca69a9b781aa7fed84f198f8ca9947f70c6bac64da62ca14894371159f92a13aa909a6f369e5bda

data/CHANGELOG.md

@@ -1,7 +1,13 @@
 Cliprompt Changelog
 =====================
 
-v0.0.1 - wip
+v0.0.2 - 2014-05-20
+-----------
+
+- fix case when numbers are used in choices
+- added some test coverage for further evolution easiness
+
+v0.0.1 - 2014-05-19
 -------------
 
 - first draft

data/README.md

@@ -1,19 +1,19 @@
 Cliprompt
 ==============
 
+[![Gem Version](https://badge.fury.io/rb/cliprompt.png)](http://rubygems.org/gems/cliprompt)
 [![Build Status](https://travis-ci.org/mose/cliprompt.png?branch=master)](https://travis-ci.org/mose/cliprompt)
 [![Coverage Status](https://coveralls.io/repos/mose/cliprompt/badge.png?branch=master)](https://coveralls.io/r/mose/cliprompt?branch=master)
 [![Dependency Status](https://gemnasium.com/mose/cliprompt.svg)](https://gemnasium.com/mose/cliprompt)
 [![Code Climate](https://codeclimate.com/github/mose/cliprompt.png)](https://codeclimate.com/github/mose/cliprompt)
 
-This library provides a simple DSL for managing user interaction in a CLI application.
+This library provides a simple DSL for managing user interaction in a CLI application. Still under development, not stable yet.
 
 Features
 ----------
 
-- manages questions, choices, default values, yes/no values
-- makes possible to have env vars set for defaults
-- makes possible to colorize output
+- manages questions, choices, default values, yes/no values (done)
+- makes possible to have env vars set for defaults (todo)
 
 Usage
 ----------

data/cliprompt.gemspec

@@ -18,7 +18,7 @@ Gem::Specification.new do |spec|
   spec.test_files    = spec.files.grep(%r{^spec/})
   spec.require_paths = ["lib"]
 
-  spec.add_dependency 'dye'
+  spec.add_dependency 'paint'
 
   spec.add_development_dependency "bundler", "~> 1.6"
   spec.add_development_dependency "rake"

data/example.rb

@@ -7,6 +7,10 @@ class Myclass
   end
 
   def askit
+    puts '-------------------'
+    puts 'numeric default'
+    show "what is your age?", 42
+    show "what is your size?", 6.2
     puts '-------------------'
     puts 'Free form'
     show "This simply ask for a simple form mandatory thing?"
@@ -22,10 +26,10 @@ class Myclass
     show 'a boolean?', boolean: true, default: false
     puts '-------------------'
     puts 'a list of choices'
-    show 'a list without default?', ['22', '33', '44', '55']
-    show 'a list without default?', choices: ['22', '33', '44', '55'], default: '22'
+    show 'a list without default?', [22, 33, 44, '55']
     show 'a list with default?', ['22', '33', '=44', '55']
-    show 'a list with default?', choices: ['22', '33', '=44', '55']
+    show 'a list without default?', choices: ['22', '33', '44', '55'], default: 22
+    show 'a list with default?', choices: ['22', 33, '=44', '55']
   end
 
   def show(*args)

data/lib/cliprompt/optionset.rb

@@ -12,16 +12,18 @@ module Cliprompt
       @default = nil
       @boolean = false
       @envdefault = nil
-      unless options.nil?
-        meth = "parse_#{options.class.name.downcase}".to_sym
-        if respond_to? meth
-          send(meth, options)
-        else
-          fail OptionException, "Undefined parser ::#{meth}"
-        end
+      @type = options.class.name.downcase
+      meth = "parse_#{@type}".to_sym
+      if respond_to? meth
+        send(meth, options)
+      else
+        fail OptionException, "Undefined parser ::#{meth}"
       end
     end
 
+    def parse_nilclass(args)
+    end
+
     def parse_hash(args)
       @choices = args[:choices] || args['choices'] || []
       parse_array @choices
@@ -36,7 +38,7 @@ module Cliprompt
     end
 
     def parse_array(args)
-      @choices = args.map do |a|
+      @choices = args.map(&:to_s).map do |a|
         if a[0] && a[0] == '='
           @default = a[1..-1]
         else
@@ -45,6 +47,14 @@ module Cliprompt
       end
     end
 
+    def parse_fixnum(arg)
+      @default = arg.to_s
+    end
+
+    def parse_float(arg)
+      @default = arg.to_s
+    end
+
     def parse_string(arg)
       if arg.downcase.match /^y(es)?(\/)?n(o)?/
         @boolean = true
@@ -58,10 +68,6 @@ module Cliprompt
       end
     end
 
-    def boolean?
-      @boolean
-    end
-
     def display
       back = ''
       if @boolean
@@ -75,5 +81,38 @@ module Cliprompt
       return back
     end
 
+    def validate(question, answer)
+      if answer == ''
+        check_default question
+      elsif @boolean
+        check_boolean question, answer
+      elsif @choices.count > 0
+        check_choices question, answer
+      else
+        answer
+      end
+    end
+
+    def check_default(question)
+      return ask_again(question, Cliprompt::MSG_MANDATORY_TEXT) if @default.nil?
+      @default
+    end
+
+    def check_boolean(question, answer)
+      answer.downcase!
+      return ask_again(question, Cliprompt::MSG_YES_OR_NO) unless /^(y(es)?|n(o)?)$/.match(answer)
+      !/^y(es)?$/.match(answer).nil?
+    end
+
+    def check_choices(question, answer)
+      return ask_again(question, Cliprompt::MSG_CHOSE_IN_LIST) unless @choices.include?(answer)
+      answer
+    end
+
+    def ask_again(question, msg)
+      Cliprompt.shout msg
+      Cliprompt.ask question, self
+    end
+
   end
 end

data/lib/cliprompt/version.rb

@@ -1,3 +1,3 @@
 module Cliprompt
-  VERSION = "0.0.1"
+  VERSION = "0.0.2"
 end

data/lib/cliprompt.rb

@@ -1,4 +1,4 @@
-require "dye"
+require "paint"
 
 require "cliprompt/version"
 require "cliprompt/optionset"
@@ -7,15 +7,9 @@ module Cliprompt
 
   module_function
 
-  CUSTOM_STYLES = {
-    error: [ :bold, :red ],
-    ok:    [ :bold, :green ]
-  }
-  define_dye_method CUSTOM_STYLES
-
-  MSG_MANDATORY_TEXT = Dye.dye("Sorry you need to fill that information.", [ :bold, :red ])
-  MSG_YES_OR_NO = Dye.dye("You need to answer by yes, no, y or n.", [ :bold, :red ])
-  MSG_CHOSE_IN_LIST = Dye.dye("You need to chose between the available options.", [ :bold, :red ])
+  MSG_MANDATORY_TEXT = "Sorry you need to fill that information."
+  MSG_YES_OR_NO = "You need to answer by yes, no, y or n."
+  MSG_CHOSE_IN_LIST = "You need to chose between the available options."
 
   def ask(question, *options)
     if options[0].class == Optionset
@@ -26,32 +20,15 @@ module Cliprompt
     output.print "#{question} #{opts.display} "
     answer = input.gets.chomp
     output.flush
-    check(answer, question, opts)
+    opts.validate(question, answer)
   end
 
-  def check(answer, question, opts)
-    if answer == ''
-      if !opts.default.nil?
-        answer = opts.default
-      else
-        output.puts MSG_MANDATORY_TEXT
-        ask(question, opts)
-      end
-    else
-      if opts.boolean
-        if /^(y(es)?|n(o)?)$/.match(answer.downcase)
-          answer = !/^y(es)?$/.match(answer.downcase).nil?
-        else
-          output.puts MSG_YES_OR_NO
-          ask(question, opts)
-        end
-      elsif opts.choices.count > 0 && !opts.choices.include?(answer)
-        output.puts MSG_CHOSE_IN_LIST
-        ask(question, opts)
-      else
-        answer
-      end
-    end
+  def say(message)
+    output.puts message
+  end
+
+  def shout(message)
+    output.puts Paint[message, :bold, :red ]
   end
 
   def setio(input, output)

data/spec/lib/cliprompt/optionset_spec.rb

@@ -1,24 +1,33 @@
 # encoding: utf-8
 
 require 'spec_helper'
+require 'cliprompt'
 require 'cliprompt/optionset'
 
 describe Cliprompt::Optionset do
 
+  describe '.new' do
+    context "when an unknown objkect is passed as option," do
+      When(:options) { Object.new }
+      Then { expect{ Cliprompt::Optionset.new(options) }.to raise_error(Cliprompt::OptionException) }
+    end
+  end
+
   describe '.parse_array' do
-    Given(:options) { ['xxx', 'yyy', 'zzz'] }
 
     context "when there is no default (#{['xxx', 'yyy', 'zzz'].to_s})," do
+      Given(:options) { ['xxx', 'yyy', 'zzz'] }
       Given(:set) { Cliprompt::Optionset.new(options) }
       When(:choices) { set.choices }
       When(:default) { set.default }
       When(:display) { set.display }
       Then { expect(choices).to eq options }
       Then { expect(default).to be_false }
-      Then { expect(display).to eq "(xxx / yyy / zzz)" }
+      Then { expect(display).to eq '(xxx / yyy / zzz)' }
     end
 
     context "when there is a default specified (#{['xxx', '=yyy', 'zzz'].to_s})," do
+      Given(:options) { ['xxx', 'yyy', 'zzz'] }
       Given(:options_with_default) { ['xxx', '=yyy', 'zzz'] }
       Given(:set) { Cliprompt::Optionset.new(options_with_default) }
       When(:choices) { set.choices }
@@ -26,13 +35,24 @@ describe Cliprompt::Optionset do
       When(:display) { set.display }
       Then { expect(choices).to eq options }
       Then { expect(default).to eq 'yyy' }
-      Then { expect(display).to eq "(xxx / yyy / zzz)[yyy]" }
+      Then { expect(display).to eq '(xxx / yyy / zzz)[yyy]' }
+    end
+
+    context "when there is a mixed numeric and string choices (#{[22, 'yyy', 'zzz'].to_s})," do
+      Given(:options) { [22, 'yyy', 'zzz'] }
+      Given(:set) { Cliprompt::Optionset.new(options) }
+      When(:choices) { set.choices }
+      When(:default) { set.default }
+      When(:display) { set.display }
+      Then { expect(choices).to eq options.map(&:to_s) }
+      Then { expect(default).to be_false }
+      Then { expect(display).to eq '(22 / yyy / zzz)' }
     end
   end
 
   describe '.parse_hash' do
 
-    context "when there is choices and default," do
+    context 'when there is choices and default,' do
       context "when using sym keys (#{{ default: 'xxx', choices: ['xxx', 'yyy', 'zzz'] }.to_s})," do
         Given(:options) { { default: 'xxx', choices: ['xxx', 'yyy', 'zzz'] } }
         Given(:set) { Cliprompt::Optionset.new(options) }
@@ -41,7 +61,7 @@ describe Cliprompt::Optionset do
         When(:display) { set.display }
         Then { expect(choices).to eq ['xxx', 'yyy', 'zzz'] }
         Then { expect(default).to eq 'xxx' }
-        Then { expect(display).to eq "(xxx / yyy / zzz)[xxx]" }
+        Then { expect(display).to eq '(xxx / yyy / zzz)[xxx]' }
       end
       context "when using string keys (#{{ 'default' => 'xxx', 'choices' => ['xxx', 'yyy', 'zzz'] }.to_s})," do
         Given(:options) { { 'default' => 'xxx', 'choices' => ['xxx', 'yyy', 'zzz'] } }
@@ -51,12 +71,12 @@ describe Cliprompt::Optionset do
         When(:display) { set.display }
         Then { expect(choices).to eq ['xxx', 'yyy', 'zzz'] }
         Then { expect(default).to eq 'xxx' }
-        Then { expect(display).to eq "(xxx / yyy / zzz)[xxx]" }
+        Then { expect(display).to eq '(xxx / yyy / zzz)[xxx]' }
       end
     end
 
-    context "when there is only boolean," do
-      context "when  no default is given, default booean is Y," do
+    context 'when there is only boolean,' do
+      context 'when  no default is given, default booean is Y,' do
         Given(:options) { { boolean: true } }
         Given(:set) { Cliprompt::Optionset.new(options) }
         When(:default) { set.default }
@@ -64,9 +84,9 @@ describe Cliprompt::Optionset do
         When(:boolean) { set.boolean }
         Then { expect(default).to be_true }
         Then { expect(boolean).to be_true }
-        Then { expect(display).to eq "[Y/n]" }
+        Then { expect(display).to eq '[Y/n]' }
       end
-      context "when default is given as true, default booean is Y," do
+      context 'when default is given as true, default booean is Y,' do
         Given(:options) { { boolean: true, default: true } }
         Given(:set) { Cliprompt::Optionset.new(options) }
         When(:default) { set.default }
@@ -74,9 +94,9 @@ describe Cliprompt::Optionset do
         When(:boolean) { set.boolean }
         Then { expect(default).to be_true }
         Then { expect(boolean).to be_true }
-        Then { expect(display).to eq "[Y/n]" }
+        Then { expect(display).to eq '[Y/n]' }
       end
-       context "when default is given as false, default boolean is N," do
+       context 'when default is given as false, default boolean is N,' do
         Given(:options) { { boolean: true, default: false } }
         Given(:set) { Cliprompt::Optionset.new(options) }
         When(:default) { set.default }
@@ -84,13 +104,34 @@ describe Cliprompt::Optionset do
         When(:boolean) { set.boolean }
         Then { expect(default).to be_false }
         Then { expect(boolean).to be_true }
-        Then { expect(display).to eq "[y/N]" }
+        Then { expect(display).to eq '[y/N]' }
       end
    end
   end
 
+  describe '.parse_fixnum' do
+    Given(:options) { 42 }
+    Given(:set) { Cliprompt::Optionset.new(options) }
+    When(:default) { set.default }
+    Then { expect(default).to eq options.to_s }
+  end
+
+  describe '.parse_fixnum' do
+    Given(:options) { 3.14 }
+    Given(:set) { Cliprompt::Optionset.new(options) }
+    When(:default) { set.default }
+    Then { expect(default).to eq options.to_s }
+  end
+
   describe '.parse_string' do
 
+    context 'when a random string is passed, it is the default,' do
+      Given(:options) { 'something' }
+      Given(:set) { Cliprompt::Optionset.new(options) }
+      When(:default) { set.default }
+      Then { expect(default).to eq options }
+    end
+
     context 'when a "yesno" kind of string is passed,' do
       context 'when using yesno,' do
         Given(:options) { 'yesno' }
@@ -100,50 +141,156 @@ describe Cliprompt::Optionset do
         When(:boolean) { set.boolean }
         Then { expect(default).to be_true }
         Then { expect(boolean).to be_true }
-        Then { expect(display).to eq "[Y/n]" }
+        Then { expect(display).to eq '[Y/n]' }
       end
-      context "when using yn," do
+      context 'when using yn,' do
         Given(:options) { 'yn' }
         Given(:set) { Cliprompt::Optionset.new(options) }
         When(:default) { set.default }
         When(:display) { set.display }
         Then { expect(default).to be_true }
-        Then { expect(display).to eq "[Y/n]" }
+        Then { expect(display).to eq '[Y/n]' }
       end
-      context "when using YN," do
+      context 'when using YN,' do
         Given(:options) { 'YN' }
         Given(:set) { Cliprompt::Optionset.new(options) }
         When(:default) { set.default }
         When(:display) { set.display }
         Then { expect(default).to be_true }
-        Then { expect(display).to eq "[Y/n]" }
+        Then { expect(display).to eq '[Y/n]' }
       end
-      context "when using yesNo," do
+      context 'when using yesNo,' do
         Given(:options) { 'yesNo' }
         Given(:set) { Cliprompt::Optionset.new(options) }
         When(:default) { set.default }
         When(:display) { set.display }
         Then { expect(default).to be_false }
-        Then { expect(display).to eq "[y/N]" }
+        Then { expect(display).to eq '[y/N]' }
       end
-      context "when using yN," do
+      context 'when using yN,' do
         Given(:options) { 'yesNo' }
         Given(:set) { Cliprompt::Optionset.new(options) }
         When(:default) { set.default }
         When(:display) { set.display }
         Then { expect(default).to be_false }
-        Then { expect(display).to eq "[y/N]" }
+        Then { expect(display).to eq '[y/N]' }
       end
-      context "when using y/N," do
+      context 'when using y/N,' do
         Given(:options) { 'yesNo' }
         Given(:set) { Cliprompt::Optionset.new(options) }
         When(:default) { set.default }
         When(:display) { set.display }
         Then { expect(default).to be_false }
-        Then { expect(display).to eq "[y/N]" }
+        Then { expect(display).to eq '[y/N]' }
       end
     end
 
   end
 
+  describe '.validate' do
+    Given(:question) { 'so what?' }
+    context 'when enter key is hit,' do
+      Given(:input) { '' }
+      Given(:set) { Cliprompt::Optionset.new() }
+      When { set.stub(:check_default).with(question) }
+      Then { expect(set).to receive(:check_default).with(question) }
+      And  { expect{ set.validate(question, input) }.not_to raise_error }
+    end
+    context 'when it is a boolean,' do
+      Given(:input) { 'x' }
+      Given(:set) { Cliprompt::Optionset.new(boolean: true) }
+      When { set.stub(:check_boolean).with(question, input) }
+      Then { expect(set).to receive(:check_boolean).with(question, input) }
+      And  { expect{ set.validate(question, input) }.not_to raise_error }
+    end
+    context 'when it is a choice list,' do
+      Given(:input) { 'x' }
+      Given(:set) { Cliprompt::Optionset.new(choices: [1,2,3]) }
+      When { set.stub(:check_choices).with(question, input) }
+      Then { expect(set).to receive(:check_choices).with(question, input) }
+      And  { expect{ set.validate(question, input) }.not_to raise_error }
+    end
+    context 'when it is not a mandatory question, a boolean nor a choice list' do
+      Given(:input) { 'something' }
+      Given(:set) { Cliprompt::Optionset.new() }
+      Then { expect(set.validate(question, input)).to eq input }
+    end
+  end
+
+  describe '.check_default' do
+    Given(:question) { 'so what?' }
+    Given(:msg) { Cliprompt::MSG_MANDATORY_TEXT }
+    context 'when there is no default set,' do
+      Given(:set) { Cliprompt::Optionset.new() }
+      When { set.stub(:ask_again).with(question, msg) }
+      Then { expect(set).to receive(:ask_again).with(question, msg) }
+      And  { expect{ set.check_default(question) }.not_to raise_error }
+     end
+    context 'when there is a default set,' do
+      Given(:default) { 'x' }
+      Given(:set) { Cliprompt::Optionset.new(default: default) }
+      When(:response) { set.check_default(question) }
+      Then { expect(response).to eq default }
+     end
+  end
+
+
+  describe '.check_boolean' do
+    Given(:question) { 'so what?' }
+    Given(:msg) { Cliprompt::MSG_YES_OR_NO }
+    Given(:set) { Cliprompt::Optionset.new(boolean: true) }
+    context 'when a non yes-no answer is given,' do
+      When(:input) { 'xxx' }
+      When { set.stub(:ask_again).with(question, msg) }
+      Then { expect(set).to receive(:ask_again).with(question, msg) }
+      And  { expect{ set.check_boolean(question, input) }.not_to raise_error }
+     end
+    context 'when a no answer is given,' do
+      When(:input) { 'no' }
+      Then { expect(set.check_boolean(question, input)).to be_false }
+    end
+    context 'when a N answer is given,' do
+      When(:input) { 'N' }
+      Then { expect(set.check_boolean(question, input)).to be_false }
+    end
+    context 'when a yes answer is given,' do
+      When(:input) { 'yes' }
+      Then { expect(set.check_boolean(question, input)).to be_true }
+    end
+    context 'when a Y answer is given,' do
+      When(:input) { 'Y' }
+      Then { expect(set.check_boolean(question, input)).to be_true }
+    end
+  end
+
+  describe '.check_choices' do
+    Given(:question) { 'so what?' }
+    Given(:msg) { Cliprompt::MSG_CHOSE_IN_LIST }
+    Given(:choices) { %w(a b c) }
+    Given(:set) { Cliprompt::Optionset.new(choices: choices) }
+    context 'when answer is not in choices list,' do
+      When(:input) { 'x' }
+      When { set.stub(:ask_again).with(question, msg) }
+      Then { expect(set).to receive(:ask_again).with(question, msg) }
+      And  { expect{ set.check_choices(question, input) }.not_to raise_error }
+     end
+    context 'when answer is in choices list,' do
+      When(:input) { 'a' }
+      When(:response) { set.check_choices(question, input) }
+      Then { expect(response).to eq input }
+     end
+  end
+
+  describe '.ask_again' do
+    Given(:question) { 'so what?' }
+    Given(:msg) { 'heho gimme something' }
+    Given(:set) { Cliprompt::Optionset.new() }
+    When { Cliprompt.stub(:shout).with(msg) }
+    When { Cliprompt.stub(:ask).with(question, set) }
+    Then { expect(Cliprompt).to receive(:shout).with(msg) }
+    And  { expect(Cliprompt).to receive(:ask).with(question, set) }
+    And  { expect{ set.ask_again(question, msg)}.not_to raise_error }
+  end
+
+
 end

data/spec/lib/cliprompt_spec.rb

@@ -2,43 +2,47 @@
 
 require 'spec_helper'
 require 'cliprompt'
+require 'cliprompt/optionset'
 
 describe Cliprompt do
+  Given(:input) { StringIO.new }
+  Given(:output) { StringIO.new }
+  Given { subject.setio(input, output) }
 
   describe '.ask' do
-    Given(:input) { StringIO.new }
-    Given(:output) { StringIO.new }
-    Given { subject.setio(input, output) }
-
-    # context 'when it is free form,' do
-    #   When(:question) { 'wazza?' }
-    #   context 'without default,' do
-    #     When(:args) { }
-    #     When { subject.input.stub(:gets).and_return("\n") }
-    #     When { subject.ask(question, args) }
-    #     Then { expect(output).to receive(:print).with("#{question}  ") }
-    #     context 'when enter key is used,' do
-    #       When(:answer) { subject.ask(question) }
-    #       When { input.gets("\n") }
-    #       Then { expect(output).to receive(:puts).with(Cliprompt::MSG_MANDATORY_TEXT)}
-    #     end
-    #   end
-    #   it 'is displayed ay the end of the question' do
-    #   end
-    # end
-    context 'when there is no preset choices,' do
-      it 'only displays the question' do
-      end
+    Given(:question) { 'wazza?' }
+    Given(:answer) { 'xxx' }
+    context 'without default,' do
+      When(:args) { }
+      When { input.stub(:gets).and_return answer }
+      Then { expect(subject.ask(question, args)).to eq answer }
+      And  { expect(output.string).to eq "#{question}  " }
     end
-    context 'when enter is typed,' do
-      it 'returns the default value' do
-      end
+    context 'with a default,' do
+      When(:default) { 'ooo' }
+      When(:args) { { default: default } }
+      When { input.stub(:gets).and_return answer }
+      Then { expect(subject.ask(question, args)).to eq answer }
+      And  { expect(output.string).to eq "#{question} [#{default}] " }
     end
-    context 'when a value is provided' do
-      it 'returns the value' do
-      end
+    context 'with an optionset,' do
+      When(:args) { Cliprompt::Optionset.new() }
+      When { input.stub(:gets).and_return answer }
+      Then { expect(subject.ask(question, args)).to eq answer }
+      And  { expect(output.string).to eq "#{question}  " }
     end
+  end
+
+  describe '.say' do
+    Given(:msg) { "hah" }
+    When { subject.say msg }
+    Then { expect(output.string).to eq "#{msg}\n" }
+  end
 
+  describe '.shout' do
+    Given(:msg) { "hah" }
+    When { subject.shout msg }
+    Then { expect(output.string).to eq "#{Paint[msg, :bold, :red ]}\n" }
   end
 
 end

metadata

@@ -1,17 +1,17 @@
 --- !ruby/object:Gem::Specification
 name: cliprompt
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors:
 - mose
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-05-19 00:00:00.000000000 Z
+date: 2014-05-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: dye
+  name: paint
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="