clin 0.1.0 → 0.2.0

data/lib/clin/command_parser.rb

@@ -0,0 +1,115 @@
+require 'clin'
+
+# Command parser
+class Clin::CommandParser
+  # Create the command parser
+  # @param command_cls [Class<Clin::Command>] Command that must be matched
+  # @param argv [Array<String>] List of CL arguments
+  # @param fallback_help [Boolean] If the parse should raise an HelpError or the real error.
+  def initialize(command_cls, argv = ARGV, fallback_help: true)
+    @command = command_cls
+    argv = Shellwords.split(argv) if argv.is_a? String
+    @argv = argv
+    @fallback_help = fallback_help
+  end
+
+  # Parse the command line.
+  def parse
+    argv = @argv.clone
+    error = nil
+    options = {}
+    begin
+      options.merge! parse_options(argv)
+    rescue Clin::OptionError => e
+      error = e
+    end
+    begin
+      options.merge! parse_arguments(argv)
+    rescue Clin::ArgumentError => e
+      raise e unless @fallback_help
+      error = e
+    end
+
+    return redispatch(options) if @command.redispatch?
+    obj = @command.new(options)
+    handle_error(error)
+    obj
+  end
+
+  # Parse the options in the argv.
+  # @return [Array] the list of argv that are not options(positional arguments)
+  def parse_options(argv)
+    out = {}
+    parser = @command.option_parser(out)
+    skipped = skipped_options
+    argv.reject! { |x| skipped.include?(x) }
+    begin
+      parser.parse!(argv)
+    rescue OptionParser::InvalidOption => e
+      raise Clin::OptionError, e.to_s
+    end
+    out[:skipped_options] = skipped if @command.skip_options?
+    out
+  end
+
+  # Get the options that have been skipped by options_first!
+  def skipped_options
+    return [] unless @command.skip_options?
+    argv = @argv.dup
+    skipped = []
+    parser = @command.option_parser
+    loop do
+      begin
+        parser.parse!(argv)
+        break
+      rescue OptionParser::InvalidOption => e
+        skipped << e.to_s.sub(/invalid option:\s+/, '')
+        next if argv.empty? || argv.first.start_with?('-')
+        skipped << argv.shift
+      end
+    end
+
+    skipped
+  end
+
+  # Parse the argument. The options must have been strip out first.
+  def parse_arguments(argv)
+    out = {}
+    @command.args.each do |arg|
+      value, argv = arg.parse(argv)
+      out[arg.name.to_sym] = value
+    end
+    out.delete_if { |_, v| v.nil? }
+  end
+
+  # Method called after the argument have been parsed and before creating the command
+  # @param params [Array<String>] Parsed params from the command line.
+  def redispatch(params)
+    commands = @command._redispatch_args.last
+    commands ||= @command.default_commands
+    dispatcher = Clin::CommandDispatcher.new(commands)
+    begin
+      dispatcher.parse(redispatch_arguments(params))
+    rescue Clin::HelpError
+      raise Clin::HelpError, @command.option_parser
+    end
+  end
+
+  # Compute the list of argument to pass to the CommandDispatcher
+  # @param params [Hash] Options and Arguments of the CL
+  def redispatch_arguments(params)
+    args, prefix = @command._redispatch_args
+    args = args.map { |x| params[x] }.flatten.compact
+    args = prefix.split + args unless prefix.nil?
+    args += params[:skipped_options] if @command.skip_options?
+    args
+  end
+
+  # Guard that check if there was an error and fail HelpError if there was
+  # @raise [Clin::HelpError]
+  def handle_error(error)
+    return unless error
+    fail Clin::HelpError, @command.option_parser if @fallback_help
+    fail error
+  end
+end

data/lib/clin/common/help_options.rb

@@ -17,7 +17,6 @@ class Clin::HelpOptions < Clin::GeneralOption
     @raise = raise
   end
 
-
   def execute(options)
     return unless @raise
     fail Clin::HelpError, options[:help] if options[:help]

data/lib/clin/errors.rb

@@ -14,6 +14,9 @@ module Clin
 
   # Error when a fixed argument is not matched
   class FixedArgumentError < ArgumentError
+    # Create a new FixedArgumentError
+    # @param argument [String] Name of the fixed argument
+    # @param got [String] What argument was in place of the fixed argument
     def initialize(argument = '', got = '')
       super("Expecting '#{argument}' but got '#{got}'")
     end
