clin 0.2.0 → 0.3.0

data/lib/clin/command_mixin/options.rb

@@ -0,0 +1,134 @@
+require 'clin'
+require 'clin/option'
+
+# Contains class methods to add option to a command or a General option
+module Clin::CommandMixin::Options
+  extend ActiveSupport::Concern
+
+  included do
+    self.options = []
+    self.general_options = {}
+    # Trigger when a class inherit this class
+    # It will clone attributes that need inheritance
+    # @param subclass [Clin::Command]
+    def self.inherited(subclass)
+      subclass.options = @options.clone
+      subclass.general_options = @general_options.clone
+      super
+    end
+  end
+
+  module ClassMethods # :nodoc:
+    attr_accessor :options
+    attr_accessor :general_options
+
+    # Add an option
+    # @param args list of arguments.
+    #   * First argument must be the name if no block is given.
+    #     It will set automatically read the value into the hash with  +name+ as key
+    #   * The remaining arguments are OptionsParser#on arguments
+    # ```
+    #   option :require, '-r', '--require [LIBRARY]', 'Require the library'
+    #   option '-h', '--helper', 'Show the help' do
+    #     puts opts
+    #     exit
+    #   end
+    # ```
+    def opt_option(*args, &block)
+      add_option Clin::Option.new(*args, &block)
+    end
+
+    # Add an option.
+    # Helper method that just create a new Clin::Option with the argument then call add_option
+    # ```
+    #   option :show, 'Show some message'
+    #   # => -s --show              SHOW Show some message
+    #   option :require, 'Require a library', short: false, optional: true, argument: 'LIBRARY'
+    #   # => --require [LIBRARY]    Require a library
+    #   option :help, 'Show the help', argument: false do
+    #     puts opts
+    #     exit
+    #   end
+    #   # => -h --help              Show the help
+    # ```
+    def option(name, description, **config, &block)
+      add_option Clin::Option.new(name, description, **config, &block)
+    end
+
+    # For an option that does not have an argument
+    # Same as .option except it will default argument to false
+    # ```
+    #   option :verbose, 'Use verbose' #=> -v --verbose will be added to the option of this command
+    # ```
+    def flag_option(name, description, **config, &block)
+      add_option Clin::Option.new(name, description, **config.merge(argument: false), &block)
+    end
+
+    # Add a list option.
+    # @see Clin::OptionList#initialize
+    def list_option(name, description, **config)
+      add_option Clin::OptionList.new(name, description, **config)
+    end
+
+    # Add a list options that don't take arguments
+    # Same as .list_option but set +argument+ to false
+    # @see Clin::OptionList#initialize
+    def list_flag_option(name, description, **config)
+      add_option Clin::OptionList.new(name, description, **config.merge(argument: false))
+    end
+
+    def auto_option(name, usage, &block)
+      add_option Clin::Option.parse(name, usage, &block)
+    end
+
+    # Add a new option.
+    # @param option [Clin::Option] option to add.
+    def add_option(option)
+      # Need to use += instead of << otherwise the parent class will also be changed
+      @options << option
+    end
+
+    # Add a general option
+    # @param option_cls [Class<GeneralOption>] Class inherited from GeneralOption
+    # @param config [Hash] General option config. Check the general option config.
+    def general_option(option_cls, config = {})
+      option_cls = option_cls.constantize if option_cls.is_a? String
+      @general_options[option_cls] = option_cls.new(config)
+    end
+
+    # Remove a general option
+    # Might be useful if a parent added the option but is not needed in this child.
+    def remove_general_option(option_cls)
+      option_cls = option_cls.constantize if option_cls.is_a? String
+      @general_options.delete(option_cls)
+    end
+
+    # To be called inside OptionParser block
+    # Extract the option in the command line using the OptionParser and map it to the out map.
+    # @param opts [OptionParser]
+    # @param out [Hash] Where the options shall be extracted
+    def register_options(opts, out)
+      @options.each do |option|
+        option.register(opts, out)
+      end
+
+      @general_options.each do |_cls, option|
+        option.class.register_options(opts, out)
+      end
+    end
+
+    # Call #execute on each of the general options.
+    # This is called during the command initialization
+    # e.g. A verbose general option execute would be:
+    # ```
+    # def execute(params)
+    #  MyApp.verbose = true if params[:verbose]
+    # end
+    # ```
+    def execute_general_options(options)
+      general_options.each do |_cls, gopts|
+        gopts.execute(options)
+      end
+    end
+  end
+end

