u-struct 0.11.0 → 1.1.0

data/rbi/micro/struct/factory/members.rbi

@@ -0,0 +1,67 @@
+# typed: strong
+
+class Micro::Struct::Factory::Members
+  STR_OR_SYMBOL = T.type_alias { T.any(String, Symbol) }
+  MEMBER_NAMES  = T.type_alias { T.any(STR_OR_SYMBOL, T::Array[STR_OR_SYMBOL]) }
+
+  sig { returns(T::Array[Symbol]) }
+  attr_reader :required_and_optional
+
+  Names = T.let(T.unsafe, T.proc.params(arg0: T.nilable(MEMBER_NAMES)).returns(T::Array[Symbol]))
+
+  sig {
+    params(
+      required_members: T::Array[STR_OR_SYMBOL],
+      required_option: T.nilable(MEMBER_NAMES),
+      optional_option: T.nilable(MEMBER_NAMES)
+    ).void
+  }
+  def initialize(required_members, required_option, optional_option)
+  end
+
+  class ToEval < ::Struct
+    extend T::Generic
+
+    sig {
+      params(
+        required: T::Array[Symbol],
+        optional: T::Array[Symbol],
+        required_and_optional: T::Array[Symbol]
+      ).void
+    }
+    def initialize(required, optional, required_and_optional)
+    end
+
+    sig { returns(T::Array[Symbol]) }
+    def required
+    end
+
+    sig { returns(T::Array[Symbol]) }
+    def optional
+    end
+
+    sig { returns(T::Array[Symbol]) }
+    def required_and_optional
+    end
+
+    sig { params(name: Symbol).returns(T::Boolean) }
+    def option?(name)
+    end
+
+    sig { params(names: Symbol).returns(T::Boolean) }
+    def options?(*names)
+    end
+
+    sig { returns(String) }
+    def keyword_args
+    end
+
+    sig { returns(String) }
+    def positional_args
+    end
+  end
+
+  sig { returns(ToEval) }
+  def to_eval
+  end
+end

data/rbi/micro/struct/factory.rbi

@@ -0,0 +1,41 @@
+# typed: strong
+
+class Micro::Struct::Factory
+  STR_OR_SYMBOL = T.type_alias { T.any(String, Symbol) }
+  MEMBER_NAMES = T.type_alias { T.any(STR_OR_SYMBOL, T::Array[STR_OR_SYMBOL]) }
+  STRUCT_BLOCK = T.type_alias { T.nilable(T.proc.params(arg0: T.untyped).returns(T.untyped)) }
+
+  sig {
+    params(feature_names: T::Array[T.any(String, Symbol)]).void
+  }
+  def initialize(feature_names)
+  end
+
+  sig { params(members: T.untyped, block:   STRUCT_BLOCK).returns(Struct) }
+  def instance(**members, &block)
+  end
+
+  sig {
+    params(
+      required_members: STR_OR_SYMBOL,
+      required:     T.nilable(MEMBER_NAMES),
+      optional:     T.nilable(MEMBER_NAMES),
+      struct_block: STRUCT_BLOCK
+    )
+    .returns(T.class_of(Struct))
+  }
+  def new(*required_members, required: nil, optional: nil, &struct_block)
+  end
+
+  sig {
+    params(
+      required_members: T::Array[STR_OR_SYMBOL],
+      required:     T.nilable(MEMBER_NAMES),
+      optional:     T.nilable(MEMBER_NAMES),
+      struct_block: STRUCT_BLOCK
+    )
+    .returns(T.class_of(Struct))
+  }
+  def __create__(required_members, required, optional, struct_block)
+  end
+end

data/rbi/micro/struct/features.rbi

