clin 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 96826af1a7b6e82847b69c692292d7c2a10c69ed
-  data.tar.gz: 28fd292aafc8be55a10af75853283a4def9def65
+  metadata.gz: be4386269225e68a69c419a0a4a90668f5da8287
+  data.tar.gz: 0a33c686511f6a0498fe40276c936b6574fbe497
 SHA512:
-  metadata.gz: 3690346888ff69f711f292bca3f1e15a4580599ea12f070264b2c6eb6cdedc3f5081ac8113c08d2f391e1a892c6e6e36832d9351367ce83a924ab9ec801392e3
-  data.tar.gz: 05d2c816d4140359ce2a01fca4462417b6c55fca85580fb7ffe7b8692b60498fe33b2dad151b21c783b7673b1a47f8e31a19215e1c63982a072e73a28345f1fd
+  metadata.gz: 2878f163e2974a9a3c93e9f565e9b5fdaf5ec91bcced8856b95b7045f45eca8427da8a22631f1741da582982ab1c575e19c6115cee4dd8078a69a08f217cf41d
+  data.tar.gz: eba57a52877c4ea5fca71571ab1a534459f173d9715028774b76a6be8fb9e7721b077fdc8371839ba770a43dfde17bd34fd7bf2c71e2001e88c6898be7458fab

data/.travis.yml

@@ -1,6 +1,5 @@
 language: ruby
 rvm:
-  - '2.0'
   - '2.1'
   - '2.2'
 

data/CHANGELOG.md

