command_mapper 0.1.0.pre1

data/lib/command_mapper/option.rb

@@ -0,0 +1,282 @@
+require 'command_mapper/exceptions'
+require 'command_mapper/option_value'
+
+module CommandMapper
+  #
+  # Represents an option for a command.
+  #
+  class Option
+
+    # @return [String]
+    attr_reader :flag
+
+    # @return [Symbol]
+    attr_reader :name
+
+    # @return [OptionValue, nil]
+    attr_reader :value
+
+    #
+    # Initializes the option.
+    #
+    # @param [String] flag
+    #   The option's flag (ex: `-o` or `--output`).
+    #
+    # @param [Symbol, nil] name
+    #   The option's name.
+    #
+    # @param [Boolean] equals
+    #   Specifies whether the option's flag and value should be separated with a
+    #   `=` character.
+    #
+    # @param [Hash, nil] value
+    #   The option's value.
+    #
+    # @option value [Boolean] :required
+    #   Specifies whether the option requires a value or not.
+    #
+    # @option value [Types:Type, Hash, nil] :type
+    #   The explicit type for the option's value.
+    #
+    # @param [Boolean] repeats
+    #   Specifies whether the option can be given multiple times.
+    #
+    def initialize(flag, name: nil, equals: nil, value: nil, repeats: false)
+      @flag    = flag
+      @name    = name || self.class.infer_name_from_flag(flag)
+      @equals  = equals
+      @value   = case value
+                 when Hash then OptionValue.new(**value)
+                 when true then OptionValue.new
+                 end
+      @repeats = repeats
+    end
+
+    #
+    # Infers a method name from the given option flag.
+    #
+    # @param [String] flag
+    #   The given long or short option flag.
+    #
+    # @return [Symbol]
+    #   The inferred method method name.
+    #
+    # @raise [ArgumentError]
+    #   Could not infer the name from the given option flag or was not given a
+    #   valid option flag.
+    #
+    def self.infer_name_from_flag(flag)
+      if flag.start_with?('--')
+        name = flag[2..-1]
+      elsif flag.start_with?('-')
+        name = flag[1..-1]
+
+        if name.length < 2
+          raise(ArgumentError,"cannot infer a name from short option flag: #{flag.inspect}")
+        end
+      else
+        raise(ArgumentError,"not an option flag: #{flag}")
+      end
+
+      name.downcase.gsub(/[_-]+/,'_').to_sym
+    end
+
+    #
+    # Indicates whether the option accepts a value.
+    #
+    # @return [Boolean]
+    #
+    def accepts_value?
+      !@value.nil?
+    end
+
+    #
+    # Indicates whether the option flag and value should be separated with a
+    # `=` character.
+    #
+    # @return [Boolean]
+    #
+    def equals?
+      @equals
+    end
+
+    #
+    # Determines whether the option can be given multiple times.
+    #
+    # @return [Boolean]
+    #
+    def repeats?
+      @repeats
+    end
+
+    #
+    # Validates whether the given value is compatible with the option.
+    #
+    # @param [Array<Object>, Object] value
+    #
+    # @return [true, (false, String)]
+    #   Returns true if the value is valid, or `false` and a validation error
+    #   message if the value is not compatible.
+    #
+    def validate(value)
+      if accepts_value?
+        if repeats?
+          validate_repeating(value)
+        else
+          @value.validate(value)
+        end
+      else
+        validate_does_not_accept_value(value)
+      end
+    end
+
+    #
+    # Converts the given value into the command-line arguments for the option's
+    # flag and value.
+    #
+    # @param [Array] argv
+    #   The argv array.
+    #
+    # @param [Object] value
+    #   The value given to the option.
+    #
+    # @return [Array<String>]
+    #
+    # @raise [ArgumentError]
+    #   The given value was incompatible with the option.
+    #
+    def argv(argv=[],value)
+      valid, message = validate(value)
+
+      unless valid
+        raise(ValidationError,"option #{@name} was given an invalid value (#{value.inspect}): #{message}")
+      end
+
+      if accepts_value?
+        if repeats?
+          values = Array(value)
+
+          values.each do |element|
+            emit_option_flag_and_value(argv,element)
+          end
+        else
+          emit_option_flag_and_value(argv,value)
+        end
+      else
+        emit_option_flag_only(argv,value)
+      end
+
+      return argv
+    end
+
+    private
+
+    #
+    # Validates a value when the option can be repeated.
+    #
+    # @param [Array<Object>, Object] value
+    #
+    # @return [true, (false, String)]
+    #   Returns true if the value is valid, or `false` and a validation error
+    #   message if the value is not compatible.
+    #
+    def validate_repeating(value)
+      values = case value
+               when Array then value
+               else            [value]
+               end
+
+      if @value.required?
+        # option requires atleast one value
+        if values.empty?
+          return [false, "requires at least one value"]
+        end
+      end
+
+      values.each do |element|
+        valid, message = @value.validate(element)
+
+        unless valid
+          return [false, message]
+        end
+      end
+
+      return true
+    end
+
+    #
+    # Validates a value when the option does not accept a value.
+    #
+    # @param [Array<Object>, Object] value
+    #
+    # @return [true, (false, String)]
+    #   Returns true if the value is valid, or `false` and a validation error
+    #   message if the value is not compatible.
+    #
+    def validate_does_not_accept_value(value)
+      case value
+      when true, false, nil
+        return true
+      when Integer
+        if repeats?
+          return true
+        else
+          return [false, "only repeating options may accept Integers"]
+        end
+      else
+        return [false, "only accepts true, false, or nil"]
+      end
+    end
+
+    #
+    # Emits the option's flag.
+    #
+    # @param [Array<String>] argv
+    #   The argv array to append to.
+    #
+    # @param [true, false, nil] value
+    #   Indicates whether to emit the option's flag or not.
+    #
+    def emit_option_flag_only(argv,value)
+      case value
+      when true
+        argv << @flag
+      when Integer
+        if repeats?
+          value.times { argv << @flag }
+        end
+      end
+    end
+
+    #
+    # Emits the option's flag and value.
+    #
+    # @param [Array<String>] argv
+    #   The argv array to append to.
+    #
+    # @param [Object] value
+    #   The value for the option.
+    #
+    # @raise [VAlidationError]
+    #   The formatted value starts with a `-` character.
+    #
+    def emit_option_flag_and_value(argv,value)
+      if !@value.required? && value == true
+        argv << @flag
+      else
+        string = @value.format(value)
+
+        if string.start_with?('-')
+          raise(ValidationError,"option #{@name} formatted value (#{string.inspect}) cannot start with a '-'")
+        end
+
+        if equals?
+          argv << "#{@flag}=#{string}"
+        else
+          argv << @flag << string
+        end
+      end
+    end
+  end
+
+end

