tty-option 0.0.0 → 0.1.0

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

@@ -0,0 +1,166 @@
+# frozen_string_literal: true
+
+require_relative "../error_aggregator"
+require_relative "../pipeline"
+require_relative "param_types"
+require_relative "required_check"
+
+module TTY
+  module Option
+    class Parser
+      class Arguments
+        include ParamTypes
+
+        # Create a command line arguments parser
+        #
+        # @param [Array<Argument>] arguments
+        #   the list of arguments
+        # @param [Hash] config
+        #   the configuration settings
+        #
+        # @api public
+        def initialize(arguments, check_invalid_params: true,
+                       raise_on_parse_error: false)
+          @arguments = arguments
+          @error_aggregator =
+            ErrorAggregator.new(raise_on_parse_error: raise_on_parse_error)
+          @required_check = RequiredCheck.new(@error_aggregator)
+          @pipeline = Pipeline.new(@error_aggregator)
+          @parsed = {}
+          @remaining = []
+
+          @defaults = {}
+          @arguments.each do |arg|
+            if arg.default?
+              case arg.default
+              when Proc
+                @defaults[arg.key] = arg.default.()
+              else
+                @defaults[arg.key] = arg.default
+              end
+            elsif arg.required?
+              @required_check << arg
+            end
+          end
+        end
+
+        # Read positional arguments from the command line
+        #
+        # @param [Array<String>] argv
+        #
+        # @return [Array<Hash, Array, Hash>]
+        #   a list of parsed and unparsed arguments and errors
+        #
+        # @api private
+        def parse(argv)
+          @argv = argv.dup
+
+          @arguments.each do |arg|
+            values = next_argument(arg)
+            @required_check.delete(arg) unless values.empty?
+
+            assign_argument(arg, values)
+          end
+
+          while (val = @argv.shift)
+            @remaining << val
+          end
+
+          @required_check.()
+
+          [@parsed, @remaining, @error_aggregator.errors]
+        end
+
+        private
+
+        # @api private
+        def next_argument(arg)
+          if arg.arity >= 0
+            process_exact_arity(arg)
+          else
+            process_infinite_arity(arg)
+          end
+        end
+
+        def process_exact_arity(arg)
+          values = []
+          arity = arg.arity
+
+          while arity > 0
+            break if @argv.empty?
+            value = @argv.shift
+            if argument?(value)
+              values << value
+              arity -= 1
+            else
+              @remaining << value
+            end
+          end
+
+          if 0 < values.size && values.size < arg.arity &&
+              Array(@defaults[arg.key]).size < arg.arity
+            @error_aggregator.(InvalidArity.new(arg, values.size))
+          end
+
+          values
+        end
+
+        def process_infinite_arity(arg)
+          values = []
+          arity = arg.arity.abs - 1
+
+          arity.times do |i|
+            break if @argv.empty?
+            value = @argv.shift
+            if argument?(value)
+              values << value
+            else
+              @remaining << value
+            end
+          end
+
+          # consume remaining
+          while (value = @argv.shift)
+            if argument?(value)
+              values << value
+            else
+              @remaining << value
+            end
+          end
+
+          if values.size < arity && Array(@defaults[arg.key]).size < arity
+            @error_aggregator.(InvalidArity.new(arg, values.size))
+          end
+
+          values
+        end
+
+        # Assign argument to the parsed
+        #
+        # @param [Argument] arg
+        # @param [Array] values
+        #
+        # @api private
+        def assign_argument(arg, values)
+          val = case values.size
+                when 0
+                  if arg.default?
+                    case arg.default
+                    when Proc
+                      @defaults[arg.key]
+                    else
+                      @defaults[arg.key]
+                    end
+                  end
+                when 1
+                  values.first
+                else
+                  values
+                end
+
+          @parsed[arg.key] = @pipeline.(arg, val)
+        end
+      end # Arguments
+    end # Parser
+  end # Option
+end # TTY

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

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module TTY
+  module Option
+    class Parser
+      class ArityCheck
+        def initialize(error_aggregator)
+          @multiplies = []
+          @error_aggregator = error_aggregator
+        end
+
+        def add(param)
+          @multiplies << param
+        end
+        alias :<< :add
+
+        # Check if parameter matches arity
+        #
+        # @raise [InvalidArity]
+        #
+        # @api private
+        def call(arities)
+          @multiplies.each do |param|
+            arity = arities[param.key]
+
+            if arity < param.min_arity
+              @error_aggregator.(InvalidArity.new(param, arity))
+            end
+          end
+        end
+      end # ArityCheck
+    end # Parser
+  end # Option
+end # TTY

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

