decentworks-date-support 0.1.0

data/.gem_rbs_collection/railties/6.0/railties.rbs

@@ -0,0 +1,44 @@
+module Rails
+  module Configuration
+    class MiddlewareStackProxy
+      def delete: (*untyped args) ?{ () -> untyped } -> untyped
+
+      def insert_before: (*untyped args) ?{ () -> untyped } -> untyped
+
+      alias insert insert_before
+
+      def insert_after: (*untyped args) ?{ () -> untyped } -> untyped
+
+      def swap: (*untyped args) ?{ () -> untyped } -> untyped
+
+      def unshift: (*untyped args) ?{ () -> untyped } -> untyped
+
+      def use: (*untyped args) ?{ () -> untyped } -> untyped
+    end
+  end
+end
+
+module Rails
+  class Engine
+    # Defines the routes for this engine. If a block is given to
+    # routes, it is appended to the engine.
+    def routes: () ?{ () [self: ActionDispatch::Routing::Mapper] -> void } -> ActionDispatch::Routing::RouteSet
+  end
+end
+
+module Rails
+  module Generators
+    class PluginGenerator < AppBase
+      # It is necessary to satisfy alias target.
+      def app_path: () -> untyped
+    end
+  end
+end
+
+module Rails
+  def self.application: () -> Rails::Application
+
+  class Railties
+    extend Initializable::ClassMethods
+  end
+end

data/.gem_rbs_collection/rainbow/3.0/.rbs_meta.yaml

@@ -0,0 +1,9 @@
+---
+name: rainbow
+version: '3.0'
+source:
+  type: git
+  name: ruby/gem_rbs_collection
+  revision: 82762423fc5694b82888ea89a972847cf19838c2
+  remote: https://github.com/ruby/gem_rbs_collection.git
+  repo_dir: gems

data/.gem_rbs_collection/rainbow/3.0/global.rbs

@@ -0,0 +1,7 @@
+module Rainbow
+  def self.enabled: () -> bool
+
+  def self.enabled=: (bool value) -> bool
+
+  def self.uncolor: (String string) -> String
+end

data/.gem_rbs_collection/rainbow/3.0/presenter.rbs

