tdiary 5.4.0 → 5.5.0.beta1

data/vendor/bundle/ruby/3.4.0/gems/thor-1.5.0/lib/thor/parser/option.rb

@@ -0,0 +1,178 @@
+class Thor
+  class Option < Argument #:nodoc:
+    attr_reader :aliases, :group, :lazy_default, :hide, :repeatable
+
+    VALID_TYPES = [:boolean, :numeric, :hash, :array, :string]
+
+    def initialize(name, options = {})
+      @check_default_type = options[:check_default_type]
+      options[:required] = false unless options.key?(:required)
+      @repeatable     = options.fetch(:repeatable, false)
+      super
+      @lazy_default   = options[:lazy_default]
+      @group          = options[:group].to_s.capitalize if options[:group]
+      @aliases        = normalize_aliases(options[:aliases])
+      @hide           = options[:hide]
+    end
+
+    # This parse quick options given as method_options. It makes several
+    # assumptions, but you can be more specific using the option method.
+    #
+    #   parse :foo => "bar"
+    #   #=> Option foo with default value bar
+    #
+    #   parse [:foo, :baz] => "bar"
+    #   #=> Option foo with default value bar and alias :baz
+    #
+    #   parse :foo => :required
+    #   #=> Required option foo without default value
+    #
+    #   parse :foo => 2
+    #   #=> Option foo with default value 2 and type numeric
+    #
+    #   parse :foo => :numeric
+    #   #=> Option foo without default value and type numeric
+    #
+    #   parse :foo => true
+    #   #=> Option foo with default value true and type boolean
+    #
+    # The valid types are :boolean, :numeric, :hash, :array and :string. If none
+    # is given a default type is assumed. This default type accepts arguments as
+    # string (--foo=value) or booleans (just --foo).
+    #
+    # By default all options are optional, unless :required is given.
+    #
+    def self.parse(key, value)
+      if key.is_a?(Array)
+        name, *aliases = key
+      else
+        name = key
+        aliases = []
+      end
+
+      name    = name.to_s
+      default = value
+
+      type = case value
+      when Symbol
+        default = nil
+        if VALID_TYPES.include?(value)
+          value
+        elsif required = (value == :required) # rubocop:disable Lint/AssignmentInCondition
+          :string
+        end
+      when TrueClass, FalseClass
+        :boolean
+      when Numeric
+        :numeric
+      when Hash, Array, String
+        value.class.name.downcase.to_sym
+      end
+
+      new(name.to_s, required: required, type: type, default: default, aliases: aliases)
+    end
+
+    def switch_name
+      @switch_name ||= dasherized? ? name : dasherize(name)
+    end
+
+    def human_name
+      @human_name ||= dasherized? ? undasherize(name) : name
+    end
+
+    def usage(padding = 0)
+      sample = if banner && !banner.to_s.empty?
+        "#{switch_name}=#{banner}".dup
+      else
+        switch_name
+      end
+
+      sample = "[#{sample}]".dup unless required?
+
+      if boolean? && name != "force" && !name.match(/\A(no|skip)[\-_]/)
+        sample << ", [#{dasherize('no-' + human_name)}], [#{dasherize('skip-' + human_name)}]"
+      end
+
+      aliases_for_usage.ljust(padding) + sample
+    end
+
+    def aliases_for_usage
+      if aliases.empty?
+        ""
+      else
+        "#{aliases.join(', ')}, "
+      end
+    end
+
+    def show_default?
+      case default
+      when TrueClass, FalseClass
+        true
+      else
+        super
+      end
+    end
+
+    VALID_TYPES.each do |type|
+      class_eval <<-RUBY, __FILE__, __LINE__ + 1
+        def #{type}?
+          self.type == #{type.inspect}
+        end
+      RUBY
+    end
+
+  protected
+
+    def validate!
+      raise ArgumentError, "An option cannot be boolean and required." if boolean? && required?
+      validate_default_type!
+    end
+
+    def validate_default_type!
+      default_type = case @default
+      when nil
+        return
+      when TrueClass, FalseClass
+        required? ? :string : :boolean
+      when Numeric
+        :numeric
+      when Symbol
+        :string
+      when Hash, Array, String
+        @default.class.name.downcase.to_sym
+      end
+
+      expected_type = (@repeatable && @type != :hash) ? :array : @type
+
+      if default_type != expected_type
+        err = "Expected #{expected_type} default value for '#{switch_name}'; got #{@default.inspect} (#{default_type})"
+
+        if @check_default_type
+          raise ArgumentError, err
+        elsif @check_default_type == nil
+          Thor.deprecation_warning "#{err}.\n" +
+            "This will be rejected in the future unless you explicitly pass the options `check_default_type: false`" +
+            " or call `allow_incompatible_default_type!` in your code"
+        end
+      end
+    end
+
+    def dasherized?
+      name.index("-") == 0
+    end
+
+    def undasherize(str)
+      str.sub(/^-{1,2}/, "")
+    end
+
+    def dasherize(str)
+      (str.length > 1 ? "--" : "-") + str.tr("_", "-")
+    end
+
+  private
+
+    def normalize_aliases(aliases)
+      Array(aliases).map { |short| short.to_s.sub(/^(?!\-)/, "-") }
+    end
+  end
+end