@@ -0,0 +1,41 @@
+# typed: strong
+
+module Micro::Struct::Features
+  FEAT_NAMES = T.type_alias { T::Array[Symbol] }
+  FEAT_OPTIONS = T.type_alias { T::Hash[Symbol, T::Boolean] }
+  STR_OR_SYMBOL = T.type_alias { T.any(String, Symbol) }
+
+  module Options
+    sig { params(names: FEAT_NAMES).returns(FEAT_OPTIONS) }
+    def from(names:)
+    end
+  end
+
+  class Config < ::Struct
+    extend T::Generic
+
+    sig { params(names: FEAT_NAMES, options: FEAT_OPTIONS).void }
+    def initialize(names, options)
+    end
+
+    sig { returns(FEAT_NAMES) }
+    def names; end
+
+    sig { returns(FEAT_OPTIONS) }
+    def options; end
+
+    sig { params(name: Symbol).returns(T::Boolean) }
+    def option?(name); end
+
+    sig { params(names: Symbol).returns(T::Boolean) }
+    def options?(*names); end
+  end
+
+  Names = T.let(T.unsafe, T.proc.params(arg0: T::Array[STR_OR_SYMBOL]).returns(FEAT_NAMES))
+
+  sig {
+    params(values: T::Array[STR_OR_SYMBOL]).returns(T.any(Config, Exposed))
+  }
+  def self.config(values)
+  end
+end

data/rbi/micro/struct/normalize_names.rbi

@@ -0,0 +1,20 @@
+# typed: strong
+
+module Micro::Struct::NormalizeNames
+  module AsSymbols
+    STR_OR_SYMBOL = T.type_alias { T.any(String, Symbol) }
+
+    REGEXP = T.let(T.unsafe, Regexp)
+    Invalid = T.let(T.unsafe, T.proc.params(arg0: String, arg1: T.any(STR_OR_SYMBOL)).void)
+    AsSymbol = T.let(T.unsafe, T.proc.params(arg0: String, arg1: T.any(STR_OR_SYMBOL)).returns(Symbol))
+
+    sig {
+      params(
+        values:  T.nilable(T.any(STR_OR_SYMBOL, T::Array[STR_OR_SYMBOL])),
+        context: String
+      ).returns(T::Array[Symbol])
+    }
+    def self.call(values, context:)
+    end
+  end
+end

data/rbi/micro/struct/version.rbi

@@ -0,0 +1,3 @@
+# typed: strong
+
+Micro::Struct::VERSION = T.let(T.unsafe(nil), String)

data/rbi/micro/struct.rbi

@@ -0,0 +1,68 @@
+# typed: strong
+
+module Micro::Struct
+  STR_OR_SYMBOL = T.type_alias { T.any(String, Symbol) }
+  STRUCT_BLOCK  = T.type_alias { T.nilable(T.proc.params(arg0: T.untyped).returns(T.untyped)) }
+
+  sig {
+    params(feature_names: Symbol).returns(Micro::Struct::Factory)
+  }
+  def self.with(*feature_names)
+  end
+
+  sig {
+    params(feature_names: Symbol).returns(Micro::Struct::Factory)
+  }
+  def self.[](*feature_names)
+  end
+
+  sig {
+    params(
+      members:  STR_OR_SYMBOL,
+      required: T.nilable(T.any(STR_OR_SYMBOL, T::Array[STR_OR_SYMBOL])),
+      optional: T.nilable(T.any(STR_OR_SYMBOL, T::Array[STR_OR_SYMBOL])),
+      block:    STRUCT_BLOCK
+    )
+    .returns(T.class_of(Struct))
+  }
+  def self.new(*members, required: nil, optional: nil, &block)
+  end
+
+  sig {
+    params(
+      members: T.untyped,
+      block:   STRUCT_BLOCK
+    )
+    .returns(Struct)
+  }
+  def self.instance(**members, &block)
+  end
+
+  READONLY = T.let(T::Array[Symbol])
+  IMMUTABLE = T.let(T::Array[Symbol])
+  EMPTY_ARRAY = T.let(T::Array)
+
+  sig {
+    params(with: T::Array[Symbol]).returns(Micro::Struct::Factory)
+  }
+  def readonly(with: EMPTY_ARRAY)
+  end
+
+  sig {
+    params(with: T::Array[Symbol]).returns(Micro::Struct::Factory)
+  }
+  def immutable(with: EMPTY_ARRAY)
+  end
+
+  private
+
+  sig {
+    params(
+      names: T.nilable(T::Array[Symbol]),
+      defaults: T::Array[Symbol]
+    )
+    .returns(Micro::Struct::Factory)
+  }
+  def factory(names, defaults = EMPTY_ARRAY)
+  end
+end

data/sorbet/config

@@ -0,0 +1,8 @@
+--dir
+.
+
+--ignore
+examples
+
+--ignore
+vendor

data/sorbet/rbi/gems/ast@2.4.2.rbi