data/lib/clin/command_mixin.rb

@@ -0,0 +1,9 @@
+require 'clin'
+
+# Namespace module for all the command mixins
+module Clin::CommandMixin
+end
+
+require 'clin/command_mixin/core'
+require 'clin/command_mixin/dispatcher'
+require 'clin/command_mixin/options'

data/lib/clin/general_option.rb

@@ -1,7 +1,9 @@
 require 'clin'
 
 # Parent class for reusable options across commands
-class Clin::GeneralOption < Clin::CommandOptionsMixin
+class Clin::GeneralOption
+  include Clin::CommandMixin::Options
+
   def initialize(_config = {})
   end
 

data/lib/clin/option.rb

@@ -3,8 +3,31 @@ require 'clin'
 # Option container.
 # Prefer the `.option`, `.flag_option`,... class methods than `.add_option Option.new(...)`
 class Clin::Option
+  def self.parse(name, usage, &block)
+    long = nil
+    short = nil
+    argument = nil
+    desc = []
+    usage.split.each do |segment|
+      if segment.start_with? '--'
+        long, argument = segment.split('=', 2)
+      elsif segment.start_with? '-'
+        short = segment
+      else
+        desc << segment
+      end
+    end
+    argument = false if argument.nil?
+    new(name, desc.join(' '), short: short, long: long, argument: argument, &block)
+  end
+
   attr_accessor :name, :description, :optional_argument, :block, :type, :default
-  attr_reader :short, :long, :argument
+
+  # Set the short name(e.g. -v for verbose)
+  attr_writer :short
+
+  # Set the long name(e.g. --verbose for verbose)
+  attr_writer :long
 
   # Create a new option.
   # @param name [String] Option name.
@@ -24,7 +47,7 @@ class Clin::Option
     @short = short
     @long = long
     @optional_argument = argument_optional
-    @argument = argument
+    self.argument = argument
     @type = type
     @block = block
     @default = default
@@ -101,6 +124,18 @@ class Clin::Option
     @argument ||= default_argument
   end
 
+  # Set the argument
+  # @param value
+  def argument=(value)
+    if value
+      arg = Clin::Argument.new(value)
+      @optional_argument = true if arg.optional
+      @argument = arg.name
+    else # If false or nil
+      @argument = value
+    end
+  end
+
   def option_parser_arguments
     args = [short, long_argument, @type, description]
     args.compact
@@ -153,4 +188,3 @@ class Clin::Option
     out
   end
 end
-

data/lib/clin/option_list.rb

@@ -1,8 +1,8 @@
 require 'clin'
 require 'clin/option'
 
+# Option that can be used multiple time in the command line
 class Clin::OptionList < Clin::Option
-
   # @see Clin::Option#initialize
   def initialize(*args)
     super

data/lib/clin/shell.rb