@@ -0,0 +1,209 @@
+module Rainbow
+  class Presenter < String
+    # Sets color of this text.
+    def color: (*Symbol values) -> instance
+
+    alias foreground color
+
+    alias fg color
+
+    # Sets background color of this text.
+    def background: (*Symbol values) -> instance
+
+    alias bg background
+
+    # Resets terminal to default colors/backgrounds.
+    #
+    # It shouldn't be needed to use this method because all methods
+    # append terminal reset code to end of string.
+    def reset: () -> instance
+
+    # Turns on bright/bold for this text.
+    def bright: () -> instance
+
+    alias bold bright
+
+    # Turns on faint/dark for this text (not well supported by terminal
+    # emulators).
+    def faint: () -> instance
+
+    # Turns on italic style for this text (not well supported by terminal
+    # emulators).
+    def italic: () -> instance
+
+    # Turns on underline decoration for this text.
+    def underline: () -> instance
+
+    # Turns on blinking attribute for this text (not well supported by terminal
+    # emulators).
+    def blink: () -> instance
+
+    # Inverses current foreground/background colors.
+    def inverse: () -> instance
+
+    # Hides this text (set its color to the same as background).
+    def hide: () -> instance
+
+    def black: () -> instance
+
+    def red: () -> instance
+
+    def green: () -> instance
+
+    def yellow: () -> instance
+
+    def blue: () -> instance
+
+    def magenta: () -> instance
+
+    def cyan: () -> instance
+
+    def white: () -> instance
+
+    # We take care of X11 color method call here.
+    # Such as #aqua, #ghostwhite.
+    def method_missing: (untyped method_name, *untyped args) -> untyped
+
+    def respond_to_missing?: (untyped method_name, *untyped args) -> bool
+
+    def wrap_with_sgr: (untyped codes) -> instance
+
+    def aliceblue: () -> instance
+    def antiquewhite: () -> instance
+    def aqua: () -> instance
+    def aquamarine: () -> instance
+    def azure: () -> instance
+    def beige: () -> instance
+    def bisque: () -> instance
+    def blanchedalmond: () -> instance
+    def blueviolet: () -> instance
+    def brown: () -> instance
+    def burlywood: () -> instance
+    def cadetblue: () -> instance
+    def chartreuse: () -> instance
+    def chocolate: () -> instance
+    def coral: () -> instance
+    def cornflower: () -> instance
+    def cornsilk: () -> instance
+    def crimson: () -> instance
+    def darkblue: () -> instance
+    def darkcyan: () -> instance
+    def darkgoldenrod: () -> instance
+    def darkgray: () -> instance
+    def darkgreen: () -> instance
+    def darkkhaki: () -> instance
+    def darkmagenta: () -> instance
+    def darkolivegreen: () -> instance
+    def darkorange: () -> instance
+    def darkorchid: () -> instance
+    def darkred: () -> instance
+    def darksalmon: () -> instance
+    def darkseagreen: () -> instance
+    def darkslateblue: () -> instance
+    def darkslategray: () -> instance
+    def darkturquoise: () -> instance
+    def darkviolet: () -> instance
+    def deeppink: () -> instance
+    def deepskyblue: () -> instance
+    def dimgray: () -> instance
+    def dodgerblue: () -> instance
+    def firebrick: () -> instance
+    def floralwhite: () -> instance
+    def forestgreen: () -> instance
+    def fuchsia: () -> instance
+    def gainsboro: () -> instance
+    def ghostwhite: () -> instance
+    def gold: () -> instance
+    def goldenrod: () -> instance
+    def gray: () -> instance
+    def greenyellow: () -> instance
+    def honeydew: () -> instance
+    def hotpink: () -> instance
+    def indianred: () -> instance
+    def indigo: () -> instance
+    def ivory: () -> instance
+    def khaki: () -> instance
+    def lavender: () -> instance
+    def lavenderblush: () -> instance
+    def lawngreen: () -> instance
+    def lemonchiffon: () -> instance
+    def lightblue: () -> instance
+    def lightcoral: () -> instance
+    def lightcyan: () -> instance
+    def lightgoldenrod: () -> instance
+    def lightgray: () -> instance
+    def lightgreen: () -> instance
+    def lightpink: () -> instance
+    def lightsalmon: () -> instance
+    def lightseagreen: () -> instance
+    def lightskyblue: () -> instance
+    def lightslategray: () -> instance
+    def lightsteelblue: () -> instance
+    def lightyellow: () -> instance
+    def lime: () -> instance
+    def limegreen: () -> instance
+    def linen: () -> instance
+    def maroon: () -> instance
+    def mediumaquamarine: () -> instance
+    def mediumblue: () -> instance
+    def mediumorchid: () -> instance
+    def mediumpurple: () -> instance
+    def mediumseagreen: () -> instance
+    def mediumslateblue: () -> instance
+    def mediumspringgreen: () -> instance
+    def mediumturquoise: () -> instance
+    def mediumvioletred: () -> instance
+    def midnightblue: () -> instance
+    def mintcream: () -> instance
+    def mistyrose: () -> instance
+    def moccasin: () -> instance
+    def navajowhite: () -> instance
+    def navyblue: () -> instance
+    def oldlace: () -> instance
+    def olive: () -> instance
+    def olivedrab: () -> instance
+    def orange: () -> instance
+    def orangered: () -> instance
+    def orchid: () -> instance
+    def palegoldenrod: () -> instance
+    def palegreen: () -> instance
+    def paleturquoise: () -> instance
+    def palevioletred: () -> instance
+    def papayawhip: () -> instance
+    def peachpuff: () -> instance
+    def peru: () -> instance
+    def pink: () -> instance
+    def plum: () -> instance
+    def powderblue: () -> instance
+    def purple: () -> instance
+    def rebeccapurple: () -> instance
+    def rosybrown: () -> instance
+    def royalblue: () -> instance
+    def saddlebrown: () -> instance
+    def salmon: () -> instance
+    def sandybrown: () -> instance
+    def seagreen: () -> instance
+    def seashell: () -> instance
+    def sienna: () -> instance
+    def silver: () -> instance
+    def skyblue: () -> instance
+    def slateblue: () -> instance
+    def slategray: () -> instance
+    def snow: () -> instance
+    def springgreen: () -> instance
+    def steelblue: () -> instance
+    def tan: () -> instance
+    def teal: () -> instance
+    def thistle: () -> instance
+    def tomato: () -> instance
+    def turquoise: () -> instance
+    def violet: () -> instance
+    def webgray: () -> instance
+    def webgreen: () -> instance
+    def webmaroon: () -> instance
+    def webpurple: () -> instance
+    def wheat: () -> instance
+    def whitesmoke: () -> instance
+    def yellowgreen: () -> instance
+  end
+end