@@ -21,8 +24,10 @@ module Clin
 
   # Error when a command is missing an argument
   class MissingArgumentError < ArgumentError
-    def initialize(message = '')
-      super("Missing argument #{message}")
+    # Create a new MissingArgumentError
+    # @param argument [String] Name of the missing argument
+    def initialize(argument = '')
+      super("Missing argument #{argument}")
     end
   end
 

data/lib/clin/general_option.rb

@@ -1,15 +1,15 @@
 require 'clin'
 
+# Parent class for reusable options across commands
 class Clin::GeneralOption < Clin::CommandOptionsMixin
-
-  def initialize(config = {})
-
+  def initialize(_config = {})
   end
 
   # It get the params the general options needs and do whatever the option is suppose to do with it.
-  # Method called in the initialize of the command. This allow general options to be extracted when parsing a command line
+  # Method called in the initialize of the command.
+  # This allow general options to be extracted when parsing a command line
   # as well as calling the command directly in the code
   # @param _params [Hash] Params got in the command
   def execute(_params)
   end
-end
+end

data/lib/clin/option.rb

@@ -1,24 +1,40 @@
 require 'clin'
 
 # Option container.
+# Prefer the `.option`, `.flag_option`,... class methods than `.add_option Option.new(...)`
 class Clin::Option
-  attr_accessor :name, :description, :optional_argument, :block
+  attr_accessor :name, :description, :optional_argument, :block, :type, :default
   attr_reader :short, :long, :argument
 
-  def initialize(name, description, short: nil, long: nil, argument: nil, optional_argument: false, &block)
+  # Create a new option.
+  # @param name [String] Option name.
+  # @param description [String] Option Description.
+  # @param short [String|Boolean]
+  # @param long [String|Boolean]
+  # @param argument [String|Boolean]
+  # @param argument_optional [Boolean]
+  # @param type [Class]
+  # @param default [Class] If the option is not specified set the default value.
+  #   If default is nil the key will not be added to the params
+  # @param block [Block]
+  def initialize(name, description, short: nil, long: nil,
+                 argument: nil, argument_optional: false, type: nil, default: nil, &block)
     @name = name
     @description = description
     @short = short
     @long = long
-    @optional_argument = optional_argument
+    @optional_argument = argument_optional
     @argument = argument
+    @type = type
     @block = block
+    @default = default
   end
 
   # Register the option to the Option Parser
   # @param opts [OptionParser]
   # @param out [Hash] Out options mapping
   def register(opts, out)
+    load_default(out)
     if @block.nil?
       opts.on(*option_parser_arguments) do |value|
         on(value, out)
@@ -30,14 +46,30 @@ class Clin::Option
     end
   end
 
+  # Default option short name.
+  # ```
+  # :verbose => '-v'
+  # :help => '-h'
+  # :Require => '-r'
+  # ```
   def default_short
     "-#{name[0].downcase}"
   end
 
+  # Default option long name.
+  # ```
+  # :verbose => '--verbose'
+  # :Require => '--require'
+  # :add_stuff => '--add-stuff'
+  # ```
   def default_long
-    "--#{name.downcase}"
+    "--#{name.to_s.downcase.dasherize}"
   end
 
+  # Default argument
+  # ```
+  # :Require => 'REQUIRE'
+  # ```
   def default_argument
     name.to_s.upcase
   end
@@ -47,7 +79,7 @@ class Clin::Option
   # If @short is false it will return nil
   # @return [String]
   def short
-    return nil if @short === false
+    return nil if @short.eql? false
     @short ||= default_short
   end
 
@@ -56,7 +88,7 @@ class Clin::Option
   # If @long is false it will return nil
   # @return [String]
   def long
-    return nil if @long === false
+    return nil if @long.eql? false
     @long ||= default_long
   end
 
@@ -65,31 +97,52 @@ class Clin::Option
   # If @argument is false it will return nil
   # @return [String]
   def argument
-    return nil if @argument === false
+    return nil if flag?
     @argument ||= default_argument
   end
 
   def option_parser_arguments
-    args = [short, long_argument, description]
+    args = [short, long_argument, @type, description]
     args.compact
   end
 
+  # Function called by the OptionParser when the option is used
+  # If no block is given this is called otherwise it call the block
   def on(value, out)
     out[@name] = value
   end
 