@@ -0,0 +1,111 @@
+require 'clin'
+
+# Class the offer helper method to interact with the user using the command line
+class Clin::Shell
+  # Input stream, default: STDIN
+  attr_accessor :in
+
+  # Output stream, default: STDOUT
+  attr_accessor :out
+
+  def initialize(input: STDIN, output: STDOUT)
+    @in = input
+    @out = output
+    @yes_or_no_persist = false
+    @override_persist = false
+  end
+
+  # Ask a question
+  # @param statement [String]
+  # @param default [String]
+  # @param autocomplete [Array|Proc] Filter for autocomplete
+  def ask(statement, default: nil, autocomplete: nil)
+    answer = scan(statement, autocomplete: autocomplete)
+    if answer.blank?
+      default
+    else
+      answer.strip
+    end
+  end
+
+  # Ask a question and expect the result to be in the list of choices
+  # Will continue asking until the input is correct
+  # or if a default value is supplied then empty will return.
+  # @param statement [String] Question to ask
+  # @param choices [Array] List of choices
+  # @param default [String] Default value if the user put blank value.
+  # @param allow_initials [Boolean] Allow the user to reply with only the initial of the choice.
+  #   (e.g. yes/no => y/n)
+  # If multiple choices start with the same initial
+  # ONLY the first one will be able to be selected using its initial
+  def choose(statement, choices, default: nil, allow_initials: false)
+    Clin::ShellInteraction::Choose.new(self).run(statement, choices,
+                                                 default: default, allow_initials: allow_initials)
+  end
+
+  # Expect the user the return yes or no(y/n also works)
+  # @param statement [String] Question to ask
+  # @param default [String] Default value(yes/no)
+  # @param persist [Boolean] Add "always" to the choices. When all is selected all the following
+  # call to yes_or_no with persist: true will return true instead of asking the user.
+  def yes_or_no(statement, default: nil, persist: false)
+    Clin::ShellInteraction::YesOrNo.new(self).run(statement, default: default, persist: persist)
+  end
+
+  # Yes or no question defaulted to yes
+  # @param options [Hash] Named parameters for yes_or_no
+  # @see #yes_or_no
+  def yes?(statement, options = {})
+    options[:default] = :yes
+    yes_or_no(statement, **options)
+  end
+
+  # Yes or no question defaulted to no
+  # @param options [Hash] Named parameters for yes_or_no
+  # @see #yes_or_no
+  def no?(statement, options = {})
+    options[:default] = :no
+    yes_or_no(statement, **options)
+  end
+
+  # File conflict helper method.
+  # Give the following options to the user
+  # - yes, Yes for this one
+  # - no, No for this one
+  # - all, Yes for all one
+  # - quit, Quit the program
+  # - diff, Diff the 2 files
+  # @param filename [String] Filename with the conflict
+  # @param block [Block] optional block that give the new content in case of diff
+  # @return [Boolean] If the file should be overwritten.
+  def file_conflict(filename, default: nil, &block)
+    Clin::ShellInteraction::FileConflict.new(self).run(filename, default: default, &block)
+  end
+
+  # File conflict question defaulted to yes
+  def overwrite?(filename, &block)
+    file_conflict(filename, default: :yes, &block)
+  end
+
+  # File conflict question defaulted to no
+  def keep?(filename, &block)
+    file_conflict(filename, default: :no, &block)
+  end
+
+  # Prompt the statement to the user and return his reply.
+  # @param statement [String]
+  # @param autocomplete [Array|Block]
+  protected def scan(statement, autocomplete: nil)
+    unless autocomplete.nil?
+      Readline.completion_proc = if autocomplete.is_a? Proc
+                                   autocomplete
+                                 else
+                                   proc { |s| autocomplete.grep(/^#{Regexp.escape(s)}/) }
+                                 end
+    end
+    Readline.completion_append_character = nil
+    Readline.readline(statement + ' ', true)
+  end
+end
+
+require 'clin/shell_interaction'

data/lib/clin/shell_interaction/choose.rb

@@ -0,0 +1,59 @@
+require 'clin'
+
+# Handle a choose question
+class Clin::ShellInteraction::Choose < Clin::ShellInteraction
+  def run(statement, choices, default: nil, allow_initials: false)
+    choices = convert_choices(choices)
+    question = prepare_question(statement, choices, default: default, initials: allow_initials)
+    loop do
+      answer = @shell.ask(question, default: default, autocomplete: choices.keys)
+      unless answer.nil?
+        choices.each do |choice, _|
+          if choice.casecmp(answer) == 0 || (allow_initials && choice[0].casecmp(answer[0]) == 0)
+            return choice
+          end
+        end
+      end
+      print_choices_help(choices, allow_initials: allow_initials)
+    end
+  end
+
+  protected def choice_message(choices, default: nil, initials: false)
+    choices = choices.keys.map { |x| x == default ? x.to_s.upcase : x }
+    msg = if initials
+            choices.map { |x| x[0] }.join('')
+          else
+            choices.join(',')
+          end
+    "[#{msg}]"
+  end
+
+  protected def prepare_question(statement, choices, default: nil, initials: false)
+    "#{statement} #{choice_message(choices, default: default, initials: initials)}"
+  end
+
+  # Convert the choices to a hash with key being the choice and value the description
+  protected def convert_choices(choices)
+    if choices.is_a? Array
+      Hash[*choices.map { |k| [k, ''] }.flatten]
+    elsif choices.is_a? Hash
+      choices
+    end
+  end
+
+  protected def print_choices_help(choices, allow_initials: false)
+    puts 'Choose from:'
+    used_initials = Set.new
+    choices.each do |choice, description|
+      suf = choice.to_s
+      suf += ", #{description}" unless description.blank?
+      line = if allow_initials && !used_initials.include?(choice[0])
+               used_initials << choice[0]
+               "  #{choice[0]} - #{suf}"
+             else
+               "      #{suf}"
+             end
+      puts line
+    end
+  end
+end

data/lib/clin/shell_interaction/file_conflict.rb

@@ -0,0 +1,53 @@
+require 'clin'
+
+# Handle the file_conflict interaction with the user.
+class Clin::ShellInteraction::FileConflict < Clin::ShellInteraction
+  def run(filename, default: nil, &block)
+    choices = file_conflict_choices
+    choices = choices.except(:diff) unless block_given?
+    return true if persist?
+    result = nil
+    while result.nil?
+      choice = @shell.choose("Overwrite '#{filename}'?", choices,
+                             default: default, allow_initials: true)
+      result = handle_choice(choice, filename, &block)
+    end
+    result
+  end
+
+  protected def handle_choice(choice, filename, &block)
+    case choice
+    when :yes
+      return true
+    when :no
+      return false
+    when :always
+      return persist!
+    when :quit
+      puts 'Aborting...'
+      fail SystemExit
+    when :diff
+      show_diff(filename, block.call)
+      return nil
+    else
+      return nil
+    end
+  end
+
+  protected def file_conflict_choices
+    {yes: 'Overwrite',
+     no: 'Do not Overwrite',
+     always: 'Override this and all the next',
+     quit: 'Abort!',
+     diff: 'Show the difference',
+     help: 'Show this'}
+  end
+
+  protected def show_diff(old_file, new_content)
+    Tempfile.open(File.basename(old_file)) do |f|
+      f.write new_content
+      f.rewind
+      system %(#{Clin.diff_cmd} "#{old_file}" "#{f.path}")
+    end
+  end
+end

data/lib/clin/shell_interaction/yes_or_no.rb

@@ -0,0 +1,16 @@
+require 'clin'
+
+# Handle a simple yes/no interaction
+class Clin::ShellInteraction::YesOrNo < Clin::ShellInteraction
+  def run(statement, default: nil, persist: false)
+    default = default.to_sym unless default.nil?
+    options = [:yes, :no]
+    if persist
+      return true if persist?
+      options << :always
+    end
+    choice = @shell.choose(statement, options, default: default, allow_initials: true)
+    return persist! if choice == :always
+    choice == :yes
+  end
+end

data/lib/clin/shell_interaction.rb

@@ -0,0 +1,34 @@
+require 'clin'
+
+# Parent class for shell interaction.
+class Clin::ShellInteraction
+  class << self
+    attr_accessor :persist
+  end
+
+  attr_accessor :shell
+
+  # @param shell [Clin::Shell] Shell starting the interaction.
+  def initialize(shell)
+    @shell = shell
+    self.class.persist ||= {}
+  end
+
+  # @return [Boolean]
+  def persist?
+    self.class.persist[@shell] ||= false
+  end
+
+  # Mark the current shell to persist file interaction
+  def persist!
+    self.class.persist[@shell] = persist_answer
+  end
+
+  def persist_answer
+    true
+  end
+end
+
+require 'clin/shell_interaction/file_conflict'
+require 'clin/shell_interaction/yes_or_no'
+require 'clin/shell_interaction/choose'

data/lib/clin/version.rb

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

data/lib/clin.rb

@@ -1,6 +1,7 @@
 require 'active_support'
 require 'active_support/core_ext'
 require 'optparse'
+require 'readline'
 require 'clin/version'
 
 # Clin Global module. All classes and clin modules should be inside this module
@@ -9,6 +10,9 @@ module Clin
     # Set the global exe name. `Clin.exe_name = 'git'`
     attr_writer :exe_name
 
+    # Set the command when comparing 2 files(Used in the shell)
+    attr_writer :diff_cmd
+
     def default_exe_name
       'command'
     end
@@ -18,15 +22,20 @@ module Clin
     def exe_name
       @exe_name ||= Clin.default_exe_name
     end
+
+    def diff_cmd
+      @diff_cmd ||= 'diff -u'
+    end
   end
 end
 
+require 'clin/command_mixin'
 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'
+require 'clin/shell'

data/spec/clin/command_dispacher_spec.rb

@@ -43,8 +43,8 @@ RSpec.describe Clin::CommandDispatcher do
   end
 
   describe '#parse' do
-    let(:cmd1) { double(:command, parse: 'cmd1', usage: 'cmd1 use') }
-    let(:cmd2) { double(:command, parse: 'cmd2', usage: 'cmd1 use') }
+    let(:cmd1) { double(:command_mixin, parse: 'cmd1', usage: 'cmd1 use') }
+    let(:cmd2) { double(:command_mixin, parse: 'cmd2', usage: 'cmd1 use') }
     let(:args) { %w(some args) }
     subject { Clin::CommandDispatcher.new(cmd1, cmd2) }
     context 'when first command match' do
@@ -81,4 +81,4 @@ RSpec.describe Clin::CommandDispatcher do
       it { expect(@error.to_s).to eq(subject.help_message) }
     end
   end
-end
+end

data/spec/clin/command_mixin/core_spec.rb

@@ -0,0 +1,37 @@
+RSpec.describe Clin::CommandMixin::Core do
+  def new_subject
+    a = Class.new
+    a.include Clin::CommandMixin::Core
+    a
+  end
+
+  describe '.prioritize' do
+    subject { new_subject }
+    it 'set priority to 1 when no argument given' do
+      subject.prioritize
+      expect(subject._priority).to be 1
+    end
+
+    it 'set priority to 1 when no argument given' do
+      subject.prioritize(42)
+      expect(subject._priority).to be 42
+    end
+  end
+
+  describe '.priority' do
+    subject { new_subject }
+    it 'get the default priority' do
+      expect(subject.priority).to be subject._default_priority
+    end
+
+    it 'sum default and priority when subject has been prioritize' do
+      subject.prioritize(42)
+      expect(subject.priority).to be subject._default_priority + 42
+    end
+
+    it 'has a smaller priority when inheriting' do
+      child = Class.new(subject)
+      expect(child.priority).to be < subject.priority
+    end
+  end
+end

data/spec/clin/{command_options_mixin_spec.rb → command_mixin/options_spec.rb}

@@ -1,9 +1,14 @@
 require 'spec_helper'
-require 'clin/command_options_mixin'
 
-RSpec.describe Clin::CommandOptionsMixin do
+RSpec.describe Clin::CommandMixin::Options do
+  def new_subject
+    a = Class.new
+    a.include Clin::CommandMixin::Options
+    a
+  end
+
   describe '#add_option' do
-    subject { Class.new(Clin::CommandOptionsMixin) }
+    subject { new_subject }
     let(:option) { Clin::Option.new(:name, '-n') }
     before do
       subject.add_option option
@@ -11,11 +16,10 @@ RSpec.describe Clin::CommandOptionsMixin do
 
     it { expect(subject.options.size).to be 1 }
     it { expect(subject.options.first).to eq option }
-    it { expect(Clin::CommandOptionsMixin.options.size).to be 0 }
   end
 
   describe '#option' do
-    subject { Class.new(Clin::CommandOptionsMixin) }
+    subject { new_subject }
     let(:args) { [:name, '-n'] }
     let(:option) { Clin::Option.new(*args) }
 
@@ -29,7 +33,7 @@ RSpec.describe Clin::CommandOptionsMixin do
   end
 
   describe '#general_option' do
-    subject { Class.new(Clin::CommandOptionsMixin) }
+    subject { new_subject }
     let(:option) { double(:option, register_options: true, new: true) }
     before do
       subject.general_option option
@@ -37,11 +41,10 @@ RSpec.describe Clin::CommandOptionsMixin do
     it { expect(option).to have_received(:new) }
     it { expect(subject.general_options.size).to be 1 }
     it { expect(subject.general_options.values.first).to eq(true) }
-    it { expect(Clin::CommandOptionsMixin.general_options.size).to be 0 }
   end
 
   describe '#register_options' do
-    subject { Class.new(Clin::CommandOptionsMixin) }
+    subject { new_subject }
     let(:opt1) { double(:option, register: true) }
     let(:opt2) { double(:option, register: true) }
     let(:g_opt_cls) { double(:general_option_class, register_options: true) }

data/spec/clin/command_parser_spec.rb

@@ -130,8 +130,8 @@ RSpec.describe Clin::CommandParser do
     end
 
     context 'when using commands' do
-      let(:cmd1) { double(:command) }
-      let(:cmd2) { double(:command) }
+      let(:cmd1) { double(:command_mixin) }
+      let(:cmd2) { double(:command_mixin) }
       before do
         @command.dispatch :args, commands: [cmd1, cmd2]
         allow_any_instance_of(Clin::CommandDispatcher).to receive(:initialize)

data/spec/clin/command_spec.rb

@@ -67,9 +67,9 @@ RSpec.describe Clin::Command 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(:cmd1) { double(:command_mixin, usage: 'cmd1') }
+    let(:cmd2) { double(:command_mixin, usage: 'cmd2') }
+    let(:cmd3) { double(:command_mixin, usage: 'cmd3') }
     let(:cmds) { [cmd1, cmd2, cmd3] }
     let(:opts) { double(:option_parser, separator: true) }
     before do