data/vendor/bundle/ruby/3.4.0/gems/thor-1.5.0/lib/thor/parser/options.rb

@@ -0,0 +1,294 @@
+class Thor
+  class Options < Arguments #:nodoc:
+    LONG_RE     = /^(--\w+(?:-\w+)*)$/
+    SHORT_RE    = /^(-[a-z])$/i
+    EQ_RE       = /^(--\w+(?:-\w+)*|-[a-z])=(.*)$/i
+    SHORT_SQ_RE = /^-([a-z]{2,})$/i # Allow either -x -v or -xv style for single char args
+    SHORT_NUM   = /^(-[a-z])#{NUMERIC}$/i
+    OPTS_END    = "--".freeze
+
+    # Receives a hash and makes it switches.
+    def self.to_switches(options)
+      options.map do |key, value|
+        case value
+        when true
+          "--#{key}"
+        when Array
+          "--#{key} #{value.map(&:inspect).join(' ')}"
+        when Hash
+          "--#{key} #{value.map { |k, v| "#{k}:#{v}" }.join(' ')}"
+        when nil, false
+          nil
+        else
+          "--#{key} #{value.inspect}"
+        end
+      end.compact.join(" ")
+    end
+
+    # Takes a hash of Thor::Option and a hash with defaults.
+    #
+    # If +stop_on_unknown+ is true, #parse will stop as soon as it encounters
+    # an unknown option or a regular argument.
+    def initialize(hash_options = {}, defaults = {}, stop_on_unknown = false, disable_required_check = false, relations = {})
+      @stop_on_unknown = stop_on_unknown
+      @exclusives = (relations[:exclusive_option_names] || []).select{|array| !array.empty?}
+      @at_least_ones = (relations[:at_least_one_option_names] || []).select{|array| !array.empty?}
+      @disable_required_check = disable_required_check
+      options = hash_options.values
+      super(options)
+
+      # Add defaults
+      defaults.each do |key, value|
+        @assigns[key.to_s] = value
+        @non_assigned_required.delete(hash_options[key])
+      end
+
+      @shorts = {}
+      @switches = {}
+      @extra = []
+      @stopped_parsing_after_extra_index = nil
+      @is_treated_as_value = false
+
+      options.each do |option|
+        @switches[option.switch_name] = option
+
+        option.aliases.each do |name|
+          @shorts[name] ||= option.switch_name
+        end
+      end
+    end
+
+    def remaining
+      @extra
+    end
+
+    def peek
+      return super unless @parsing_options
+
+      result = super
+      if result == OPTS_END
+        shift
+        @parsing_options = false
+        @stopped_parsing_after_extra_index ||= @extra.size
+        super
+      else
+        result
+      end
+    end
+
+    def shift
+      @is_treated_as_value = false
+      super
+    end
+
+    def unshift(arg, is_value: false)
+      @is_treated_as_value = is_value
+      super(arg)
+    end
+
+    def parse(args) # rubocop:disable Metrics/MethodLength
+      @pile = args.dup
+      @is_treated_as_value = false
+      @parsing_options = true
+
+      while peek
+        if parsing_options?
+          match, is_switch = current_is_switch?
+          shifted = shift
+
+          if is_switch
+            case shifted
+            when SHORT_SQ_RE
+              unshift($1.split("").map { |f| "-#{f}" })
+              next
+            when EQ_RE
+              unshift($2, is_value: true)
+              switch = $1
+            when SHORT_NUM
+              unshift($2)
+              switch = $1
+            when LONG_RE, SHORT_RE
+              switch = $1
+            end
+
+            switch = normalize_switch(switch)
+            option = switch_option(switch)
+            result = parse_peek(switch, option)
+            assign_result!(option, result)
+          elsif @stop_on_unknown
+            @parsing_options = false
+            @extra << shifted
+            @stopped_parsing_after_extra_index ||= @extra.size
+            @extra << shift while peek
+            break
+          elsif match
+            @extra << shifted
+            @extra << shift while peek && peek !~ /^-/
+          else
+            @extra << shifted
+          end
+        else
+          @extra << shift
+        end
+      end
+
+      check_requirement! unless @disable_required_check
+      check_exclusive!
+      check_at_least_one!
+
+      assigns = Thor::CoreExt::HashWithIndifferentAccess.new(@assigns)
+      assigns.freeze
+      assigns
+    end
+
+    def check_exclusive!
+      opts = @assigns.keys
+      # When option A and B are exclusive, if A and B are given at the same time,
+      # the difference of argument array size will decrease.
+      found = @exclusives.find{ |ex| (ex - opts).size < ex.size - 1 }
+      if found
+        names = names_to_switch_names(found & opts).map{|n| "'#{n}'"}
+        class_name = self.class.name.split("::").last.downcase
+        fail ExclusiveArgumentError, "Found exclusive #{class_name} #{names.join(", ")}"
+      end
+    end
+
+    def check_at_least_one!
+      opts = @assigns.keys
+      # When at least one is required of the options A and B,
+      # if the both options were not given, none? would be true.
+      found = @at_least_ones.find{ |one_reqs| one_reqs.none?{ |o| opts.include? o} }
+      if found
+        names = names_to_switch_names(found).map{|n| "'#{n}'"}
+        class_name = self.class.name.split("::").last.downcase
+        fail AtLeastOneRequiredArgumentError, "Not found at least one of required #{class_name} #{names.join(", ")}"
+      end
+    end
+
+    def check_unknown!
+      to_check = @stopped_parsing_after_extra_index ? @extra[0...@stopped_parsing_after_extra_index] : @extra
+
+      # an unknown option starts with - or -- and has no more --'s afterward.
+      unknown = to_check.select { |str| str =~ /^--?(?:(?!--).)*$/ }
+      raise UnknownArgumentError.new(@switches.keys, unknown) unless unknown.empty?
+    end
+
+  protected
+
+    # Option names changes to swith name or human name
+    def names_to_switch_names(names = [])
+      @switches.map do |_, o|
+        if names.include? o.name
+          o.respond_to?(:switch_name) ? o.switch_name : o.human_name
+        else
+          nil
+        end
+      end.compact
+    end
+
+    def assign_result!(option, result)
+      if option.repeatable && option.type == :hash
+        (@assigns[option.human_name] ||= {}).merge!(result)
+      elsif option.repeatable
+        (@assigns[option.human_name] ||= []) << result
+      else
+        @assigns[option.human_name] = result
+      end
+    end
+
+    # Check if the current value in peek is a registered switch.
+    #
+    # Two booleans are returned.  The first is true if the current value
+    # starts with a hyphen; the second is true if it is a registered switch.
+    def current_is_switch?
+      return [false, false] if @is_treated_as_value
+      case peek
+      when LONG_RE, SHORT_RE, EQ_RE, SHORT_NUM
+        [true, switch?($1)]
+      when SHORT_SQ_RE
+        [true, $1.split("").any? { |f| switch?("-#{f}") }]
+      else
+        [false, false]
+      end
+    end
+
+    def current_is_switch_formatted?
+      return false if @is_treated_as_value
+      case peek
+      when LONG_RE, SHORT_RE, EQ_RE, SHORT_NUM, SHORT_SQ_RE
+        true
+      else
+        false
+      end
+    end
+
+    def current_is_value?
+      return true if @is_treated_as_value
+      peek && (!parsing_options? || super)
+    end
+
+    def switch?(arg)
+      !switch_option(normalize_switch(arg)).nil?
+    end
+
+    def switch_option(arg)
+      if match = no_or_skip?(arg) # rubocop:disable Lint/AssignmentInCondition
+        @switches[arg] || @switches["--#{match}"]
+      else
+        @switches[arg]
+      end
+    end
+
+    # Check if the given argument is actually a shortcut.
+    #
+    def normalize_switch(arg)
+      (@shorts[arg] || arg).tr("_", "-")
+    end
+
+    def parsing_options?
+      peek
+      @parsing_options
+    end
+
+    # Parse boolean values which can be given as --foo=true or --foo for true values, or
+    # --foo=false, --no-foo or --skip-foo for false values.
+    #
+    def parse_boolean(switch)
+      if current_is_value?
+        if ["true", "TRUE", "t", "T", true].include?(peek)
+          shift
+          true
+        elsif ["false", "FALSE", "f", "F", false].include?(peek)
+          shift
+          false
+        else
+          @switches.key?(switch) || !no_or_skip?(switch)
+        end
+      else
+        @switches.key?(switch) || !no_or_skip?(switch)
+      end
+    end
+
+    # Parse the value at the peek analyzing if it requires an input or not.
+    #
+    def parse_peek(switch, option)
+      if parsing_options? && (current_is_switch_formatted? || last?)
+        if option.boolean?
+          # No problem for boolean types
+        elsif no_or_skip?(switch)
+          return nil # User set value to nil
+        elsif option.string? && !option.required?
+          # Return the default if there is one, else the human name
+          return option.lazy_default || option.default || option.human_name
+        elsif option.lazy_default
+          return option.lazy_default
+        else
+          raise MalformattedArgumentError, "No value provided for option '#{switch}'"
+        end
+      end
+
+      @non_assigned_required.delete(option)
+      send(:"parse_#{option.type}", switch)
+    end
+  end
+end

