tty-option 0.0.0 → 0.1.0

data/lib/tty/option/parser/options.rb

@@ -0,0 +1,273 @@
+# frozen_string_literal: true
+
+require_relative "arity_check"
+require_relative "param_types"
+require_relative "required_check"
+require_relative "../error_aggregator"
+require_relative "../pipeline"
+
+module TTY
+  module Option
+    class Parser
+      class Options
+        include ParamTypes
+
+        LONG_OPTION_RE = /^(--[^=]+)(\s+|=)?(.*)?$/.freeze
+
+        SHORT_OPTION_RE = /^(-.)(.*)$/.freeze
+
+        # Create a command line env variables parser
+        #
+        # @param [Array<Option>] options
+        #   the list of options
+        # @param [Hash] config
+        #   the configuration settings
+        #
+        # @api public
+        def initialize(options, check_invalid_params: true,
+                       raise_on_parse_error: false)
+          @options = options
+          @check_invalid_params = check_invalid_params
+          @error_aggregator =
+            ErrorAggregator.new(raise_on_parse_error: raise_on_parse_error)
+          @required_check = RequiredCheck.new(@error_aggregator)
+          @arity_check = ArityCheck.new(@error_aggregator)
+          @pipeline = Pipeline.new(@error_aggregator)
+          @parsed = {}
+          @remaining = []
+          @shorts = {}
+          @longs = {}
+          @arities = Hash.new(0)
+
+          setup_opts
+        end
+
+        # Configure list of returned options
+        #
+        # @api private
+        def setup_opts
+          @options.each do |opt|
+            @shorts[opt.short_name] = opt
+            @longs[opt.long_name] = opt
+            @arity_check << opt if opt.multiple?
+
+            if opt.default?
+              case opt.default
+              when Proc
+                assign_option(opt, opt.default.())
+              else
+                assign_option(opt, opt.default)
+              end
+            elsif !(opt.argument_optional? || opt.argument_required?)
+              assign_option(opt, false)
+            elsif opt.required?
+              @required_check << opt
+            end
+          end
+        end
+
+        # Read option(s) from command line
+        #
+        # @param [Array<String>] argv
+        #
+        # @api public
+        def parse(argv)
+          @argv = argv.dup
+
+          loop do
+            opt, value = next_option
+            if !opt.nil?
+              @required_check.delete(opt)
+              @arities[opt.key] += 1
+
+              if block_given?
+                yield(opt, value)
+              else
+                assign_option(opt, value)
+              end
+            end
+            break if @argv.empty?
+          end
+
+          @arity_check.(@arities)
+          @required_check.()
+
+          [@parsed, @remaining, @error_aggregator.errors]
+        end
+
+        private
+
+        # Get next option
+        #
+        # @api private
+        def next_option
+          opt, value = nil, nil
+
+          while !@argv.empty? && !option?(@argv.first)
+            @remaining << @argv.shift
+          end
+
+          return if @argv.empty?
+
+          argument = @argv.shift
+
+          if (matched = argument.match(LONG_OPTION_RE))
+            long, sep, rest = matched[1..-1]
+            opt, value = *process_double_option(long, sep, rest)
+          elsif (matched = argument.match(SHORT_OPTION_RE))
+            short, other_singles = *matched[1..-1]
+            opt, value = *process_single_option(short, other_singles)
+          end
+
+          [opt, value]
+        end
+
+        # Process a double option
+        #
+        # @return [Array<Option, Object>]
+        #   a list of option and its value
+        #
+        # @api private
+        def process_double_option(long, sep, rest)
+          opt, value = nil, nil
+
+          if (opt = @longs[long])
+            if opt.argument_required?
+              if !rest.empty? || sep.to_s.include?("=")
+                value = rest
+                if opt.multi_argument? &&
+                   !(consumed = consume_arguments).empty?
+                  value = [rest] + consumed
+                end
+              elsif !@argv.empty?
+                value = opt.multi_argument? ? consume_arguments : @argv.shift
+              else
+                @error_aggregator.(MissingArgument.new(opt))
+              end
+            elsif opt.argument_optional?
+              if !rest.empty?
+                value = rest
+                if opt.multi_argument? &&
+                   !(consumed = consume_arguments).empty?
+                  value = [rest] + consumed
+                end
+              elsif !@argv.empty?
+                value = opt.multi_argument? ? consume_arguments : @argv.shift
+              end
+            else # boolean flag
+              value = true
+            end
+          else
+            # option stuck together with an argument or abbreviated
+            matching_options = 0
+            @longs.each_key do |key|
+              if !key.to_s.empty? &&
+                 (key.to_s.start_with?(long) || long.to_s.start_with?(key))
+                opt = @longs[key]
+                matching_options += 1
+              end
+            end
+
+            if matching_options.zero?
+              if @check_invalid_params
+                @error_aggregator.(InvalidParameter.new("invalid option '#{long}'"))
+              else
+                @remaining << long
+              end
+            elsif matching_options == 1
+              value = long[opt.long_name.size..-1]
+            else
+              @error_aggregator.(AmbiguousOption.new("option '#{long}' is ambiguous"))
+            end
+          end
+
+          [opt, value]
+        end
+
+        # Process a single option
+        #
+        # @return [Array<Option, Object>]
+        #   a list of option and its value
+        #
+        # @api private
+        def process_single_option(short, other_singles)
+          opt, value = nil, nil
+
+          if (opt = @shorts[short])
+            if opt.argument_required?
+              if !other_singles.empty?
+                value = other_singles
+                if opt.multi_argument? &&
+                   !(consumed = consume_arguments).empty?
+                  value = [other_singles] + consumed
+                end
+              elsif !@argv.empty?
+                value = opt.multi_argument? ? consume_arguments : @argv.shift
+              else
+                @error_aggregator.(MissingArgument.new(opt))
+              end
+            elsif opt.argument_optional?
+              if !other_singles.empty?
+                value = other_singles
+                if opt.multi_argument? &&
+                   !(consumed = consume_arguments).empty?
+                  value = [other_singles] + consumed
+                end
+              elsif !@argv.empty?
+                value = opt.multi_argument? ? consume_arguments : @argv.shift
+              end
+            else # boolean flag
+              if !other_singles.empty?
+                @argv.unshift("-#{other_singles}")
+              end
+              value = true
+            end
+          elsif @check_invalid_params
+            @error_aggregator.(InvalidParameter.new("invalid option '#{short}'"))
+          else
+            @remaining << short
+          end
+
+          [opt, value]
+        end
+
+        # Consume multi argument
+        #
+        # @api private
+        def consume_arguments(values: [])
+          while (value = @argv.first) && !option?(value)
+            val = @argv.shift
+            parts = val.include?("&") ? val.split(/&/) : [val]
+            parts.each { |part| values << part }
+          end
+
+          values.size == 1 ? values.first : values
+        end
+
+        # @api private
+        def assign_option(opt, val)
+          value = @pipeline.(opt, val)
+
+          if opt.multiple?
+            allowed = opt.arity < 0 || @arities[opt.key] <= opt.arity
+            if allowed
+              case value
+              when Hash
+                (@parsed[opt.key] ||= {}).merge!(value)
+              else
+                Array(value).each do |v|
+                  (@parsed[opt.key] ||= []) << v
+                end
+              end
+            else
+              @remaining << opt.short_name
+              @remaining << value
+            end
+          else
+            @parsed[opt.key] = value
+          end
+        end
+      end # Options
+    end # Parser
+  end # Option
+end # TTY