+  # If the option is a flag option.
+  # i.e Doesn't accept argument.
+  def flag?
+    @argument.eql? false
+  end
+
+  # Init the output Hash with the default values. Must be called before parsing.
+  # @param out [Hash]
+  def load_default(out)
+    return if @default.nil?
+    begin
+      out[@name] = @default.clone
+    rescue
+      out[@name] = @default
+    end
+  end
+
   def ==(other)
     return false unless other.is_a? Clin::Option
-    @name == other.name &&
-        @description == other.description &&
-        short == other.short &&
-        long == other.long &&
-        argument == other.argument &&
-        @optional_argument == other.optional_argument &&
-        @block == other.block
+    to_a == other.to_a
+  end
+
+  # Return array of the attributes
+  def to_a
+    [@name, @description, @type, short, long, argument, @optional_argument, @default, @block]
   end
 
-  protected
+  # Get the long argument syntax.
+  # ```
+  #  :require => '--require REQUIRE'
+  # ```
   def long_argument
     return nil unless long
     out = long
@@ -100,3 +153,4 @@ class Clin::Option
     out
   end
 end
+

data/lib/clin/option_list.rb

@@ -0,0 +1,25 @@
+require 'clin'
+require 'clin/option'
+
+class Clin::OptionList < Clin::Option
+
+  # @see Clin::Option#initialize
+  def initialize(*args)
+    super
+    if flag?
+      self.default = 0
+    else
+      self.default = []
+    end
+  end
+
+  def on(value, out)
+    if flag?
+      out[@name] ||= 0
+      out[@name] += 1
+    else
+      out[@name] ||= []
+      out[@name] << value
+    end
+  end
+end

data/lib/clin/version.rb

@@ -1,4 +1,4 @@
 # Clin version
 module Clin
-  VERSION = '0.1.0'
+  VERSION = '0.2.0'
 end

data/lib/clin.rb

@@ -5,25 +5,28 @@ require 'clin/version'
 
 # Clin Global module. All classes and clin modules should be inside this module
 module Clin
-  def self.default_exe_name
-    'command'
-  end
+  class << self
+    # Set the global exe name. `Clin.exe_name = 'git'`
+    attr_writer :exe_name
 
-  # Global exe_name
-  # If this is not override it will be 'command'
-  def self.exe_name
-    @exe_name ||= Clin.default_exe_name
-  end
+    def default_exe_name
+      'command'
+    end
 
-  # Set the global exe name
-  def self.exe_name=(value)
-    @exe_name=value
+    # Global exe_name
+    # If this is not override it will be 'command'
+    def exe_name
+      @exe_name ||= Clin.default_exe_name
+    end
   end
 end
 
 require 'clin/command'
+require 'clin/command_parser'
 require 'clin/command_options_mixin'
 require 'clin/general_option'
 require 'clin/command_dispatcher'
 require 'clin/common/help_options'
 require 'clin/errors'
+require 'clin/option'
+require 'clin/option_list'

data/spec/clin/command_parser_spec.rb

