cli-framework 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: e378c6588d51d7390a41c7fd7c7984fe5708ab44
+  data.tar.gz: e78c30a2b5fc8f5fd69e1a1e85062a337f4fc15b
+SHA512:
+  metadata.gz: 74fc1951add43ae050bd186e1f42dbc6af3d8b6b0d363b3a849e77a7aa7a88e201d4c22802eb1a5d4055deed23e42b6683fb3cd2554b7c0b2272d09db38ed5ce
+  data.tar.gz: 1fb29e9a371716a752e927040b2d799ca997df8e5612e18346aec8b258daa40612a34b1d899d7abef46a68e09f2b6beae8ae156a3ad69911b4b6714f60c403b4

data/bin/cli

@@ -0,0 +1,1059 @@
+# puts here all gem that you will need for the command line
+#   require "xyz"
+#
+module CommandLineConfig
+  Name ||= "cli" 
+  Version ||= "0.0.1"
+  Color ||= 'yellow'
+  Otherwise ||= "help"
+  BeforeInit ||= ['check.rb'] #execute scripts before initilatizing the cli
+  Special ||= [['-v','version'], ['-help','help']]
+end
+
+
+
+require "terminal-table"
+
+module CommandLineUtils
+  extend self
+
+  @rendered = ""
+
+  KEYS = {
+    " " => "space",
+    "\t" => "tab", # or ctrl + I on mac
+    "\r" => "return",
+    "\n" => "linefeed", # or ctrl + J on mac
+    "\e" => "escape",
+    "\e[A" => "up",
+    "\e[B" => "down",
+    "\e[C" => "right",
+    "\e[D" => "left",
+    "\177" => "backspace",
+    "\003" => "ctrl-c", # ctrl + c
+    "\004" => "ctrl-d", # ctrl + d
+  }
+
+  # Read a character the user enters on console. This call is synchronous blocking.
+  # This is taken from: http://www.alecjacobson.com/weblog/?p=75
+  def read_char
+    begin
+      # save previous state of stty
+      old_state = `stty -g`
+      # disable echoing and enable raw (not having to press enter)
+      system "stty raw -echo"
+      c = STDIN.getc.chr
+      # gather next two characters of special keys
+      if(c=="\e")
+        extra_thread = Thread.new{
+          c = c + STDIN.getc.chr
+          c = c + STDIN.getc.chr
+        }
+        # wait just long enough for special keys to get swallowed
+        extra_thread.join(0.00001)
+        # kill thread so not-so-long special keys don't wait on getc
+        extra_thread.kill
+      end
+    rescue => ex
+      puts "#{ex.class}: #{ex.message}"
+      puts ex.backtrace
+    ensure
+      # restore previous state of stty
+      system "stty #{old_state}"
+    end
+    return c
+  end
+
+  # Read a keypress on console. Return the key name (e.g. "space", "a", "B")
+  # Params:
+  # +with_exit_codes+:: +Bool+ whether to throw Interrupts when the user presses
+  #   ctrl-c and ctrl-d. (true by default)
+  def read_key with_exit_codes = true, return_char = false
+    char = read_char
+    if with_exit_codes and ( char == "\003" or char == "\004" )
+      self.update_line(0,"Process Interrupted"); print "\n"
+      exit
+    end
+    if return_char then char else char_to_raw char end
+  end
+
+  # Get each key the user presses and hand it one by one to the block. Do this
+  # as long as the block returns truthy
+  # Params:
+  # +&block+:: +Proc+ a block that receives a user key and returns truthy or falsy
+  def read_key_while_true return_char = false, &block
+    STDIN.noecho do
+      while true  # ask for key and run block until it return false
+        @key = CommandLineUtils.read_key
+        not_a_command = @key =~ /[^[:print:]]/ # return 0 if it not a recoginzed command
+        unless not_a_command == 0  # don't run the block and reask for key if it is not an input or a special in KEYS hash
+          returned_value = block.( @key, return_char )
+          return if returned_value == false
+        else
+          true
+        end
+      end
+    end
+  end
+
+  # Get the console window size
+  # Returns: [width, height]
+  def winsize
+    STDIN.winsize
+  end
+
+  
+  def hide_cursor_during # hides cursor during the execustion of providd block
+    print `tput civis` # hide the cursor
+      yield # run the provided block
+    print `tput cnorm`  # finally show the cursor
+  end
+
+  def char_to_raw char
+    KEYS.fetch char, char
+  end
+
+  def carriage_return;  "\r"    end
+  def line_up;          "\e[A"  end
+  def clear_line;       "\e[0K" end
+  def char_left;        "\e[D"  end
+  def char_right;       "\e[C"  end
+
+  # modified by me
+  @lineNumber = 0
+  def update_line returnNumber, line = ""  #modifie a line, count from bottom to top
+    if returnNumber > @lineNumber
+       print "\r\033[#{returnNumber - @lineNumber}A" 
+    elsif returnNumber < @lineNumber
+      print "\r\033[#{@lineNumber - returnNumber}B" 
+    else
+      print "\r"
+    end
+      print "\033[K#{line}"
+      @lineNumber = returnNumber
+  end
+
+  @rendered_lines = []
+  def render_line line
+    @rendered_lines << line
+    puts line
+  end
+
+  def rendered_lines
+    @rendered_lines
+  end
+
+  @question
+  def renderQuestion question,returnBool = false
+    @question = question
+    print question
+    print "\n" if returnBool
+  end
+
+  def answerQuestion question = @question, answer
+    down = @lineNumber 
+    print "\r\033[B" * down
+    @lineNumber = 0
+    clear 
+    clear 1
+    CommandLineUtils.update_line(0, "#{question} #{answer}")
+    print "\n"
+  end
+
+  # clear the console based on the last text rendered
+  def clear lineToClear = nil
+    # determine how many lines to move up
+
+    numberOfLines = lineToClear || @rendered_lines.length
+    # jump back to the first position and clear the line
+    print carriage_return + ( line_up + clear_line ) * numberOfLines + clear_line
+    @rendered_lines = []
+  end
+
+
+end
+
+
+class String #extend String class in order to add coloration capabilitise
+  # colorization
+  def colorize(color_code)
+    "\e[#{color_code}m#{self}\e[0m"
+  end
+
+  def bold
+    colorize(1)
+  end
+
+  def color colorName
+    colorize(1) #make it bold first
+    case colorName
+      when "red"
+        colorize(1).colorize(31)
+      when "blue"
+        colorize(1).colorize(34)
+      when "yellow"
+        colorize(1).colorize(33)
+      when "green"
+        colorize(1).colorize(32)
+      when "cyan"
+        colorize(1).colorize(36)
+      when "pink"
+        colorize(1).colorize(35)
+      when "white"
+        colorize(1).colorize(37)
+      when "normal"
+        colorize(0)
+    end
+  end  
+end
+
+class ScreenUtils
+
+    def self.newline(line = "", return_line = false)
+        puts ""
+    end
+
+    def self.removeline(lineNumber = 0)
+        lineNumber.times { print "\r" }
+        print ""
+    end
+
+    def self.read_char
+    begin
+      # save previous state of stty
+      old_state = `stty -g`
+      # disable echoing and enable raw (not having to press enter)
+      system "stty raw -echo"
+      c = STDIN.getc.chr
+      # gather next two characters of special keys
+      if(c=="\e")
+        extra_thread = Thread.new{
+          c = c + STDIN.getc.chr
+          c = c + STDIN.getc.chr
+        }
+        # wait just long enough for special keys to get swallowed
+        extra_thread.join(0.00001)
+        # kill thread so not-so-long special keys don't wait on getc
+        extra_thread.kill
+      end
+    rescue => ex
+      puts "#{ex.class}: #{ex.message}"
+      puts ex.backtrace
+    ensure
+      # restore previous state of stty
+      system "stty #{old_state}"
+    end
+    return c
+  end
+
+end
+
+module Input
+ extend self
+
+  def ask params = { question: "select from options below ...", default: "", suggestion: "" }
+        @question = params[:question].bold
+        @dialogue = params[:dialogue]
+        @type = params[:type] # can be 'confirm' - 'password'
+        @defaultColor = params[:color] || CommandLineConfig::Color || "white"
+        
+        @dialogue_msg = params[:dialogue] || ""
+        @dialogue_msg = @dialogue_msg.color(@defaultColor)
+        @yesColor = params[:yes_color]; @noColor = params[:no_color]
+        @defaultAnswer = params[:default];  
+ 
+                   @answer = @defaultAnswer
+                
+        @suggestion = params[:suggestion]
+        # CommandLineUtils.hide_cursor_during do # hide the cursor while block is executed
+            @line = ["#{@dialogue_msg + @question}", " ", @answer]
+            @password = ""; @cursor_position = @answer.length 
+            render_line true
+                if @type == "confirm"
+                    # @answer
+                    CommandLineUtils.hide_cursor_during do # hide the cursor while block is executed
+                     CommandLineUtils.read_key_while_true do |key|
+                         if key == "return" || key == "Y" || key == "y" || key == "t" || key == "T"
+                             confirm true
+                             false
+                         elsif key == "n" || key == "N" || key == "backspace" || key == "f" || key == "F"
+                             confirm false
+                             false
+                         end
+                     end
+                     end
+                else
+                     @keyed = false ;
+                    CommandLineUtils.read_key_while_true do |key|
+                        if key == "return"
+                            @keyed = true
+                            answer
+                        elsif key == "backspace"
+                            @answer.clear unless @keyed
+                            @cursor_position = 0 unless @keyed
+                            @keyed = true
+                            @answer.chop!
+                            @cursor_position -= 1 unless @cursor_position == 0
+                            update_line
+                        elsif key == "space"
+                            @answer.insert(@cursor_position, " ")
+                            @keyed = true
+                            @cursor_position += 1 
+                            update_line
+                        elsif key == "left" && @cursor_position > 0
+
+                            print "\033[1D"
+                            @cursor_position -= 1
+
+                        elsif key == "right"
+                            unless @cursor_position == @answer.length 
+                            print "\033[1C"
+                            @cursor_position += 1 
+                            end
+                        else
+                            @answer.insert(@cursor_position, key) 
+                            @cursor_position += key.length
+                            @keyed = true
+                            update_line
+                        end 
+                    end
+                # end
+        end
+
+           yield(@answer) if block_given?
+           return @answer
+
+  end
+
+  def render_line stay
+      if @type == "password"
+          print "#{@line[0]+@line[1]}#{'*' * @line[2].length}"
+      else
+          print @line.join('')
+      end
+    print "\n" 
+    update_line
+  end
+
+  def update_line
+      if @type == "password"
+          CommandLineUtils.update_line(1, "#{@line[0]+@line[1]}#{'*' * @line[2].length}")
+      else
+        CommandLineUtils.update_line(1, "#{@line.join('')}") #current
+      end     
+      if @cursor_position
+      left = @answer.length - @cursor_position
+      print "\033[#{left}D" unless left == 0  
+      end         
+  end
+
+  def answer
+      if @type == "password"
+          CommandLineUtils.answerQuestion(@line[0] , ('*' * @line[2].length).color(@defaultColor))
+      else
+          CommandLineUtils.answerQuestion(@line[0] ,@line[2].color(@defaultColor))
+      end
+      return false
+  end
+
+  def confirm bool
+      if bool
+          @answer = true
+          CommandLineUtils.answerQuestion(@line[0] , "yes".color(@yesColor || @defaultColor))
+      else
+          @answer = false
+          CommandLineUtils.answerQuestion(@line[0] , "no".color(@noColor || @defaultColor))
+      end
+  end
+
+end
+
+module Choice
+ extend self
+
+  def ask params = { question: "select from options below ...", choices: [], default: 0 }
+        # inilialize global params of the list - set default values
+        unless params[:choices].length == 0 # dont launch the selection if no choices are provided
+        params[:multiple] = false unless params[:multiple] == true
+
+        @selector = "❱" # for unselected - on select - unselectable
+        @check_selector = ["⬡ ","⬢ "]
+        @selector = ["    ","  #{@selector} "]
+
+        @checkbox = params[:multiple]; if @checkbox && params[:indent]; @selector[1].chop!;end ; 
+        @checked = @check_selector
+        @checked = ["",""] if !@checkbox
+        @question = params[:question]; @arrayOfChoice = params[:choices]
+        @defaultColor = params[:color] || CommandLineConfig::Color || "white"
+        ; @defaultChoiceNumber = params[:default]
+         @dialogue_msg = params[:dialogue] || ""
+        @dialogue_msg = @dialogue_msg.color(@defaultColor)
+        
+        CommandLineUtils.hide_cursor_during do # hide the cursor while block is executed
+                
+                choice_default_visual
+                @current_line_to_update = @reversedArrayOfChoices[@current_line - 1]
+
+                CommandLineUtils.read_key_while_true do |key| 
+
+                        if key == "up" 
+                            
+                            @previous_line = @current_line; 
+                            @current_line = 0 if @current_line >= @reversedArrayOfChoices.length # restart at bottom when "up" on top
+                            @current_line_to_update = @reversedArrayOfChoices[@current_line]
+                            @current_line += 1
+                            update_lines
+
+
+                        elsif key == "down"
+
+                            @previous_line = @current_line 
+                            @current_line = @reversedArrayOfChoices.length + 1 if @current_line <= 1 # restart at top when "down" on bottom
+                            @current_line -= 1;
+                            @current_line_to_update = @reversedArrayOfChoices[@current_line - 1]
+                            update_lines
+                        
+                        elsif key == "space" 
+                         
+                            toggle_select if @checkbox 
+                            
+                        elsif key == "return"
+
+                            answer
+                            
+                        end
+                
+                key != 'return' && @key != 'escape' && @key != 'backspace' # exit if it returns false
+                end
+            end
+            yield(@index, @choice) if block_given?
+           return @index
+        end
+    end
+
+    def choice_default_visual
+        CommandLineUtils.renderQuestion(@dialogue_msg + @question.bold, true); @lines = []
+                @arrayOfChoice.each.with_index do |line, index| # print the default selected choice | print layer
+                    # inject default values
+                       @arrayOfChoice[index][:selectable] = true unless line[:selectable] == false 
+                       @arrayOfChoice[index][:color] = @defaultColor unless line[:color]
+                       @arrayOfChoice[index][:description] = "" unless line[:description]
+                       @arrayOfChoice[index][:check] = false unless line[:check] # unless check is defaulted
+
+                    # add default visual 
+                    # line template = ["selector", "check", "name", "description"]
+                    line_to_print = [@selector[0], @checked[0], line[:name], line[:description]]
+
+                    line_to_print[1] = @checked[1] if @checkbox && @arrayOfChoice[index][:check]
+                    line_to_print[0] = @selector[1] if index == @defaultChoiceNumber    
+
+                    if index == @defaultChoiceNumber
+                        CommandLineUtils.render_line "#{(line_to_print[0]+line_to_print[1]+line_to_print[2]).color(line[:color])}#{line_to_print[3]}"
+                    elsif !line[:selectable]
+                        CommandLineUtils.render_line "#{(line_to_print[0]+line_to_print[1]+line_to_print[2]).color('normal')}#{line_to_print[3]}"
+                    else
+                        CommandLineUtils.render_line "#{(line_to_print[0]+line_to_print[1]+line_to_print[2]).color('white')}#{line_to_print[3]}"
+                    end
+
+                    @lines << line_to_print
+
+                end
+         @lines.reverse!
+         @reversedArrayOfChoices = @arrayOfChoice.reverse
+         @current_line = @arrayOfChoice.length - @defaultChoiceNumber # select default line | compute layer
+         @previous_line = @current_line
+    end
+
+def toggle_select
+        new_check_state = !@current_line_to_update[:check]
+        color = @current_line_to_update[:color]
+        @reversedArrayOfChoices[@current_line - 1][:check] = new_check_state
+        @lines[@current_line - 1][1] = (new_check_state ? @checked[1] : @checked[0])
+        line = @lines[@current_line - 1]
+        CommandLineUtils.update_line(@current_line, "#{(line[0]+line[1]+line[2]).color(color)}#{line[3]}" )#current                      
+    end
+
+  def update_lines
+        previous_line = @lines[@previous_line - 1];
+        previous_line[0] = @selector[0]
+        current_line = @lines[@current_line - 1];
+        current_line[0] = @selector[1]
+
+        CommandLineUtils.update_line(@current_line, "#{(current_line[0]+current_line[1]+current_line[2]).color(@reversedArrayOfChoices[@current_line - 1][:color])}#{current_line[3]}") #current                      
+        CommandLineUtils.update_line(@previous_line, "#{(previous_line[0]+previous_line[1]+previous_line[2]).color('white')}#{previous_line[3]}") 
+  end
+
+  def answer
+      if @checkbox # :multiple implementation
+        @indexes = []; @choices = []; @answer = false
+        @arrayOfChoice.each.with_index { |choice, index| ; if choice[:check] == true 
+                                                                @indexes << index; 
+                                                                @choices << choice;
+                                                                name = choice[:as] || choice[:name]
+                                                                if @answer
+                                                                    @answer = "#{@answer} - #{name.color(choice[:color])}"
+                                                                else
+                                                                    @answer = "#{name.color(choice[:color])}"
+                                                                end
+                                                           end  
+                                                           }
+        @answer = "-".color(@defaultColor) unless @answer                                                  
+        CommandLineUtils.answerQuestion(@answer)
+        @index = @indexes; @choice = @choices
+      else # normal
+        @index = @reversedArrayOfChoices.length - @current_line.to_i; 
+        choices = @reversedArrayOfChoices.reverse
+        @choice = choices[@index]; 
+        @answer = @choice[:as] || @choice[:name] 
+        CommandLineUtils.answerQuestion("#{@answer}".color(@choice[:color]))
+      end
+  end
+
+end
+
+
+
+class CommandLineInterface
+    attr_accessor :name, :version, :color
+
+    def initialize
+        @@cmds = []
+        # yield(self) if block_given?
+        @name = CommandLineConfig::Name
+        @version = CommandLineConfig::Version
+        @color = CommandLineConfig::Color || "blue"
+        @otherwise = CommandLineConfig::Otherwise || "help"
+        @commandInput = Inputs.new
+        @first_argument = Inputs.all[0].show if Inputs.all[0]
+        
+
+
+        if @first_argument
+                ## detect special commands
+
+                redirect_special_cmds @first_argument
+
+                ## execute normally
+
+
+                @actionExecute = @first_argument.capitalize + "Action"
+                CommandAction.actions.each do |action| # compare each actions with the first command
+                    if action.class.to_s == @actionExecute || action.alias == @first_argument
+                        executeCommand action
+                    end
+                end
+
+                ## if action not found
+
+                error
+        else
+            error
+        end
+
+
+    end
+
+    def error
+         @actionExecute = "ErrorAction"
+            CommandAction.actions.each do |action| # compare each actions with the first command
+                if action.class.to_s == @actionExecute 
+                    executeCommand action
+            end
+         end
+    end
+
+    def redirect_special_cmds firstArg
+        if CommandLineConfig::Special
+
+            CommandLineConfig::Special.each do |spcmd| #['-v --v', 'version']
+                special_commands = spcmd[0].split(' ')
+                special_commands.each do |special|
+                    if special == firstArg
+                        @actionExecute = spcmd[1].capitalize + "Action"
+                        CommandAction.actions.each do |action| # compare each actions with the first command
+                            if action.class.to_s == @actionExecute || action.alias == firstArg
+                                executeCommand action
+                            end
+                        end
+                    end
+                end
+            end
+        end
+    end
+
+    def executeCommand action
+        inputs = Inputs.all;
+        arguments = make_argumentsObj action 
+        options = make_optionsObj action;
+        namespaces = make_namespaceObj action
+        action.action inputs, arguments, options, namespaces
+        exit
+    end
+
+    def make_argumentsObj cmd # create parameters ['type','subtype'] => { 'type': params1, ... args: [rest of the shit]}
+        argumentsObj = {}
+        args = InputArgument.all
+        cmd.args.each do |param|
+            args.delete_at(0)
+                    argumentsObj[param] = args[0]
+
+        end
+        argumentsObj['args'] = args
+        return argumentsObj
+    end
+
+    def make_optionsObj cmd # create { "global": true/false, "special": true/false}
+        optionsObj = {}
+        options = InputOption.all
+        cmd.options.each do |opt|
+            opt[0].split(' ').each do |sub|
+                options.each do |input|
+                    optionsObj[opt[1]] = true if sub == input
+                end
+            end
+            optionsObj[opt[1]] = false unless optionsObj[opt[1]]
+        end
+        return optionsObj
+    end
+
+    def make_namespaceObj cmd # name:space foo:bar => {'name':'space', 'foo':'bar'  }
+        namespaceObj = []
+        InputNamespace.all.each do |namespace|
+            namespaceObj << namespace.split(':')
+        end
+        return namespaceObj
+    end
+
+    def launch commandNameExec
+        @@cmds.each do |cmd|
+           executeCommand(cmd) if cmd.name == commandNameExec
+        end
+    end
+
+
+    def self.terminal commandString # call a subprocess that outputs
+        system commandString
+    end
+
+
+
+
+
+end
+
+
+class Inputs
+    @@inputs = []
+    def initialize
+
+        if ARGV[0] && ARGV[0].is_namespace? # unNamespace the first arg
+            namespaceEls = ARGV[0].split(':')
+            ARGV.delete_at(0)
+            namespaceEls.each.with_index do |el,index| ;  ARGV.insert(0+index, el) ; end
+
+        end
+        ARGV.each.with_index do |arg, index|
+            if arg[0] == "-" #detect options
+                @@inputs << InputOption.new(index, arg)
+            elsif arg.split(':').length >= 2 #detect namespaces
+                @@inputs << InputNamespace.new(index, arg)
+            else
+                @@inputs << InputArgument.new(index, arg)
+            end
+
+        end
+    end
+
+    def self.all
+        return @@inputs
+    end
+end
+
+class InputClass
+    def next
+        nextIndex = @index + 1
+        return Inputs.all[nextIndex] if CommandInput.all[nextIndex]
+    end
+
+    def previous
+        prevIndex = @index - 1
+        return Inputs.all[prevIndex] if CommandInput.all[prevIndex]
+    end
+end
+
+class InputOption < InputClass
+    @@options = []
+    @option
+    def initialize index,arg
+        @@options << arg
+        @option = arg
+        @index = index
+    end
+
+    def show
+        return @option
+    end
+
+    def self.all
+        return @@options
+    end
+end
+
+class InputNamespace < InputClass
+    @@namespaces = []
+    @namespace
+    def initialize index,arg
+        @@namespaces << arg  # => 'arg:space'
+        @namespace = arg
+        @index = index
+    end
+
+    def show 
+        return @namespace 
+    end
+
+    def self.all
+        return @@namespaces
+    end
+end
+
+class InputArgument < InputClass
+    @@arguments = []
+    @argument
+    def initialize index,arg
+        @@arguments << arg
+        @argument = arg
+        @index = index
+    end
+
+    def show
+        return @argument
+    end
+    
+    def self.all
+        return @@arguments
+    end
+end
+
+class CommandAction
+    attr_accessor :description, :options, :args, :alias
+    @@actions = []
+
+    def initialize config 
+        @description = config[:description]
+        @options = config[:options]
+        @args = config[:params]
+        @alias = config[:alias]
+
+        @@actions << self
+    end
+
+    def self.register config = Hash.new
+        config[:description] = "" unless config[:description]
+        config[:options] = [] unless config[:options]
+        config[:params] = [] unless config[:params]
+        config[:alias] = "" unless config[:alias]
+        self.new config
+    end
+
+    def self.actions
+        return @@actions
+    end
+
+end
+module CommandLine extend self
+    Action = CommandAction
+end
+
+module CommandFile extend self
+   Specification = self
+   def new; @spec = {}; 
+       yield(self)
+       print "\n"
+       print @spec
+       exit
+   end
+
+    def parameters params; @spec['parameters'] = params; end
+    def alias params; @spec['alias'] = params; end
+    def description params; @spec['description'] = params ; end
+    def option params; @spec['options'] = [] unless @spec['options']; @spec['options'] << params ; end
+    def name params; @spec['name'] = params; end
+    def execute params; @spec['execute'] = params; end
+    def exclude params; @spec['exclude'] = params; end
+end
+
+class String #extend String class in order to add coloration capabilitise
+  # colorization
+  def colorize(color_code)
+    "\e[#{color_code}m#{self}\e[0m"
+  end
+
+  def bold
+    colorize(1)
+  end
+
+  def color colorName
+    colorize(1) #make it bold first
+    case colorName
+      when "red"
+        colorize(1).colorize(31)
+      when "blue"
+        colorize(1).colorize(34)
+      when "yellow"
+        colorize(1).colorize(33)
+      when "green"
+        colorize(1).colorize(32)
+      when "cyan"
+        colorize(1).colorize(36)
+      when "pink"
+        colorize(1).colorize(35)
+      when "white"
+        colorize(1).colorize(37)
+      when "normal"
+        colorize(0)
+    end
+  end  
+
+  def is_namespace?
+      if self.split(':').length >= 2
+          return true
+      else 
+          return false
+      end
+  end
+
+end
+
+class ActionAction < CommandLine::Action; register  description: "create or overwrite an action",
+                                                    alias: 'a',
+                                                    params: ['name']
+
+
+   def action inputs, arguments, options, namespaces
+    if arguments['name']
+        createAction arguments['name'],namespaces if validate arguments['name']
+    else
+        error
+    end
+   end
+
+   def error
+       puts 'a valid name has to be provided in order to create the action'
+        puts 'use "cli action <name>"'
+    end
+
+   def validate name
+    if name.length == 0 || name[/[a-zA-Z]+/] != name
+        error
+        return false
+    else
+        return true
+    end
+   end
+
+   def register namespaces
+       print namespaces
+    return "    register"
+    end
+
+   def createAction name,namespaces
+       puts "creating #{name} action"
+       lines = [
+           "class #{name.capitalize}Action < CommandLine::Action",
+           "    register",
+           "    def action inputs, arguments, options, namespaces",
+           "    ",
+           "    end",
+           "end",
+       ]
+
+       File.open("lib/actions/#{name}.rb", 'a') do |f| 
+        lines.each do |line|
+            f.print line, "\n"
+        end
+       end
+
+   end
+end
+
+
+
+
+class BuildAction < CommandLine::Action
+    register description: "build the cli"
+
+
+#    description: "this the description of build action"
+#    params: ["port"]
+#    options: [['-d -deploy','deploy'], ['-i','international']]
+
+   def action inputs, arguments, options, namespaces
+       puts "packing the cli .."
+       CommandLineInterface.terminal "rake install"
+   end
+end
+
+
+
+
+class ErrorAction < CommandLine::Action
+    register 
+
+   def action inputs, arguments, options, namespaces
+       puts "\"#{inputs[0].show if inputs[0]}\" is not a valid #{CommandLineConfig::Name} Command"
+   end
+end
+
+
+
+
+class HelpAction < CommandLine::Action
+   register 
+
+
+   def action inputs, arguments, options, namespaces
+       self.help
+   end
+    
+   def help
+        rows = scanConfig # [{name:" ", "params":"", "description":"saljdn"} ]
+        puts "\n #{CommandLineConfig::Name} - #{CommandLineConfig::Version}"
+        table style: { :border_x => "", :border_y => "", :border_i => "" } do |row|
+              rows.each do |c|
+                    name = c[:name]; next if name == 'help' || name == "version" || name == "error" || name.nil?
+                    row.add [name.color(CommandLineConfig::Color)  ,c[:params] ,c[:description]] 
+              end
+            #   row.separation
+            #   rows.each do |c|
+            #         name = c[:name]; if name == 'help' || name == "version"
+            #         row.add [name ,c[:params] ,c[:description]] 
+            #   end
+            #   end
+
+        end
+          print "\n"           
+        #scanning for commandfiles in order to take configuration of each commandString
+        #scanning all commands to get thei config 
+        #output a table
+    end
+ 
+    def scanConfig
+        rows = []
+        # cmd.configuration.call() #make config anvailable
+        CommandAction.actions.each do |cmd|
+            params = ""
+            cmd.args.each do |p|
+                params += "<#{p}> "
+            end
+
+            name = cmd.class.to_s.downcase.split('action')[0]
+            rows << { name: name , params: params, description: cmd.description }
+        end
+        return rows
+    end
+
+    def table params
+
+         table = Terminal::Table.new params do |row|
+             def row.add params; self.add_row params end
+             def row.separation; self.add_separator; end
+             yield(row) if block_given?
+            end
+        puts table
+    end
+end
+
+class NewAction < CommandLine::Action
+    register description: 'create a new cli',
+                  params: ['name', 'color']                 
+                #  options: [['-g --general', 'general']] 
+
+
+
+    def action inputs, arguments, options, namespaces
+        unless arguments['name']
+            puts "A name for the cli has to be provided"
+            puts "  cli new ... <- replace '...' with the name of your cli"
+            puts "Don't worry, you can change the name of your cli very easily after if you want so"
+            exit
+        end
+        msg = CommandLineInterface.terminal "git clone -b blank https://github.com/iliasbhal/cli-framework #{arguments['name']}" 
+        if msg 
+            # modify the configuration file so it matches the name
+            File.open("#{arguments['name']}/lib/configuration.rb", 'a') { |d| ; 
+                    d.truncate(0) # erase all the content of a file
+                    d.print "   module CommandLineConfig", "\n"
+                    d.print "   Name ||= '#{arguments['name']}'","\n"
+                    d.print "   Color ||= 'blue'", "\n"
+                    d.print "   Version ||= '0.0.0'","\n"
+                    d.print "   Else ||= help","\n"
+                    d.print "   Special ||= [['-v','version'], ['-help','help']]","\n"
+                    d.print "end"
+            }
+            # enter the folder and modify git
+            puts "initilializing git ..."
+            Dir.chdir("#{arguments['name']}") do |path|
+             `git remote remove origin`
+             `git branch -m blank master`
+             `git add . && git commit -m "first commit"`
+             `git reset && git init`
+            end
+            puts "done !"
+        end
+    end
+end
+
+
+class ServerAction < CommandLine::Action
+  register description: "launch a server localy with power :)",
+                params: ["port"],
+               options: [['-d -deploy','deploy'], ['-i','international']]
+
+
+   def action inputs, arguments, options, namespaces
+        Input.ask   question: "what is your name ?",
+                    dialogue: "[?] Serverless: ",
+                    default: 'john' 
+
+        Input.ask   question: "what is your name ?",
+                    dialogue: "[?] Serverless: ",
+                    type: 'password', # can be confirm / password or just nothing
+                    default: 'john' 
+        
+        Input.ask   question: "what is your name ?",
+                    dialogue: "[?] Serverless: ",
+                    type: 'confirm', # YyTt FfNn
+                    default: 'Y/N' 
+
+        Choice.ask  question: 'select from below:', default: 0,
+                    dialogue: "[?] Serverless: ",
+                    multiple: true,
+                    choices: [
+                        { name: 'choice one', description: " # not a good choice :p",as: 'jehe'},
+                        { name: 'choice two'},
+                        { name: 'choice one', description: " # not a good choice :p"},
+                        { name: 'choice two'},
+                        { name: 'choice one', description: " # not a good choice :p"},
+                        { name: 'choice two'},
+                        { name: 'choice one', description: " # not a good choice :p"},
+                        { name: 'choice two'}
+                    ] 
+   end
+end
+
+class VersionAction < CommandLine::Action
+   register description: "return the version on the cli"
+   
+
+   def action inputs, arguments, options, namespaces
+       print inputs, "\n"
+       print arguments, "\n"
+       print options, "\n"
+       print namespaces, "\n"
+       puts CommandLineConfig::Version
+   end
+end
+
+
+ CommandLineInterface.new 

metadata

@@ -0,0 +1,59 @@
+--- !ruby/object:Gem::Specification
+name: cli-framework
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Ilias Bhallil
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-10-26 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: terminal-table
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Framework for quickly building a Command line interface
+email:
+- ilias.bhal@gmail.com
+executables:
+- cli
+extensions: []
+extra_rdoc_files: []
+files:
+- bin/cli
+homepage: http://iliasbhallil.github.com
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.1
+signing_key: 
+specification_version: 4
+summary: ''
+test_files: []