@@ -1,7 +1,14 @@
+## 0.3.0
+Features:
+    - Added a shell class for any user interaction.
+    - Added `priority` to test commands in specific order and not the order they where loaded.(#4)
+    - Added `auto_option` to define specific options cleaner.(#5)
+    
 ## 0.2.0
 Features:
     - Allow unknown options to be ignored and not raise Error(#1)
     - Added list options. For options that can be multiple times in the same command(#2)
     - Added default value for options.(#3)
+
 ## 0.1.0
 Inital release.

data/README.md

@@ -3,6 +3,7 @@
 [![Coverage Status](https://coveralls.io/repos/timcolonel/clin/badge.svg?branch=master)](https://coveralls.io/r/timcolonel/clin?branch=master)
 [![Code Climate](https://codeclimate.com/github/timcolonel/clin/badges/gpa.svg)](https://codeclimate.com/github/timcolonel/clin)
 [![Inline docs](http://inch-ci.org/github/timcolonel/clin.svg?branch=master)](http://inch-ci.org/github/timcolonel/clin)
+
 Clin is Command Line Interface library that provide an clean api for complex command configuration.
 The way Clin is design allow a command defined by the user to be called via the command line as well as directly in the code without any additional configuration
 ## Installation

data/clin.gemspec

@@ -21,7 +21,7 @@ Gem::Specification.new do |spec|
   spec.add_dependency 'activesupport', '>=4.0'
   spec.add_development_dependency 'bundler', '~> 1.7'
   spec.add_development_dependency 'rake', '~> 10.0'
-  spec.add_development_dependency 'rspec'
+  spec.add_development_dependency 'rspec', '>= 3.0'
   spec.add_development_dependency 'coveralls'
   spec.add_development_dependency 'faker'
 end

data/examples/auto_option.rb

@@ -0,0 +1,17 @@
+$LOAD_PATH.push File.expand_path('../../lib', __FILE__)
+require 'clin'
+require 'clin'
+
+# Simple command Example
+class AutoOptionCommand < Clin::Command
+  auto_option :echo, '-e --eko=message Echo the message'
+  general_option Clin::HelpOptions
+
+  def run
+    puts @params[:echo]
+  end
+end
+
+# Run example:
+# AutoOptionCommand.parse('-e "Some message 1"').run
+# AutoOptionCommand.parse('--eko="Some message 2"').run

data/examples/dispatcher.rb

@@ -5,7 +5,7 @@ require 'clin'
 class DisplayCommand < Clin::Command
   arguments 'display <message>'
 
-  self.description = 'Display the given message'
+  description 'Display the given message'
 
   def run
     puts "Display: '#{params[:message]}'"
@@ -16,33 +16,27 @@ end
 class PrintCommand < Clin::Command
   arguments 'print <message>'
 
-  self.description = 'Print the given message'
+  description 'Print the given message'
 
   def run
     puts "Print: '#{params[:message]}'"
   end
 end
 
-if __FILE__ == $PROGRAM_NAME
-  Clin::CommandDispatcher.parse('display "My Message"').run
-  puts
-  puts '=' * 60
-  puts
-  Clin::CommandDispatcher.parse('print "My Message"').run
-  puts
-  puts '=' * 60
-  puts
-  begin
-    Clin::CommandDispatcher.parse('display -h').run
-  rescue Clin::CommandLineError => e
-    puts e
-  end
-  puts
-  puts '=' * 60
-  puts
-  begin
-    Clin::CommandDispatcher.parse('-h')
-  rescue Clin::CommandLineError => e
-    puts e
+# Simple command Example
+class PrintAltCommand < Clin::Command
+  arguments 'print <message>'
+
+  description 'Print the given message alternative'
+  prioritize
+
+  def run
+    puts "Print alt: '#{params[:message]}'"
   end
 end
+
+# Example of run:
+# Clin::CommandDispatcher.parse('display "My Message"').run
+# Clin::CommandDispatcher.parse('print "My Message"').run
+# Clin::CommandDispatcher.parse('display -h').run
+# Clin::CommandDispatcher.parse('-h')

data/examples/list_option.rb

@@ -17,11 +17,6 @@ class ListCommand < Clin::Command
     end
   end
 end
-
-if __FILE__ == $PROGRAM_NAME
-  ListCommand.parse('--echo "Message 1" --echo "Message 2"').run
-  puts
-  puts '=' * 60
-  puts
-  ListCommand.parse('--echo "Message 3" --echo "Message 4" -ll').run
-end
+# Use examples:
+# ListCommand.parse('--echo "Message 1" --echo "Message 2"').run
+# ListCommand.parse('--echo "Message 3" --echo "Message 4" -ll').run

data/examples/nested_dispatcher.rb

@@ -9,7 +9,7 @@ class DispatchCommand < Clin::Command
 
   flag_option :verbose, 'Verbose the output'
 
-  self.description = 'YOU print the given message'
+  description 'YOU print the given message'
 
   def run
     puts 'Should not be called'
@@ -22,7 +22,7 @@ class DisplayCommand < DispatchCommand
   option :echo, 'Display more text'
   option :times, 'Display the text multiple times', type: Integer
 
-  self.description = 'Display the given message'
+  description 'Display the given message'
 
   def run
     puts "I Display: '#{params[:message]}'"
@@ -33,60 +33,15 @@ end
 class PrintCommand < DispatchCommand
   arguments 'you print <message>'
 
-  self.description = 'Print the given message'
+  description 'Print the given message'
 
   def run
     puts "I Print: '#{params[:message]}'"
   end
 end
 
-if __FILE__ == $PROGRAM_NAME
-  Clin::CommandDispatcher.parse('you display "My Message"').run
-  puts
-  puts '=' * 60
-  puts
-  Clin::CommandDispatcher.parse('you print "My Message"').run
-  puts
-  puts '=' * 60
-  puts
-  begin
-    Clin::CommandDispatcher.parse('you -h').run
-  rescue Clin::CommandLineError => e
-    puts e
-  end
-  puts
-  puts '=' * 60
-  puts
-  begin
-    Clin::CommandDispatcher.parse('-h')
-  rescue Clin::CommandLineError => e
-    puts e
-  end
-end
-
-# Output:
-#
-# $ ruby dispatcher.rb
-# I Display: 'My Message'
-#
-# ============================================================
-#
-# I Print: 'My Message'
-#
-# ============================================================
-#
-# Usage: command you <args>... [Options]
-#
-# Options:
-#     -h, --help                       Show the help.
-#
-# Description:
-# YOU print the given message
-#
-#
-# ============================================================
-#
-# Usage:
-#   command you <args>... [Options]
-#   command you display <message> [Options]
-#   command you print <message> [Options]
+# Example of run:
+# Clin::CommandDispatcher.parse('you display "My Message"').run
+# Clin::CommandDispatcher.parse('you print "My Message"').run
+# Clin::CommandDispatcher.parse('you -h').run
+# Clin::CommandDispatcher.parse('-h')

data/examples/simple.rb

@@ -15,25 +15,6 @@ class SimpleCommand < Clin::Command
   end
 end
 
-if __FILE__ == $PROGRAM_NAME
-  SimpleCommand.parse('display "My Message" --echo SOME').run
-  puts
-  puts '=' * 60
-  puts
-  begin
-    SimpleCommand.parse('').run
-  rescue Clin::HelpError => e
-    puts e
-  end
-end
-# $ ruby simple.rb
-# My Message
-# SOME
-#
-# ============================================================
-#
-#   Usage: command display <message> [Options]
-#
-# Options:
-#   -e, --echo ECHO                  Echo some text
-# -h, --help                       Show the help.
+# Run example:
+# SimpleCommand.parse('display "My Message" --echo SOME').run
+# SimpleCommand.parse('').run

data/examples/test.rb

@@ -1,9 +1,9 @@
-$LOAD_PATH.push File.expand_path('../../lib', __FILE__)
-require 'clin'
-
-a = [1, 2, 3]
-
-b, c = a
-
-puts b
-puts c
+$LOAD_PATH.push File.expand_path('../../lib', __FILE__)
+require 'clin'
+
+
+shell = Clin::Shell.new
+
+choice = shell.choose('What?', %w(france usa italy germany))
+
+puts 'YOu ' + choice

data/lib/clin/argument.rb

@@ -20,7 +20,7 @@ class Clin::Argument
 
   # Check if the argument is optional(i.e [arg])
   def check_optional(argument)
-    if beck_between(argument, '[', ']')
+    if check_between(argument, '[', ']')
       @optional = true
       return argument[1...-1]
     end
@@ -38,7 +38,7 @@ class Clin::Argument
 
   # Check if the argument is variable(i.e <arg>)
   def check_variable(argument)
-    if beck_between(argument, '<', '>')
+    if check_between(argument, '<', '>')
       @variable = true
       return argument[1...-1]
     end
@@ -94,7 +94,7 @@ class Clin::Argument
   #   beck_between('[<arg>]', '<'. '>') # => false
   #   beck_between('[<arg>', '<'. '>') # => raise Clin::Error
   # ```
-  def beck_between(argument, start_char, end_char)
+  def check_between(argument, start_char, end_char)
     if argument[0] == start_char
       if argument[-1] != end_char
         fail Clin::Error, "Argument format error! Cannot start

data/lib/clin/command.rb

@@ -1,83 +1,15 @@
 require 'clin'
-require 'clin/command_options_mixin'
 require 'clin/argument'
 require 'shellwords'
 require 'clin/common/help_options'
 
 # Clin Command
-class Clin::Command < Clin::CommandOptionsMixin
-  class_attribute :args
-  class_attribute :description
+class Clin::Command
+  include Clin::CommandMixin::Core
+  include Clin::CommandMixin::Dispatcher
+  include Clin::CommandMixin::Options
 
-  # Redispatch will be reset to nil when inheriting a dispatcher command
-  class_attribute :_redispatch_args
-  class_attribute :_abstract
-  class_attribute :_exe_name
-  class_attribute :_skip_options
-
-  self.args = []
-  self.description = ''
-  self._abstract = false
-  self._skip_options = false
-
-  # Trigger when a class inherit this class
-  # Rest class_attributes that should not be shared with subclass
-  # @param subclass [Clin::Command]
-  def self.inherited(subclass)
-    subclass._redispatch_args = nil
-    subclass._abstract = false
-    subclass._skip_options = false
-    super
-  end
-
-  # Mark the class as abstract
-  def self.abstract(value)
-    self._abstract = value
-  end
-
-  # Set or get the exe name.
-  # Executable name that will be display in the usage.
-  # If exe_name is not set in a class or it's parent it will use the global setting Clin.exe_name
-  # @param value [String] name of the exe.
-  # ```
-  # class Git < Clin::Command
-  #   exe_name 'git'
-  #   arguments '<command> <args>...'
-  # end
-  # Git.usage # => git <command> <args>...
-  # ```
-  def self.exe_name(value = nil)
-    self._exe_name = value unless value.nil?
-    self._exe_name ||= Clin.exe_name
-  end
-
-  def self.skip_options(value)
-    self._skip_options = value
-  end
-
-  def self.skip_options?
-    _skip_options
-  end
-
-  def self.redispatch?
-    !_redispatch_args.nil?
-  end
-
-  def self.arguments(args)
-    self.args = []
-    [*args].map(&:split).flatten.each do |arg|
-      self.args += [Clin::Argument.new(arg)]
-    end
-  end
-
-  def self.usage
-    a = [exe_name, args.map(&:original).join(' '), '[Options]']
-    a.reject(&:blank?).join(' ')
-  end
-
-  def self.banner
-    "Usage: #{usage}"
-  end
+  general_option 'Clin::HelpOptions'
 
   # Parse the command and initialize the command object with the parsed options
   # @param argv [Array|String] command line to parse.
@@ -86,63 +18,16 @@ class Clin::Command < Clin::CommandOptionsMixin
     parser.parse
   end
 
-  # Build the Option Parser object
-  # Used to parse the option
-  # Useful for regenerating the help as well.
-  def self.option_parser(out = {})
-    OptionParser.new do |opts|
-      opts.banner = banner
-      opts.separator ''
-      opts.separator 'Options:'
-      register_options(opts, out)
-      dispatch_doc(opts)
-      unless description.blank?
-        opts.separator "\nDescription:"
-        opts.separator description
-      end
-      opts.separator ''
-    end
-  end
-
-  # Redispatch the command to a sub command with the given arguments
-  # @param args [Array<String>|String] New argument to parse
-  # @param prefix [String] Prefix to add to the beginning of the command
-  # @param commands [Array<Clin::Command.class>] Commands that will be tried against
-  # If no commands are given it will look for Clin::Command in the class namespace
-  # e.g. If those 2 classes are defined.
-  # `MyDispatcher < Clin::Command` and `MyDispatcher::ChildCommand < Clin::Command`
-  # Will test against ChildCommand
-  def self.dispatch(args, prefix: nil, commands: nil)
-    self._redispatch_args = [[*args], prefix, commands]
-  end
-
-  def self.dispatch_doc(opts)
-    return if _redispatch_args.nil?
-    opts.separator 'Examples: '
-    commands = (_redispatch_args[2] || default_commands)
-    commands.each do |cmd_cls|
-      opts.separator "\t#{cmd_cls.usage}"
-    end
-  end
-
-  def self.default_commands
-    # self.constants.map { |c| self.const_get(c) }
-    # .select { |c| c.is_a?(Class) && (c < Clin::Command) }
-    subcommands
-  end
-
-  # List the subcommands
-  # The subcommands are all the Classes inheriting this one that are not set to abstract
-  def self.subcommands
-    subclasses.reject(&:_abstract)
-  end
-
-  general_option 'Clin::HelpOptions'
-
+  # Contains the parameters
   attr_accessor :params
 
+  # Contains a shell object for user interaction in the command
+  # @see Clin::Shell
+  attr_accessor :shell
+
   def initialize(params = {})
     @params = params
+    @shell = Clin::Shell.new
     self.class.execute_general_options(params)
   end
 end

data/lib/clin/command_mixin/core.rb

@@ -0,0 +1,152 @@
+require 'clin'
+
+# Contains the core class methods for the command mixin
+module Clin::CommandMixin::Core
+  extend ActiveSupport::Concern
+  included do
+    @_arguments = []
+    @_default_priority = 1000
+    @_priority = 0
+  end
+
+  module ClassMethods # :nodoc:
+    attr_accessor :_arguments
+    attr_accessor :_description
+    attr_accessor :_abstract
+    attr_accessor :_exe_name
+    attr_accessor :_skip_options
+    attr_accessor :_default_priority
+    attr_accessor :_priority
+
+    # Trigger when a class inherit this class
+    # Rest class_attributes that should not be shared with subclass
+    # @param subclass [Clin::Command]
+    def inherited(subclass)
+      subclass._arguments = []
+      subclass._description = ''
+      subclass._abstract = false
+      subclass._skip_options = false
+      subclass._exe_name = @_exe_name
+      subclass._default_priority = @_default_priority.to_f / 2
+      subclass._priority = 0
+      super
+    end
+
+    # Mark the class as abstract
+    def abstract(value)
+      @_abstract = value
+    end
+
+    # Return if the current command class is abstract
+    # @return [Boolean]
+    def abstract?
+      @_abstract
+    end
+
+    # Set or get the exe name.
+    # Executable name that will be display in the usage.
+    # If exe_name is not set in a class or it's parent it will use the global setting Clin.exe_name
+    # @param value [String] name of the exe.
+    # ```
+    # class Git < Clin::Command
+    #   exe_name 'git'
+    #   arguments '<command> <args>...'
+    # end
+    # Git.usage # => git <command> <args>...
+    # ```
+    def exe_name(value = nil)
+      @_exe_name = value unless value.nil?
+      @_exe_name ||= Clin.exe_name
+    end
+
+    # Allow the current option to skip unknown options.
+    # @param value [Boolean] skip or not
+    def skip_options(value)
+      @_skip_options = value
+    end
+
+    # Is the current command skipping options
+    def skip_options?
+      @_skip_options
+    end
+
+    # Set or get the arguments for the command
+    # @param args [Array<String>] List of arguments to set. If nil it just return the current args.
+    def arguments(args = nil)
+      return @_arguments if args.nil?
+      @_arguments = []
+      [*args].map(&:split).flatten.each do |arg|
+        @_arguments << Clin::Argument.new(arg)
+      end
+    end
+
+    alias_method :args, :arguments
+
+    # Set or get the description
+    # @param desc [String] Description to set. If nil it just return the current value.
+    def description(desc = nil)
+      @_description = desc unless desc.nil?
+      @_description
+    end
+
+    def usage
+      a = [exe_name, @_arguments.map(&:original).join(' '), '[Options]']
+      a.reject(&:blank?).join(' ')
+    end
+
+    def banner
+      "Usage: #{usage}"
+    end
+
+    # Priorities this command.
+    # This does not set the priority. It add +value+ to the default priority
+    # The default priority is computed using half of the parent default priority.
+    # e.g.
+    # ```
+    # Parent = Class.new(Clin::Command)
+    # Child1 = Class.new(Parent)
+    # Child2 = Class.new(Parent)
+    # Parent.priority # => 500
+    # Child1.priority # => 250
+    # Child2.priority # => 250
+    # Child2.prioritize
+    # Child2.priority # => 251
+    # ```
+    # When dispatching commands they are sorted by priority
+    def prioritize(value = 1)
+      @_priority = value
+    end
+
+    def priority
+      @_default_priority + @_priority
+    end
+
+    # Build the Option Parser object
+    # Used to parse the option
+    # Useful for regenerating the help as well.
+    def option_parser(out = {})
+      OptionParser.new do |opts|
+        opts.banner = banner
+        opts.separator ''
+        opts.separator 'Options:'
+        register_options(opts, out)
+        dispatch_doc(opts)
+        unless @description.blank?
+          opts.separator "\nDescription:"
+          opts.separator @description
+        end
+        opts.separator ''
+      end
+    end
+
+    def default_commands
+      subcommands.sort_by(&:priority).reverse
+    end
+
+    # List the subcommands
+    # The subcommands are all the Classes inheriting this one that are not set to abstract
+    def subcommands
+      subclasses.reject(&:abstract?)
+    end
+  end
+end

data/lib/clin/command_mixin/dispatcher.rb

@@ -0,0 +1,34 @@
+require 'clin'
+
+# Dispatcher mixin contains the class methods for command that need to redispatch to subcommands
+module Clin::CommandMixin::Dispatcher
+  extend ActiveSupport::Concern
+  module ClassMethods # :nodoc:
+    attr_accessor :_redispatch_args
+
+    # Redispatch the command to a sub command with the given arguments
+    # @param args [Array<String>|String] New argument to parse
+    # @param prefix [String] Prefix to add to the beginning of the command
+    # @param commands [Array<Clin::Command.class>] Commands that will be tried against
+    # If no commands are given it will look for Clin::Command in the class namespace
+    # e.g. If those 2 classes are defined.
+    # `MyDispatcher < Clin::Command` and `MyDispatcher::ChildCommand < Clin::Command`
+    # Will test against ChildCommand
+    def dispatch(args, prefix: nil, commands: nil)
+      @_redispatch_args = [[*args], prefix, commands]
+    end
+
+    def redispatch?
+      !@_redispatch_args.nil?
+    end
+
+    def dispatch_doc(opts)
+      return if _redispatch_args.nil?
+      opts.separator 'Examples: '
+      commands = (_redispatch_args[2] || default_commands)
+      commands.each do |cmd_cls|
+        opts.separator "\t#{cmd_cls.usage}"
+      end
+    end
+  end
+end