@@ -0,0 +1,165 @@
+require 'spec_helper'
+
+RSpec.describe Clin::CommandParser do
+  describe '#parse_options' do
+    before :all do
+      @command = Class.new(Clin::Command)
+      @command.add_option Clin::Option.new(:name, 'Set name')
+      @command.add_option Clin::Option.new(:verbose, 'Set verbose', argument: false)
+      @command.add_option Clin::Option.new(:echo, 'Set name', argument_optional: true)
+    end
+
+    subject { Clin::CommandParser.new(@command, []) }
+
+    it 'raise argument when option value is missing' do
+      expect { subject.parse_options(%w(--name)) }.to raise_error(OptionParser::MissingArgument)
+    end
+    it 'raise error when unknown option' do
+      expect { subject.parse_options(%w(--other)) }.to raise_error(Clin::OptionError)
+    end
+
+    it { expect(subject.parse_options(%w(--name MyName))).to eq(name: 'MyName') }
+    it { expect(subject.parse_options(%w(--name=MyName))).to eq(name: 'MyName') }
+    it { expect(subject.parse_options(%w(-nMyName))).to eq(name: 'MyName') }
+
+
+    it { expect(subject.parse_options(%w(-v))).to eq(verbose: true) }
+
+    it { expect(subject.parse_options(%w(--echo))).to eq(echo: nil) }
+    it { expect(subject.parse_options(%w(-e EchoThis))).to eq(echo: 'EchoThis') }
+  end
+
+
+  describe '#parse_arguments' do
+    before :all do
+      @command = Class.new(Clin::Command)
+      @command.arguments(%w(fix <var> [opt]))
+    end
+
+    subject { Clin::CommandParser.new(@command, []) }
+
+    it 'raise argument when fixed in different' do
+      expect { subject.parse_arguments(%w(other val opt)) }.to raise_error(Clin::CommandLineError)
+    end
+    it 'raise error when too few arguments' do
+      expect { subject.parse_arguments(['fix']) }.to raise_error(Clin::CommandLineError)
+    end
+    it 'raise error when too much argument' do
+      expect { subject.parse_arguments(%w(other val opt more)) }
+        .to raise_error(Clin::CommandLineError)
+    end
+
+    it 'map arguments' do
+      expect(subject.parse_arguments(%w(fix val opt))).to eq(fix: 'fix', var: 'val', opt: 'opt')
+    end
+
+    it 'opt argument is nil when not provided' do
+      expect(subject.parse_arguments(%w(fix val))).to eq(fix: 'fix', var: 'val')
+    end
+  end
+
+  describe '#skipped_options' do
+    def skipped_options(argv)
+      Clin::CommandParser.new(@command, argv).skipped_options
+    end
+
+    before :all do
+      @command = Class.new(Clin::Command)
+      @command.skip_options true
+    end
+
+    context 'when all options should be skipped' do
+      it { expect(skipped_options(%w(pos arg))).to eq([]) }
+
+      it { expect(skipped_options(%w(pos arg --ignore -t))).to eq(%w(--ignore -t)) }
+
+      it { expect(skipped_options(%w(pos arg --ignore value -t))).to eq(%w(--ignore value -t)) }
+
+    end
+    context 'when option are define they should not be skipped' do
+      before :all do
+        @command.flag_option :verbose, 'Verbose'
+      end
+
+      it { expect(skipped_options(%w(pos arg --ignore value -t -v))).to eq(%w(--ignore value -t)) }
+
+      it do
+        expect(skipped_options(%w(pos arg --verbose --ignore value -t)))
+          .to eq(%w(--ignore value -t))
+      end
+
+      it do
+        expect(skipped_options(%w(pos arg --ignore value --verbose -t)))
+          .to eq(%w(--ignore value -t))
+      end
+    end
+  end
+
+  describe '.handle_dispatch' do
+    let(:args) { [Faker::Lorem.word, Faker::Lorem.word] }
+    before :all do
+      @command = Class.new(Clin::Command)
+      @command.arguments(%w(remote <args>...))
+    end
+
+    before do
+      allow_any_instance_of(Clin::CommandDispatcher).to receive(:parse)
+    end
+
+    subject { Clin::CommandParser.new(@command, []) }
+
+    context 'when only dispatching arguments' do
+      before do
+        @command.dispatch :args
+      end
+      it 'call the command dispatcher with the right arguments' do
+        expect_any_instance_of(Clin::CommandDispatcher).to receive(:parse).once.with(args)
+        subject.redispatch(remote: 'remote', args: args)
+      end
+    end
+
+    context 'when using prefix' do
+      let(:prefix) { 'remote' }
+      before do
+        @command.dispatch :args, prefix: prefix
+      end
+      it 'call the command dispatcher with the right arguments' do
+        expect_any_instance_of(Clin::CommandDispatcher).to receive(:parse).once.with([prefix] + args)
+        subject.redispatch(remote: 'remote', args: args)
+      end
+    end
+
+    context 'when using commands' do
+      let(:cmd1) { double(:command) }
+      let(:cmd2) { double(:command) }
+      before do
+        @command.dispatch :args, commands: [cmd1, cmd2]
+        allow_any_instance_of(Clin::CommandDispatcher).to receive(:initialize)
+      end
+      it 'call the command dispatcher with the right arguments' do
+        expect_any_instance_of(Clin::CommandDispatcher).to receive(:initialize).once.with([cmd1, cmd2])
+        subject.redispatch(remote: 'remote', args: args)
+      end
+    end
+
+    context 'when dispatcher raise HelpError' do
+      let(:new_message) { Faker::Lorem.sentence }
+      before do
+        @command.dispatch :args
+        allow_any_instance_of(Clin::CommandDispatcher).to receive(:initialize)
+        allow_any_instance_of(Clin::CommandDispatcher).to receive(:parse) do
+          fail Clin::HelpError, 'Dispatcher error'
+        end
+        allow(@command).to receive(:option_parser).and_return(new_message)
+      end
+      it do
+        expect { subject.redispatch(remote: 'remote', args: args) }
+          .to raise_error(Clin::HelpError)
+      end
+      it do
+        expect { subject.redispatch(remote: 'remote', args: args) }
+          .to raise_error(new_message)
+      end
+    end
+  end
+end