data/lib/tty/option/parser/param_types.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module TTY
+  module Option
+    class Parser
+      module ParamTypes
+        # Check if value looks like an argument
+        #
+        # @param [String] value
+        #
+        # @return [Boolean]
+        #
+        # @api public
+        def argument?(value)
+          !value.match(/^[^-][^=]*\z/).nil?
+        end
+
+        # Check if value is an environment variable
+        #
+        # @param [String] value
+        #
+        # @return [Boolean]
+        #
+        # @api public
+        def env_var?(value)
+          !value.match(/^[\p{Lu}_\-\d]+=/).nil?
+        end
+
+        # Check to see if value is a keyword
+        #
+        # @return [Boolean]
+        #
+        # @api public
+        def keyword?(value)
+          !value.to_s.match(/^([^-=][\p{Ll}_\-\d]*)=([^=]+)/).nil?
+        end
+
+        # Check if value looks like an option
+        #
+        # @param [String] value
+        #
+        # @return [Boolean]
+        #
+        # @api public
+        def option?(value)
+          !value.match(/^-./).nil?
+        end
+      end # ParamTypes
+    end # Parser
+  end # Option
+end # TTY

data/lib/tty/option/parser/required_check.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module TTY
+  module Option
+    class Parser
+      class RequiredCheck
+        def initialize(error_aggregator)
+          @required = []
+          @error_aggregator = error_aggregator
+        end
+
+        def add(param)
+          @required << param
+        end
+        alias :<< :add
+
+        def delete(param)
+          @required.delete(param)
+        end
+
+        # Check if required options are provided
+        #
+        # @raise [MissingParameter]
+        #
+        # @api public
+        def call
+          return if @required.empty?
+
+          @required.each do |param|
+            @error_aggregator.(MissingParameter.new(param))
+          end
+        end
+      end # RequiredCheck
+    end # Parser
+  end # Option
+end # TTY

data/lib/tty/option/pipeline.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require_relative "param_conversion"
+require_relative "param_permitted"
+require_relative "param_validation"
+
+module TTY
+  module Option
+    class Pipeline
+      PROCESSORS = [
+        ParamConversion,
+        ParamPermitted,
+        ParamValidation
+      ]
+
+      # Create a param processing pipeline
+      #
+      # @api private
+      def initialize(error_aggregator)
+        @error_aggregator = error_aggregator
+      end
+
+      # Process param value through conditions
+      #
+      # @api public
+      def call(param, value)
+        result = Result.success(value)
+        PROCESSORS.each do |processor|
+          result = processor[param, result.value]
+          if result.failure?
+            Array(result.error).each { |err| @error_aggregator.(err) }
+          end
+        end
+        result.value
+      end
+    end # Pipeline
+  end # Option
+end # TTY

data/lib/tty/option/result.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module TTY
+  module Option
+    # A monad that respresents success and failure conditions
+    class Result
+      # Wrap a value in a success monad
+      #
+      # @api public
+      def self.success(value)
+        Success.new(value)
+      end
+
+      # Wrap a value in a failure monad
+      #
+      # @api public
+      def self.failure(value)
+        Failure.new(value)
+      end
+
+      attr_reader :value
+
+      attr_reader :error
+
+      def success?
+        is_a?(Success)
+      end
+
+      def failure?
+        is_a?(Failure)
+      end
+
+      class Success < Result
+        def initialize(value)
+          @value = value
+        end
+      end
+
+      class Failure < Result
+        def initialize(error)
+          @error = error
+        end
+      end
+    end
+  end
+end