data/lib/command_mapper/option_value.rb

@@ -0,0 +1,21 @@
+require 'command_mapper/arg'
+
+module CommandMapper
+  #
+  # Represents the value for an option.
+  #
+  class OptionValue < Arg
+
+    #
+    # Formats a value using the options {#type}.
+    #
+    # @param [Object] value
+    #
+    # @return [String]
+    #
+    def format(value)
+      @type.format(value)
+    end
+
+  end
+end

data/lib/command_mapper/sudo.rb

@@ -0,0 +1,73 @@
+require 'command_mapper/command'
+require 'command_mapper/types/key_value_list'
+
+module CommandMapper
+  #
+  # Represents the `sudo` command.
+  #
+  # ## Sudo options:
+  #
+  # * `-A` - `sudo.ask_password`
+  # * `-b` - `sudo.background`
+  # * `-C` - `sudo.close_from`
+  # * `-E` - `sudo.preserve_env`
+  # * `-e` - `sudo.edit`
+  # * `-g` - `sudo.group`
+  # * `-H` - `sudo.home`
+  # * `-h` - `sudo.help`
+  # * `-i` - `sudo.simulate_initial_login`
+  # * `-k` - `sudo.kill`
+  # * `-K` - `sudo.sure_kill`
+  # * `-L` - `sudo.list_defaults`
+  # * `-l` - `sudo.list`
+  # * `-n` - `sudo.non_interactive`
+  # * `-P` - `sudo.preserve_group`
+  # * `-p` - `sudo.prompt`
+  # * `-r` - `sudo.role`
+  # * `-S` - `sudo.stdin`
+  # * `-s` - `sudo.shell`
+  # * `-t` - `sudo.type`
+  # * `-U` - `sudo.other_user`
+  # * `-u` - `sudo.user`
+  # * `-V` - `sudo.version`
+  # * `-v` - `sudo.validate`
+  #
+  # * `[command]` - `sudo.command`
+  #
+  class Sudo < Command
+
+    command "sudo" do
+      option "--askpass"
+      option "--background"
+      option "--bell"
+      option "--close-from", equals: true, value: true
+      option "--chdir", equals: true, value: true
+      option "--preserve-env", equals: true, value: true
+      option "--edit"
+      option "--group", equals: true, value: true
+      option "--set-home"
+      option "--help"
+      option "--host", equals: true, value: true
+      option "--login"
+      option "--remove-timestamp"
+      option "--reset-timestamp"
+      option "--list"
+      option "--non-interactive"
+      option "--preserve-groups"
+      option "--prompt", equals: true, value: true
+      option "--chroot", equals: true, value: true
+      option "--role", equals: true, value: true
+      option "--stdin"
+      option "--shell"
+      option "--type", equals: true, value: true
+      option "--command-timeout", equals: true, value: true
+      option "--other-user", equals: true, value: true
+      option "--user", equals: true, value: true
+      option "--version"
+      option "--validate"
+
+      argument :command, required: false, repeats: true
+    end
+
+  end
+end