data/spec/clin/command_spec.rb

@@ -0,0 +1,112 @@
+require 'spec_helper'
+require 'clin/command'
+
+RSpec.describe Clin::Command do
+  describe '#arguments=' do
+    subject { Class.new(Clin::Command) }
+    let(:args) { %w(fix <var> [opt]) }
+    before do
+      allow(Clin::Argument).to receive(:new)
+    end
+    context 'when using string to set arguments' do
+      before do
+        subject.arguments (args.join(' '))
+      end
+      it { expect(subject.args.size).to eq(args.size) }
+      it { expect(Clin::Argument).to have_received(:new).exactly(args.size).times }
+    end
+
+    context 'when using array to set arguments' do
+      before do
+        subject.arguments (args)
+      end
+      it { expect(subject.args.size).to eq(args.size) }
+      it { expect(Clin::Argument).to have_received(:new).exactly(args.size).times }
+    end
+
+    context 'when using array that contains multiple arguments to set arguments' do
+      before do
+        subject.arguments ([args[0], args[1..-1]])
+      end
+      it { expect(subject.args.size).to eq(args.size) }
+      it { expect(Clin::Argument).to have_received(:new).exactly(args.size).times }
+    end
+
+  end
+
+  describe '#banner' do
+    subject { Class.new(Clin::Command) }
+    context 'when exe is defined' do
+      let(:exe) { Faker::Lorem.word }
+      before do
+        subject.exe_name(exe)
+      end
+
+      it { expect(subject.banner).to eq("Usage: #{exe} [Options]") }
+    end
+
+    context 'when exe is not defined' do
+      it { expect(subject.banner).to eq('Usage: command [Options]') }
+    end
+
+    context 'when arguments are defined' do
+      let(:arguments) { '<some> [Value]' }
+      before do
+        subject.arguments(arguments)
+      end
+
+      it { expect(subject.banner).to eq("Usage: #{Clin.default_exe_name} #{arguments} [Options]") }
+    end
+  end
+
+
+
+  describe '.dispatch_doc' do
+    subject { Class.new(Clin::Command) }
+    before do
+      subject.arguments(%w(remote <args>...))
+    end
+
+    let(:cmd1) { double(:command, usage: 'cmd1') }
+    let(:cmd2) { double(:command, usage: 'cmd2') }
+    let(:cmd3) { double(:command, usage: 'cmd3') }
+    let(:cmds) { [cmd1, cmd2, cmd3] }
+    let(:opts) { double(:option_parser, separator: true) }
+    before do
+      subject.dispatch :args, commands: cmds
+      allow_any_instance_of(Clin::CommandDispatcher).to receive(:initialize)
+      subject.dispatch_doc(opts)
+    end
+    it { expect(opts).to have_received(:separator).at_least(cmds.size).times }
+  end
+
+  describe '.subcommands' do
+    before do
+      @cmd1 = Class.new(Clin::Command)
+      @cmd2 = Class.new(Clin::Command)
+      @abstract_cmd = Class.new(Clin::Command) { abstract true }
+    end
+
+    it { expect(Clin::Command.subcommands).to include(@cmd1) }
+    it { expect(Clin::Command.subcommands).to include(@cmd2) }
+    it { expect(Clin::Command.subcommands).not_to include(@abstract_cmd) }
+  end
+
+  describe '.exe_name' do
+    context 'when not setting the exe_name' do
+      subject { Class.new(Clin::Command) }
+
+      it { expect(subject.exe_name).to eq(Clin.exe_name) }
+    end
+
+    context 'when setting the exe_name' do
+      let(:name) { Faker::Lorem.word }
+      subject { Class.new(Clin::Command) }
+      before do
+        subject.exe_name(name)
+      end
+      it { expect(subject.exe_name).to eq(name) }
+    end
+  end
+
+end