tty-option 0.0.0 → 0.1.0

data/lib/tty/option/parameter/argument.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require_relative "../parameter"
+
+module TTY
+  module Option
+    class Parameter
+      class Argument < Parameter
+        # Required by default unless the arity allows any
+        #
+        # @api public
+        def required?
+          @settings.fetch(:required) { arity != -1 }
+        end
+      end
+    end # Parameter
+  end # Option
+end # TTY

data/lib/tty/option/parameter/environment.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module TTY
+  module Option
+    class Parameter
+      class Environment < Parameter
+        def default_name
+          key.to_s.tr("-", "_").upcase
+        end
+
+        # Compare this env var to another
+        #
+        # @api public
+        def <=>(other)
+          name <=> other.name
+        end
+      end
+    end # Parameter
+  end # Option
+end # TTY

data/lib/tty/option/parameter/keyword.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require_relative "../parameter"
+
+module TTY
+  module Option
+    class Parameter
+      class Keyword < Parameter
+        def required?
+          @settings.fetch(:required) { false }
+        end
+      end
+    end # Parameter
+  end # Option
+end # TTY

data/lib/tty/option/parameter/option.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+module TTY
+  module Option
+    class Parameter
+      class Option < Parameter
+        # Matches "-f string"
+        SHORT_ARGUMENT_REQUIRED_RE = /^-.(\s*?|\=)[^\[]+$/.freeze
+
+        # Matches "--foo string"
+        LONG_ARGUMENT_REQUIRED_RE = /^--\S+(\s+|\=)([^\[])+?$/.freeze
+
+        # Matches "-f [string]"
+        SHORT_ARGUMENT_OPTIONAL_RE = /^-.\s*\[\S+\]\s*$/.freeze
+
+        # Matches "--foo [string]"
+        LONG_ARGUMENT_OPTIONAL_RE = /^--\S+\s*\[\S+\]\s*$/.freeze
+
+        # Return long name if present, otherwise short name
+        #
+        # @api private
+        def default_name
+          [long_name, short_name].reject(&:empty?).first
+        end
+
+        def short(value = (not_set = true))
+          if not_set
+            @settings[:short]
+          else
+            @settings[:short] = value
+          end
+        end
+
+        def short?
+          @settings.key?(:short) && !@settings[:short].nil?
+        end
+
+        # Extract short flag name
+        #
+        # @api public
+        def short_name
+          short.to_s.sub(/^(-.).*$/, "\\1")
+        end
+
+        def long(value = (not_set = true))
+          if not_set
+            @settings.fetch(:long) { default_long }
+          else
+            @settings[:long] = value
+          end
+        end
+
+        def default_long
+          "--#{key.to_s.gsub("_", "-")}" unless short?
+        end
+
+        def long?
+          !long.nil?
+        end
+
+        # Extract long flag name
+        #
+        # @api public
+        def long_name
+          long.to_s.sub(/^(--.+?)(\s+|\=|\[).*$/, "\\1")
+        end
+
+        # Check if argument is required
+        #
+        # @return [Boolean]
+        #
+        # @api public
+        def argument_required?
+          !short.to_s.match(SHORT_ARGUMENT_REQUIRED_RE).nil? ||
+            !long.to_s.match(LONG_ARGUMENT_REQUIRED_RE).nil?
+        end
+
+        # Check if argument is optional
+        #
+        # @return [Boolean]
+        #
+        # @api public
+        def argument_optional?
+          !short.to_s.match(SHORT_ARGUMENT_OPTIONAL_RE).nil? ||
+            !long.to_s.match(LONG_ARGUMENT_OPTIONAL_RE).nil?
+        end
+
+        # Compare this option short and long names
+        #
+        # @api public
+        def <=>(other)
+          left = long? ? long_name : short_name
+          right = other.long? ? other.long_name : other.short_name
+          left <=> right
+        end
+      end # Option
+    end # Parameter
+  end # Option
+end # TTY

data/lib/tty/option/parameters.rb

@@ -0,0 +1,157 @@
+# frozen_string_literal: true
+
+require "set"
+
+module TTY
+  module Option
+    # A collection to hold all parameters
+    class Parameters
+      include Enumerable
+
+      # Define a query for parameter types
+      #
+      # @api private
+      def self.define_query(name)
+        define_method(:"#{name}?") do
+          !self.public_send(name).empty?
+        end
+      end
+
+      # A list of arguments
+      attr_reader :arguments
+
+      # A list of keywords
+      attr_reader :keywords
+
+      # A list of environments
+      attr_reader :environments
+
+      # A list of options
+      attr_reader :options
+
+      # A list of all parameters
+      attr_reader :list
+
+      define_query :arguments
+      define_query :keywords
+      define_query :options
+      define_query :environments
+
+      # A parameters list
+      #
+      # @api private
+      def initialize
+        @arguments = []
+        @environments = []
+        @keywords = []
+        @options = []
+        @list = []
+
+        @registered_keys = Set.new
+        @registered_shorts = Set.new
+        @registered_longs = Set.new
+      end
+
+      # Add parameter
+      #
+      # @param [TTY::Option::Parameter] parameter
+      #
+      # @api public
+      def <<(parameter)
+        check_key_uniqueness!(parameter.key)
+
+        if parameter.to_sym == :option
+          check_short_option_uniqueness!(parameter.short_name)
+          check_long_option_uniqueness!(parameter.long_name)
+        end
+
+        @list << parameter
+        arr = instance_variable_get("@#{parameter.to_sym}s")
+        arr.send :<<, parameter
+        self
+      end
+      alias add <<
+
+      # Delete a parameter from the list
+      #
+      # @example
+      #   delete(:foo, :bar, :baz)
+      #
+      # @param [Array<Symbol>] keys
+      #   the keys to delete
+      #
+      # @api public
+      def delete(*keys)
+        deleted = []
+        @list.delete_if { |p| keys.include?(p.key) && (deleted << p) }
+        deleted.each do |param|
+          params_list = instance_variable_get("@#{param.to_sym}s")
+          params_list.delete(param)
+        end
+        @registered_keys.subtract(keys)
+        @registered_shorts.replace(@options.map(&:short))
+        @registered_longs.replace(@options.map(&:long))
+        deleted
+      end
+
+      # Enumerate all parameters
+      #
+      # @api public
+      def each(&block)
+        if block_given?
+          @list.each(&block)
+        else
+          to_enum(:each)
+        end
+      end
+
+      # Make a deep copy of the list of parameters
+      #
+      # @api public
+      def dup
+        super.tap do |params|
+          params.instance_variables.each do |var|
+            dupped = DeepDup.deep_dup(params.instance_variable_get(var))
+            params.instance_variable_set(var, dupped)
+          end
+        end
+      end
+
+      private
+
+      # @api private
+      def check_key_uniqueness!(key)
+        if @registered_keys.include?(key)
+          raise ParameterConflict,
+                "already registered parameter #{key.inspect}"
+        else
+          @registered_keys << key
+        end
+      end
+
+      # @api private
+      def check_short_option_uniqueness!(short_name)
+        return if short_name.empty?
+
+        if @registered_shorts.include?(short_name)
+          raise ParameterConflict,
+                "already registered short option #{short_name}"
+        else
+          @registered_shorts << short_name
+        end
+      end
+
+      # @api private
+      def check_long_option_uniqueness!(long_name)
+        return if long_name.empty?
+
+        if @registered_longs.include?(long_name)
+          raise ParameterConflict,
+                "already registered long option #{long_name}"
+        else
+          @registered_longs << long_name
+        end
+      end
+    end # Parameters
+  end # Option
+end # TTY

data/lib/tty/option/params.rb

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+require "forwardable"
+
+require_relative "aggregate_errors"
+
+module TTY
+  module Option
+    class Params
+      extend Forwardable
+
+      def self.create(parameters = {}, remaining = [], errors = [])
+        new(parameters, remaining: remaining, errors: errors)
+      end
+
+      def_delegators :@parameters,
+                     :keys, :key?, :has_key?, :member?, :value?, :has_value?,
+                     :empty?, :include?, :each_key, :each_value
+
+      # The remaining unparsed arguments
+      #
+      # @api public
+      attr_reader :remaining
+
+      # The parameter parsing errors
+      #
+      # @api public
+      attr_reader :errors
+
+      # Create Params
+      #
+      # @api private
+      def initialize(parameters, remaining: [], errors: [])
+        @parameters = parameters
+        @parameters.default_proc = ->(hash, key) do
+          return hash[key] if hash.key?(key)
+
+          case key
+          when Symbol
+            hash[key.to_s] if hash.key?(key.to_s)
+          when String
+            hash[key.to_sym] if hash.key?(key.to_sym)
+          end
+        end
+        @remaining = remaining
+        @errors = AggregateErrors.new(errors)
+      end
+
+      # Access a given value for a key
+      #
+      # @api public
+      def [](key)
+        @parameters[key]
+      end
+
+      # Assign value to a key
+      #
+      # @api public
+      def []=(key, value)
+        @parameters[key] = value
+      end
+
+      # Access a given value for a key
+      #
+      # @api public
+      def fetch(key, *args, &block)
+        value = self[key]
+        return value unless value.nil?
+
+        @parameters.fetch(key, *args, &block)
+      end
+
+      def merge(other_params)
+        @parameters.merge(other_params)
+      end
+
+      def merge!(other_params)
+        @parameters.merge!(other_params)
+      end
+
+      # Check if params have any errors
+      #
+      # @api public
+      def valid?
+        @errors.empty?
+      end
+
+      def ==(other)
+        return false unless other.kind_of?(TTY::Option::Params)
+
+        @parameters == other.to_h
+      end
+      alias eql? ==
+
+      def hash
+        @parameters.hash
+      end
+
+      def to_h
+        @parameters.to_h
+      end
+
+      # String representation of this params
+      #
+      # @return [String]
+      #
+      # @api public
+      def inspect
+        "#<#{self.class}#{to_h.inspect}>"
+      end
+
+      # String representation of the parameters
+      #
+      # @return [String]
+      #
+      # @api public
+      def to_s
+        to_h.to_s
+      end
+    end # Params
+  end # Option
+end # TTY

data/lib/tty/option/parser.rb

@@ -1,8 +1,62 @@
 # frozen_string_literal: true
 
+require_relative "params"
+require_relative "parser/arguments"
+require_relative "parser/environments"
+require_relative "parser/keywords"
+require_relative "parser/options"
+require_relative "pipeline"
+
 module TTY
   module Option
     class Parser
-    end
-  end
-end
+      PARAMETER_PARSERS = {
+        options: TTY::Option::Parser::Options,
+        keywords: TTY::Option::Parser::Keywords,
+        arguments: TTY::Option::Parser::Arguments,
+        environments: TTY::Option::Parser::Environments
+      }
+
+      ARGUMENT_SEPARATOR = /^-{2,}$/.freeze
+
+      attr_reader :parameters
+
+      attr_reader :config
+
+      def initialize(parameters, **config)
+        @parameters = parameters
+        @config = config
+      end
+
+      def parse(argv, env)
+        argv = argv.dup
+        params = {}
+        errors = []
+        ignored = []
+
+        # split argv into processable args and leftovers
+        stop_index = argv.index { |arg| arg.match(ARGUMENT_SEPARATOR) }
+
+        if stop_index
+          ignored = argv.slice!(stop_index..-1)
+          ignored.shift
+        end
+
+        PARAMETER_PARSERS.each do |name, parser_type|
+          parser = parser_type.new(parameters.send(name), **config)
+          if name == :environments
+            parsed, argv, err = parser.parse(argv, env)
+          else
+            parsed, argv, err = parser.parse(argv)
+          end
+          params.merge!(parsed)
+          errors.concat(err)
+        end
+
+        argv += ignored unless ignored.empty?
+
+        [params, argv, errors]
+      end
+    end # Parser
+  end # Option
+end # TTY