data/.gem_rbs_collection/rainbow/3.0/rainbow.rbs

@@ -0,0 +1,5 @@
+class Object
+  private
+
+  def Rainbow: (String) -> Rainbow::Presenter
+end

data/.gem_rbs_collection/rake/13.0/.rbs_meta.yaml

@@ -0,0 +1,9 @@
+---
+name: rake
+version: '13.0'
+source:
+  type: git
+  name: ruby/gem_rbs_collection
+  revision: 82762423fc5694b82888ea89a972847cf19838c2
+  remote: https://github.com/ruby/gem_rbs_collection.git
+  repo_dir: gems

data/.gem_rbs_collection/rake/13.0/manifest.yaml

@@ -0,0 +1,2 @@
+dependencies:
+  - name: fileutils

data/.gem_rbs_collection/rake/13.0/rake.rbs

@@ -0,0 +1,39 @@
+module Rake
+  class TaskLib
+    include Rake::DSL
+  end
+
+  class Task
+  end
+
+  class TaskArguments
+    include Enumerable[untyped]
+
+    def []: (untyped index) -> untyped
+    def each: () ?{ (untyped, untyped) -> void } -> void
+  end
+
+  module DSL
+    private
+
+    include FileUtils
+
+    def desc: (String description) -> void
+    def directory: (*untyped args) ?{ () -> void } -> void
+    def file: (*untyped args) ?{ () -> void } -> void
+    def file_create: (*untyped args) ?{ () -> void } -> void
+    def import: (*String fns) -> void
+    def multitask: (*untyped args) ?{ () -> void } -> void
+    def namespace: (?untyped name) ?{ () -> void } -> void
+    def rule: (*untyped args) ?{ () -> void } -> void
+    def task: (*untyped args) ?{ (Rake::Task, Rake::TaskArguments) -> void } -> void
+  end
+end
+
+module FileUtils
+  def sh: (*String cmd, **untyped options) ?{ (bool, Process::Status) -> void } -> void
+    | (Hash[String, String] env, *String cmd, **untyped options) ?{ (bool, Process::Status) -> void } -> void
+  def ruby: (*String args, **untyped options) ?{ (bool, Process::Status) -> void } -> void
+  def safe_ln: (*untyped args, **untyped options) -> void
+  def split_all: (String path) -> Array[String]
+end

data/.gem_rbs_collection/regexp_parser/2.8/.rbs_meta.yaml

@@ -0,0 +1,9 @@
+---
+name: regexp_parser
+version: '2.8'
+source:
+  type: git
+  name: ruby/gem_rbs_collection
+  revision: 82762423fc5694b82888ea89a972847cf19838c2
+  remote: https://github.com/ruby/gem_rbs_collection.git
+  repo_dir: gems

data/.gem_rbs_collection/regexp_parser/2.8/regexp_parser.rbs

@@ -0,0 +1,17 @@
+class Regexp::Parser
+  def parse: [T] (Regexp | String input, ?String? syntax, ?options: Integer?) { (Regexp::Expression::Root) -> T } -> T
+           | (Regexp | String input, ?String? syntax, ?options: Integer?) -> Regexp::Expression::Root
+  def self.parse: [T] (Regexp | String input, ?String? syntax, ?options: Integer?) { (Regexp::Expression::Root) -> T } -> T
+                | (Regexp | String input, ?String? syntax, ?options: Integer?) -> Regexp::Expression::Root
+end
+
+module Regexp::Expression
+  class Root < Subexpression
+  end
+
+  class Subexpression < Base
+  end
+
+  class Base
+  end
+end

data/.gem_rbs_collection/rubocop/1.57/.rbs_meta.yaml

@@ -0,0 +1,9 @@
+---
+name: rubocop
+version: '1.57'
+source:
+  type: git
+  name: ruby/gem_rbs_collection
+  revision: 82762423fc5694b82888ea89a972847cf19838c2
+  remote: https://github.com/ruby/gem_rbs_collection.git
+  repo_dir: gems

data/.gem_rbs_collection/rubocop/1.57/rubocop.rbs