data/vendor/bundle/ruby/3.4.0/gems/thor-1.5.0/lib/thor/parser.rb

@@ -0,0 +1,4 @@
+require_relative "parser/argument"
+require_relative "parser/arguments"
+require_relative "parser/option"
+require_relative "parser/options"

data/vendor/bundle/ruby/3.4.0/gems/thor-1.5.0/lib/thor/rake_compat.rb

@@ -0,0 +1,72 @@
+require "rake"
+require "rake/dsl_definition"
+
+class Thor
+  # Adds a compatibility layer to your Thor classes which allows you to use
+  # rake package tasks. For example, to use rspec rake tasks, one can do:
+  #
+  #   require 'thor/rake_compat'
+  #   require 'rspec/core/rake_task'
+  #
+  #   class Default < Thor
+  #     include Thor::RakeCompat
+  #
+  #     RSpec::Core::RakeTask.new(:spec) do |t|
+  #       t.spec_opts = ['--options', './.rspec']
+  #       t.spec_files = FileList['spec/**/*_spec.rb']
+  #     end
+  #   end
+  #
+  module RakeCompat
+    include Rake::DSL if defined?(Rake::DSL)
+
+    def self.rake_classes
+      @rake_classes ||= []
+    end
+
+    def self.included(base)
+      super(base)
+      # Hack. Make rakefile point to invoker, so rdoc task is generated properly.
+      rakefile = File.basename(caller[0].match(/(.*):\d+/)[1])
+      Rake.application.instance_variable_set(:@rakefile, rakefile)
+      rake_classes << base
+    end
+  end
+end
+
+# override task on (main), for compatibility with Rake 0.9
+instance_eval do
+  alias rake_namespace namespace
+
+  def task(*)
+    task = super
+
+    if klass = Thor::RakeCompat.rake_classes.last # rubocop:disable Lint/AssignmentInCondition
+      non_namespaced_name = task.name.split(":").last
+
+      description = non_namespaced_name
+      description << task.arg_names.map { |n| n.to_s.upcase }.join(" ")
+      description.strip!
+
+      klass.desc description, Rake.application.last_description || non_namespaced_name
+      Rake.application.last_description = nil
+      klass.send :define_method, non_namespaced_name do |*args|
+        Rake::Task[task.name.to_sym].invoke(*args)
+      end
+    end
+
+    task
+  end
+
+  def namespace(name)
+    if klass = Thor::RakeCompat.rake_classes.last # rubocop:disable Lint/AssignmentInCondition
+      const_name = Thor::Util.camel_case(name.to_s).to_sym
+      klass.const_set(const_name, Class.new(Thor))
+      new_klass = klass.const_get(const_name)
+      Thor::RakeCompat.rake_classes << new_klass
+    end
+
+    super
+    Thor::RakeCompat.rake_classes.pop
+  end
+end