@@ -0,0 +1,169 @@
+# 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 Environments
+        include ParamTypes
+
+        ENV_VAR_RE = /([\p{Lu}_\-\d]+)=([^=]+)/.freeze
+
+        # Create a command line env variables parser
+        #
+        # @param [Array<Environment>] environments
+        #   the list of environment variables
+        # @param [Hash] config
+        #   the configuration settings
+        #
+        # @api public
+        def initialize(environments, check_invalid_params: true,
+                       raise_on_parse_error: false)
+          @environments = environments
+          @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 = []
+          @names = {}
+          @arities = Hash.new(0)
+
+          @environments.each do |env_arg|
+            @names[env_arg.name] = env_arg
+            @arity_check << env_arg if env_arg.multiple?
+
+            if env_arg.default?
+              case env_arg.default
+              when Proc
+                assign_envvar(env_arg, env_arg.default.())
+              else
+                assign_envvar(env_arg, env_arg.default)
+              end
+            elsif env_arg.required?
+              @required_check << env_arg
+            end
+          end
+        end
+
+        # Read environment variable(s) from command line or ENV hash
+        #
+        # @param [Array<String>] argv
+        # @param [Hash<String,Object>] env
+        #
+        # @api public
+        def parse(argv, env)
+          @argv = argv.dup
+          @env = env
+
+          loop do
+            env_var, value = next_envvar
+            if !env_var.nil?
+              @required_check.delete(env_var)
+              @arities[env_var.key] += 1
+
+              if block_given?
+                yield(env_var, value)
+              end
+              assign_envvar(env_var, value)
+            end
+            break if @argv.empty?
+          end
+
+          @environments.each do |env_arg|
+            if (value = env[env_arg.name])
+              @required_check.delete(env_arg)
+              @arities[env_arg.key] += 1
+              assign_envvar(env_arg, value)
+            end
+          end
+
+          @arity_check.(@arities)
+          @required_check.()
+
+          [@parsed, @remaining, @error_aggregator.errors]
+        end
+
+        private
+
+        def next_envvar
+          env_var, value = nil, nil
+
+          while !@argv.empty? && !env_var?(@argv.first)
+            @remaining << @argv.shift
+          end
+
+          if @argv.empty?
+            return
+          else
+            environment = @argv.shift
+          end
+
+          if (match = environment.match(ENV_VAR_RE))
+            _, name, val = *match.to_a
+
+            if (env_var = @names[name])
+              if env_var.multi_argument? &&
+                  !(consumed = consume_arguments).empty?
+                value = [val] + consumed
+              else
+                value = val
+              end
+            elsif @check_invalid_params
+              @error_aggregator.(InvalidParameter.new("invalid environment #{match}"))
+            else
+              @remaining << match.to_s
+            end
+          end
+
+          [env_var, value]
+        end
+
+        # Consume multi argument
+        #
+        # @api private
+        def consume_arguments(values: [])
+          while (value = @argv.first) &&
+            !option?(value) && !keyword?(value) && !env_var?(value)
+
+            val = @argv.shift
+            parts = val.include?("&") ? val.split(/&/) : [val]
+            parts.each { |part| values << part }
+          end
+
+          values
+        end
+
+        # @api private
+        def assign_envvar(env_arg, val)
+          value = @pipeline.(env_arg, val)
+
+          if env_arg.multiple?
+            allowed = env_arg.arity < 0 || @arities[env_arg.key] <= env_arg.arity
+            if allowed
+              case value
+              when Hash
+                (@parsed[env_arg.key] ||=  {}).merge!(value)
+              else
+                Array(value).each do |v|
+                  (@parsed[env_arg.key] ||=  []) << v
+                end
+              end
+            else
+              @remaining << "#{env_arg.name}=#{value}"
+            end
+          else
+            @parsed[env_arg.key] = value
+          end
+        end
+      end # Environments
+    end # Parser
+  end # Option
+end # TTY

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