@@ -0,0 +1,54 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for types exported from the `ast` gem.
+# Please instead update this file by running `bin/tapioca gem ast`.
+
+module AST; end
+
+class AST::Node
+  def initialize(type, children = T.unsafe(nil), properties = T.unsafe(nil)); end
+
+  def +(array); end
+  def <<(element); end
+  def ==(other); end
+  def append(element); end
+  def children; end
+  def clone; end
+  def concat(array); end
+  def deconstruct; end
+  def dup; end
+  def eql?(other); end
+  def hash; end
+  def inspect(indent = T.unsafe(nil)); end
+  def to_a; end
+  def to_ast; end
+  def to_s(indent = T.unsafe(nil)); end
+  def to_sexp(indent = T.unsafe(nil)); end
+  def to_sexp_array; end
+  def type; end
+  def updated(type = T.unsafe(nil), children = T.unsafe(nil), properties = T.unsafe(nil)); end
+
+  protected
+
+  def assign_properties(properties); end
+  def fancy_type; end
+
+  private
+
+  def original_dup; end
+end
+
+class AST::Processor
+  include ::AST::Processor::Mixin
+end
+
+module AST::Processor::Mixin
+  def handler_missing(node); end
+  def process(node); end
+  def process_all(nodes); end
+end
+
+module AST::Sexp
+  def s(type, *children); end
+end

data/sorbet/rbi/gems/coderay@1.1.3.rbi

@@ -0,0 +1,8 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for types exported from the `coderay` gem.
+# Please instead update this file by running `bin/tapioca gem coderay`.
+
+# THIS IS AN EMPTY RBI FILE.
+# see https://github.com/Shopify/tapioca/wiki/Manual-Gem-Requires

data/sorbet/rbi/gems/diff-lcs@1.5.0.rbi

@@ -0,0 +1,11 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for types exported from the `diff-lcs` gem.
+# Please instead update this file by running `bin/tapioca gem diff-lcs`.
+
+class Integer < ::Numeric
+  include ::JSON::Ext::Generator::GeneratorMethods::Integer
+end
+
+Integer::GMP_VERSION = T.let(T.unsafe(nil), String)

data/sorbet/rbi/gems/docile@1.4.0.rbi

@@ -0,0 +1,54 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for types exported from the `docile` gem.
+# Please instead update this file by running `bin/tapioca gem docile`.
+
+module Docile
+  extend ::Docile::Execution
+
+  private
+
+  def dsl_eval(dsl, *args, &block); end
+  def dsl_eval_immutable(dsl, *args, &block); end
+  def dsl_eval_with_block_return(dsl, *args, &block); end
+
+  class << self
+    def dsl_eval(dsl, *args, &block); end
+    def dsl_eval_immutable(dsl, *args, &block); end
+    def dsl_eval_with_block_return(dsl, *args, &block); end
+  end
+end
+
+module Docile::BacktraceFilter
+  def backtrace; end
+  def backtrace_locations; end
+end
+
+Docile::BacktraceFilter::FILTER_PATTERN = T.let(T.unsafe(nil), Regexp)
+
+class Docile::ChainingFallbackContextProxy < ::Docile::FallbackContextProxy
+  def method_missing(method, *args, &block); end
+end
+
+module Docile::Execution
+  private
+
+  def exec_in_proxy_context(dsl, proxy_type, *args, &block); end
+
+  class << self
+    def exec_in_proxy_context(dsl, proxy_type, *args, &block); end
+  end
+end
+
+class Docile::FallbackContextProxy
+  def initialize(receiver, fallback); end
+
+  def instance_variables; end
+  def method_missing(method, *args, &block); end
+end
+
+Docile::FallbackContextProxy::NON_FALLBACK_METHODS = T.let(T.unsafe(nil), Set)
+Docile::FallbackContextProxy::NON_PROXIED_INSTANCE_VARIABLES = T.let(T.unsafe(nil), Set)
+Docile::FallbackContextProxy::NON_PROXIED_METHODS = T.let(T.unsafe(nil), Set)
+Docile::VERSION = T.let(T.unsafe(nil), String)

data/sorbet/rbi/gems/method_source@1.0.0.rbi

@@ -0,0 +1,8 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for types exported from the `method_source` gem.
+# Please instead update this file by running `bin/tapioca gem method_source`.
+
+# THIS IS AN EMPTY RBI FILE.
+# see https://github.com/Shopify/tapioca/wiki/Manual-Gem-Requires