@@ -0,0 +1,208 @@
+module RuboCop
+  class CommentConfig
+    attr_reader processed_source: ProcessedSource
+
+    def initialize: (ProcessedSource processed_source) -> void
+  end
+
+  class ConfigLoader
+    def self.debug?: () -> boolish
+    def self.merge_with_default: (Config, String) -> Config
+  end
+
+  class Config
+    def initialize: (?Hash[untyped, untyped] hash, ?String loaded_path) -> void
+    def for_cop: (String cop) -> Hash[String, untyped]
+    def for_enabled_cop: (String cop) -> Hash[String, untyped]
+  end
+
+  class ConfigStore
+    def options_config=: (String options_config) -> void
+  end
+
+  module Cop
+    class Base
+      extend AST::NodePattern::Macros
+      include Util
+      include IgnoredNode
+      include AutocorrectLogic
+
+      def self.exclude_from_registry: () -> void
+      def self.department: () -> Symbol
+      def self.cop_name: () -> String
+      def self.documentation_url: (?Config?) -> String
+      def self.requires_gem: (String gem_name, *String version_requirements) -> void
+
+      attr_reader config: Config
+
+      def on_new_investigation: () -> void
+      def on_investigation_end: () -> void
+      def on_other_file: () -> void
+      def add_offense: (untyped node, ?message: String, ?severity: Symbol) -> void
+                     | (untyped node, ?message: String, ?severity: Symbol) { (Corrector) -> void } -> void
+      def cop_config: () -> Hash[String, untyped]
+      def target_ruby_version: () -> Float
+      def processed_source: () -> AST::ProcessedSource
+      def target_gem_version: (String gem_name) -> Gem::Version
+    end
+
+    module AutocorrectLogic
+      def autocorrect?: () -> bool
+      def autocorrect_with_disable_uncorrectable?: () -> bool
+      def autocorrect_requested?: () -> bool
+      def correctable?: () -> bool
+      def disable_uncorrectable?: () -> bool
+      def safe_autocorrect?: () -> bool
+      def autocorrect_enabled?: () -> bool
+    end
+
+    class Corrector < Parser::Source::TreeRewriter
+      def replace: ((Parser::Source::Range | RuboCop::AST::Node) range, String content) -> self
+      def wrap: ((Parser::Source::Range | RuboCop::AST::Node) range, String? insert_before, String? insert_after) -> self
+      def remove: ((Parser::Source::Range | RuboCop::AST::Node) range) -> self
+      def insert_before: ((Parser::Source::Range | RuboCop::AST::Node) range, String content) -> self
+      def insert_after: ((Parser::Source::Range | RuboCop::AST::Node) range, String content) -> self
+      def remove_preceding: ((Parser::Source::Range | RuboCop::AST::Node) node_or_range, Integer size) -> self
+      def remove_leading: ((Parser::Source::Range | RuboCop::AST::Node) node_or_range, Integer size) -> self
+      def remove_trailing: ((Parser::Source::Range | RuboCop::AST::Node) node_or_range, Integer size) -> self
+      def swap: ((Parser::Source::Range | RuboCop::AST::Node) node_or_range1, (Parser::Source::Range | RuboCop::AST::Node) node_or_range2) -> self
+    end
+
+    module Alignment
+      def configured_indentation_width: () -> Integer
+      def indentation: (RuboCop::AST::Node node) -> String
+      def offset: (RuboCop::AST::Node node) -> String
+    end
+
+    module ConfigurableEnforcedStyle
+      def opposite_style_detected: () -> void
+      def correct_style_detected: () -> void
+      def unexpected_style_detected: (Symbol unexpected) -> void
+      def ambiguous_style_detected: (*Symbol possibilities) -> void
+      def style_detected: (Symbol detected) -> void
+      def style: () -> Symbol
+    end
+
+    module CommentsHelp
+      def source_range_with_comment: (RuboCop::AST::Node node) -> Parser::Source::Range
+      def contains_comments?: (RuboCop::AST::Node node) -> bool
+      def comments_in_range: (RuboCop::AST::Node node) -> Array[Parser::Source::Comment]
+      def comments_contain_disables?: (RuboCop::AST::Node node, String cop_name) -> bool
+    end
+
+    class Offense
+      attr_reader severity: Severity
+      attr_reader location: Parser::Source::Range
+      attr_reader message: String
+      attr_reader cop_name: String
+
+      def line: () -> Integer
+      def column: () -> Integer
+    end
+
+    module RangeHelp
+      def source_range: (Parser::Source::Buffer source_buffer, Integer line_number, Integer column, ?Integer length) -> Parser::Source::Range
+      def range_between: (Integer start_pos, Integer end_pos) -> Parser::Source::Range
+      def range_with_surrounding_space: (?Parser::Source::Range range_positional,
+                                         ?range: Parser::Source::Range, ?side: Symbol, ?newlines: bool,
+                                         ?whitespace: bool, ?continuations: bool,
+                                         ?buffer: Parser::Source::Buffer) -> Parser::Source::Range
+      def range_by_whole_lines: (Parser::Source::Range range,
+                                 ?include_final_newline: bool,
+                                 ?buffer: Parser::Source::Buffer) -> Parser::Source::Range
+    end
+
+    class Registry
+    end
+
+    module IgnoredNode
+      def ignore_node: (RuboCop::AST::Node node) -> void
+      def part_of_ignored_node?: (RuboCop::AST::Node node) -> bool
+      def ignored_node?: (RuboCop::AST::Node node) -> bool
+    end
+
+    class Severity
+      type t = :info | :refactor | :convention | :warning | :error | :fatal
+
+      attr_reader name: t
+
+      def code: () -> String
+      def level: () -> Integer
+    end
+
+    module TargetRubyVersion
+      def minimum_target_ruby_version: (Float) -> void
+      def maximum_target_ruby_version: (Float) -> void
+    end
+
+    module Util
+      include PathUtil
+      def line_range: (RuboCop::AST::Node node) -> ::Range[Integer]
+      def parentheses?: (RuboCop::AST::Node node) -> bool
+      def add_parentheses: (RuboCop::AST::Node node, Corrector corrector) -> void
+      def any_descendant?: (RuboCop::AST::Node node, *Symbol types) -> bool
+      def args_begin: (RuboCop::AST::Node node) -> Parser::Source::Range
+      def args_end: (RuboCop::AST::Node node) -> Parser::Source::Range
+      def begins_its_line?: (Parser::Source::Range range) -> bool
+      def first_part_of_call_chain: (RuboCop::AST::Node node) -> RuboCop::AST::Node
+      def double_quotes_required?: (String string) -> bool
+      def needs_escaping?: (String string) -> bool
+      def escape_string: (String string) -> String
+      def to_string_literal: (String string) -> String
+      def trim_string_interpolation_escape_character: (String str) -> String
+      def interpret_string_escapes: (String string) -> String
+      def line: ((RuboCop::AST::Node | Parser::Source::Range) node_or_range) -> Integer
+      def same_line?: ((RuboCop::AST::Node | Parser::Source::Range) node1, (RuboCop::AST::Node | Parser::Source::Range) node2) -> bool
+      def indent: (RuboCop::AST::Node node, ?offset: Integer) -> String
+    end
+  end
+
+  module Ext
+    module Comment
+      def source: () -> String
+      def source_range: () -> Parser::Source::Range
+    end
+
+    module ProcessedSource
+      attr_accessor registry: Cop::Registry
+      attr_accessor config: Config
+
+      def comment_config: () -> CommentConfig
+      def disabled_line_ranges: () -> Hash[untyped, untyped]
+    end
+  end
+
+  class ProcessedSource = AST::ProcessedSource
+
+  class Runner
+    type extractorResult = Array[{ offset: Integer, processed_source: ProcessedSource}]?
+
+    interface _Extractor
+      def call: (ProcessedSource) -> extractorResult
+    end
+
+    def self.ruby_extractors: () -> Array[_Extractor]
+  end
+
+  module AutoCorrector
+    def support_autocorrect?: () -> true
+  end
+
+  module PathUtil
+    def smart_path: (String path) -> String
+  end
+end
+
+# Patch to RuboCop::AST::*
+
+module RuboCop
+  module AST
+    class Comment
+      include Ext::Comment
+    end
+
+    class ProcessedSource
+      include Ext::ProcessedSource
+    end
+  end
+end

data/.gem_rbs_collection/rubocop-ast/1.46/.rbs_meta.yaml

@@ -0,0 +1,9 @@
+---
+name: rubocop-ast
+version: '1.46'
+source:
+  type: git
+  name: ruby/gem_rbs_collection
+  revision: 82762423fc5694b82888ea89a972847cf19838c2
+  remote: https://github.com/ruby/gem_rbs_collection.git
+  repo_dir: gems