@@ -0,0 +1,158 @@
+# 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 Keywords
+        include ParamTypes
+
+        KEYWORD_ARG_RE = /([^=-].*?)=([^=]+)/.freeze
+
+        # Create a command line keywords parser
+        #
+        # @param [Array<Keyword>] keywords
+        #   the list of keywords
+        # @param [Hash] config
+        #   the configuration settings
+        #
+        # @api public
+        def initialize(keywords, check_invalid_params: true,
+                       raise_on_parse_error: false)
+          @keywords = keywords
+          @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 = []
+          @names = {}
+          @arities = Hash.new(0)
+
+          @keywords.each do |kwarg|
+            @names[kwarg.name] = kwarg
+            @arity_check << kwarg if kwarg.multiple?
+
+            if kwarg.default?
+              case kwarg.default
+              when Proc
+                assign_keyword(kwarg, kwarg.default.())
+              else
+                assign_keyword(kwarg, kwarg.default)
+              end
+            elsif kwarg.required?
+              @required_check << kwarg
+            end
+          end
+        end
+
+        # Read keyword arguments from the command line
+        #
+        # @api public
+        def parse(argv)
+          @argv = argv.dup
+
+          loop do
+            kwarg, value = next_keyword
+            if !kwarg.nil?
+              @required_check.delete(kwarg)
+              @arities[kwarg.key] += 1
+
+              if block_given?
+                yield(kwarg, value)
+              end
+              assign_keyword(kwarg, value)
+            end
+            break if @argv.empty?
+          end
+
+          @arity_check.(@arities)
+          @required_check.()
+
+          [@parsed, @remaining, @error_aggregator.errors]
+        end
+
+        private
+
+        # Get next keyword
+        #
+        # @api private
+        def next_keyword
+          kwarg, value = nil, nil
+
+          while !@argv.empty? && !keyword?(@argv.first)
+            @remaining << @argv.shift
+          end
+
+          if @argv.empty?
+            return
+          else
+            keyword = @argv.shift
+          end
+
+          if (match = keyword.match(KEYWORD_ARG_RE))
+            _, name, val = *match.to_a
+
+            if (kwarg = @names[name])
+              if kwarg.multi_argument? &&
+                 !(consumed = consume_arguments).empty?
+                value = [val] + consumed
+              else
+                value = val
+              end
+            elsif @check_invalid_params
+              @error_aggregator.(InvalidParameter.new("invalid keyword #{match}"))
+            else
+              @remaining << match.to_s
+            end
+          end
+
+          [kwarg, value]
+        end
+
+        # Consume multi argument
+        #
+        # @api private
+        def consume_arguments(values: [])
+          while (value = @argv.first) && !option?(value) && !keyword?(value)
+            val = @argv.shift
+            parts = val.include?("&") ? val.split(/&/) : [val]
+            parts.each { |part| values << part }
+          end
+
+          values
+        end
+
+        # @api private
+        def assign_keyword(kwarg, val)
+          value = @pipeline.(kwarg, val)
+
+          if kwarg.multiple?
+            allowed = kwarg.arity < 0 || @arities[kwarg.key] <= kwarg.arity
+            if allowed
+              case value
+              when Hash
+                (@parsed[kwarg.key] ||= {}).merge!(value)
+              else
+                Array(value).each do |v|
+                  (@parsed[kwarg.key] ||=  []) << v
+                end
+              end
+            else
+              @remaining << "#{kwarg.name}=#{value}"
+            end
+          else
+            @parsed[kwarg.key] = value
+          end
+        end
+      end # Keywords
+    end # Parser
+  end # Option
+end # TTY