data/lib/command_mapper/types/enum.rb

@@ -0,0 +1,35 @@
+require 'command_mapper/types/map'
+
+module CommandMapper
+  module Types
+    class Enum < Map
+
+      # @return [Array<Object>]
+      attr_reader :values
+
+      #
+      # Initializes the enum type.
+      #
+      # @param [Array<Object>] values
+      #   The values of the enum type.
+      #
+      def initialize(values)
+        @values = values
+
+        super(Hash[values.map { |value| [value, value.to_s] }])
+      end
+
+      #
+      # Creates a new enum.
+      #
+      # @param [Array<Object>] values
+      #
+      # @return [Enum]
+      #
+      def self.[](*values)
+        new(values)
+      end
+
+    end
+  end
+end

data/lib/command_mapper/types/hex.rb

@@ -0,0 +1,82 @@
+require 'command_mapper/types/num'
+
+module CommandMapper
+  module Types
+    #
+    # Represents a hexadecimal value.
+    #
+    class Hex < Num
+
+      #
+      # Initializes the hex value.
+      #
+      # @param [Boolean] leading_zero
+      #   Specifies whether the hex value will start with `0x` or not.
+      #
+      # @param [Hash{Symbol => Object}] kwargs
+      #   Additional keyword arguments for {Type#initialize}.
+      #
+      def initialize(leading_zero: false)
+        @leading_zero = leading_zero
+      end
+
+      #
+      # Indicates whether the hex value will start with `0x` or not.
+      #
+      # @return [Boolean]
+      #
+      def leading_zero?
+        @leading_zero
+      end
+
+      #
+      # Validates a value.
+      #
+      # @param [String, Integer, Object] value
+      #
+      # @return [true, (false, String)]
+      #
+      def validate(value)
+        case value
+        when String
+          unless value =~ /\A(?:0x)?[A-Fa-f0-9]+\z/
+            return [false, "not in hex format (#{value.inspect})"]
+          end
+
+          return true
+        else
+          super(value)
+        end
+      end
+
+      #
+      # Formats the value.
+      #
+      # @param [#to_i] value
+      #
+      # @return [String]
+      #
+      def format(value)
+        case value
+        when String
+          if leading_zero? && !value.start_with?('0x')
+            value = "0x#{value}"
+          elsif (!leading_zero? && value.start_with?('0x'))
+            value = value[2..]
+          end
+
+          value
+        else
+          value = value.to_i
+
+          if leading_zero?
+            "0x%x" % value
+          else
+            "%x" % value
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/command_mapper/types/input_dir.rb

@@ -0,0 +1,35 @@
+require 'command_mapper/types/input_path'
+
+module CommandMapper
+  module Types
+    #
+    # Represents a path to an existing directory.
+    #
+    class InputDir < InputPath
+
+      #
+      # Validates whether the directory exists.
+      #
+      # @param [Object] value
+      #
+      # @return [true, (false, String)]
+      #
+      def validate(value)
+        valid, message = super(value)
+
+        unless valid
+          return valid, message
+        end
+
+        unless value.empty?
+          unless File.directory?(value)
+            return [false, "directory does not exist (#{value.inspect})"]
+          end
+        end
+
+        return true
+      end
+
+    end
+  end
+end

data/lib/command_mapper/types/input_file.rb

@@ -0,0 +1,35 @@
+require 'command_mapper/types/input_path'
+
+module CommandMapper
+  module Types
+    #
+    # Represents a path to an existing file.
+    #
+    class InputFile < InputPath
+
+      #
+      # Validates the file exists.
+      #
+      # @param [Object] value
+      #
+      # @return [true, (false, String)]
+      #
+      def validate(value)
+        valid, message = super(value)
+
+        unless valid
+          return valid, message
+        end
+
+        unless value.empty?
+          unless File.file?(value)
+            return [false, "file does not exist (#{value.inspect})"]
+          end
+        end
+
+        return true
+      end
+
+    end
+  end
+end

data/lib/command_mapper/types/input_path.rb

@@ -0,0 +1,29 @@
+require 'command_mapper/types/type'
+
+module CommandMapper
+  module Types
+    #
+    # Represents a path to an existing file or a directory.
+    #
+    class InputPath < Type
+
+      #
+      # Validates whether the path exists or not.
+      #
+      # @param [Object] value
+      #
+      # @return [true, (false, String)]
+      #
+      def validate(value)
+        unless value.empty?
+          unless File.exists?(value)
+            return [false, "path does not exist (#{value.inspect})"]
+          end
+        end
+
+        return true
+      end
+
+    end
+  end
+end