muina 0.2.8 → 0.4.0

data/sorbet/rbi/gems/safe_type@1.1.1.rbi

@@ -1,157 +0,0 @@
-# DO NOT EDIT MANUALLY
-# This is an autogenerated file for types exported from the `safe_type` gem.
-# Please instead update this file by running `bin/tapioca sync`.
-
-# typed: true
-
-module SafeType
-  class << self
-    def coerce(input, rule, coerce_key = T.unsafe(nil)); end
-    def coerce!(input, rule); end
-  end
-end
-
-class SafeType::Boolean < ::SafeType::Rule
-  def initialize(type: T.unsafe(nil), **args); end
-
-  class << self
-    def default(value = T.unsafe(nil)); end
-  end
-end
-
-module SafeType::BooleanMixin; end
-
-class SafeType::CoercionError < ::StandardError
-  def initialize(value, desired_type, key = T.unsafe(nil)); end
-
-  def desired_type; end
-  def key; end
-  def value; end
-end
-
-class SafeType::Converter
-  class << self
-    def to_bool(input); end
-    def to_date(input); end
-    def to_date_time(input); end
-    def to_false(input); end
-    def to_float(input); end
-    def to_int(input); end
-    def to_time(input); end
-    def to_true(input); end
-    def to_type(input, type); end
-  end
-end
-
-class SafeType::Date < ::SafeType::Rule
-  def initialize(type: T.unsafe(nil), from: T.unsafe(nil), to: T.unsafe(nil), **args); end
-
-  def is_valid?(input); end
-
-  class << self
-    def default(value = T.unsafe(nil), from: T.unsafe(nil), to: T.unsafe(nil)); end
-    def strict(from: T.unsafe(nil), to: T.unsafe(nil)); end
-  end
-end
-
-class SafeType::DateTime < ::SafeType::Rule
-  def initialize(type: T.unsafe(nil), from: T.unsafe(nil), to: T.unsafe(nil), **args); end
-
-  def is_valid?(input); end
-
-  class << self
-    def default(value = T.unsafe(nil), from: T.unsafe(nil), to: T.unsafe(nil)); end
-    def strict(from: T.unsafe(nil), to: T.unsafe(nil)); end
-  end
-end
-
-class SafeType::EmptyValueError < ::StandardError
-  def initialize(desired_type, key = T.unsafe(nil)); end
-
-  def desired_type; end
-  def key; end
-end
-
-class SafeType::Float < ::SafeType::Rule
-  def initialize(type: T.unsafe(nil), min: T.unsafe(nil), max: T.unsafe(nil), **args); end
-
-  def is_valid?(input); end
-
-  class << self
-    def default(value = T.unsafe(nil), min: T.unsafe(nil), max: T.unsafe(nil)); end
-    def strict(min: T.unsafe(nil), max: T.unsafe(nil)); end
-  end
-end
-
-class SafeType::Integer < ::SafeType::Rule
-  def initialize(type: T.unsafe(nil), min: T.unsafe(nil), max: T.unsafe(nil), **args); end
-
-  def is_valid?(input); end
-
-  class << self
-    def default(value = T.unsafe(nil), min: T.unsafe(nil), max: T.unsafe(nil)); end
-    def strict(min: T.unsafe(nil), max: T.unsafe(nil)); end
-  end
-end
-
-class SafeType::InvalidRuleError < ::ArgumentError
-  def initialize; end
-end
-
-class SafeType::Rule
-  def initialize(type:, default: T.unsafe(nil), required: T.unsafe(nil), **args); end
-
-  def after(input); end
-  def before(input); end
-  def coerce(input, key = T.unsafe(nil)); end
-  def is_valid?(input); end
-
-  class << self
-    def coerce(input); end
-    def default; end
-    def strict; end
-  end
-end
-
-class SafeType::String < ::SafeType::Rule
-  def initialize(type: T.unsafe(nil), min_length: T.unsafe(nil), max_length: T.unsafe(nil), **args); end
-
-  def after(input); end
-  def is_valid?(input); end
-
-  class << self
-    def default(value = T.unsafe(nil), min_length: T.unsafe(nil), max_length: T.unsafe(nil)); end
-    def strict(min_length: T.unsafe(nil), max_length: T.unsafe(nil)); end
-  end
-end
-
-class SafeType::Symbol < ::SafeType::Rule
-  def initialize(type: T.unsafe(nil), min_length: T.unsafe(nil), max_length: T.unsafe(nil), **args); end
-
-  def after(input); end
-  def is_valid?(input); end
-
-  class << self
-    def default(value = T.unsafe(nil), min_length: T.unsafe(nil), max_length: T.unsafe(nil)); end
-    def strict(min_length: T.unsafe(nil), max_length: T.unsafe(nil)); end
-  end
-end
-
-class SafeType::Time < ::SafeType::Rule
-  def initialize(type: T.unsafe(nil), from: T.unsafe(nil), to: T.unsafe(nil), **args); end
-
-  def is_valid?(input); end
-
-  class << self
-    def default(value = T.unsafe(nil), from: T.unsafe(nil), to: T.unsafe(nil)); end
-    def strict(from: T.unsafe(nil), to: T.unsafe(nil)); end
-  end
-end
-
-class SafeType::ValidationError < ::StandardError
-  def initialize(value, desired_type, key = T.unsafe(nil)); end
-
-  def desired_type; end
-  def key; end
-  def value; end
-end

data/sorbet/rbi/gems/sexp_processor@4.15.3.rbi

@@ -1,359 +0,0 @@
-# DO NOT EDIT MANUALLY
-# This is an autogenerated file for types exported from the `sexp_processor` gem.
-# Please instead update this file by running `bin/tapioca sync`.
-
-# typed: true
-
-class MethodBasedSexpProcessor < ::SexpProcessor
-  def initialize; end
-
-  def class_stack; end
-  def in_klass(name); end
-  def in_method(name, file, line, line_max = T.unsafe(nil)); end
-  def in_sklass; end
-  def klass_name; end
-  def method_locations; end
-  def method_name; end
-  def method_stack; end
-  def process_class(exp); end
-  def process_defn(exp); end
-  def process_defs(exp); end
-  def process_module(exp); end
-  def process_sclass(exp); end
-  def process_until_empty(exp); end
-  def sclass; end
-  def signature; end
-  def with_new_method_stack; end
-end
-
-class NotEmptyError < ::SexpProcessorError; end
-
-class Object < ::BasicObject
-  include ::ActiveSupport::Dependencies::Loadable
-  include ::ActiveSupport::ForkTracker::CoreExt
-  include ::ActiveSupport::ForkTracker::CoreExtPrivate
-  include ::Kernel
-  include ::JSON::Ext::Generator::GeneratorMethods::Object
-  include ::ActiveSupport::Tryable
-  include ::PP::ObjectMixin
-  include ::ActiveSupport::ToJsonWithActiveSupportEncoder
-
-  def deep_clone; end
-
-  private
-
-  def s(*args, &blk); end
-end
-
-class Sexp < ::Array
-  def initialize(*args); end
-
-  def +(o); end
-  def /(pattern); end
-  def ==(obj); end
-  def =~(pattern); end
-  def [](a); end
-  def add(_arg0); end
-  def add_all(x); end
-  def all_structural_subhashes; end
-  def array_type?; end
-  def block_pass?; end
-  def check_line_numbers; end
-  def code_index; end
-  def comments; end
-  def comments=(_arg0); end
-  def compact; end
-  def deep_each(&block); end
-  def depth; end
-  def each_of_type(t, &b); end
-  def each_sexp; end
-  def eql?(o); end
-  def file; end
-  def file=(_arg0); end
-  def find_and_replace_all(from, to); end
-  def find_node(name, delete = T.unsafe(nil)); end
-  def find_nodes(name); end
-  def gsub(pattern, repl); end
-  def has_code?; end
-  def hash; end
-  def head; end
-  def inspect; end
-  def line(n = T.unsafe(nil)); end
-  def line=(_arg0); end
-  def line_max; end
-  def line_min; end
-  def map(&blk); end
-  def mass; end
-  def method_missing(meth, delete = T.unsafe(nil)); end
-  def modified; end
-  def modified=(_arg0); end
-  def modified?; end
-  def new(*body); end
-  def nil_line?; end
-  def node_type; end
-  def paren; end
-  def paren=(_arg0); end
-  def pretty_print(q); end
-  def pure_ruby_hash; end
-  def replace_sexp(pattern, &block); end
-  def respond_to?(msg, private = T.unsafe(nil)); end
-  def rest(from = T.unsafe(nil)); end
-  def satisfy?(pattern); end
-  def search_each(pattern, &block); end
-  def sexp_body(from = T.unsafe(nil)); end
-  def sexp_body=(v); end
-  def sexp_type; end
-  def sexp_type=(v); end
-  def split_at(n); end
-  def split_code; end
-  def structural_hash; end
-  def structure; end
-  def sub(pattern, repl); end
-  def to_a; end
-  def to_s; end
-  def to_sym; end
-  def value; end
-  def values(from = T.unsafe(nil)); end
-
-  private
-
-  def initialize_copy(o); end
-
-  class << self
-    def -(arg); end
-    def _; end
-    def ___; end
-    def all(*args); end
-    def any(*args); end
-    def atom; end
-    def child(child); end
-    def from_array(a); end
-    def include(child); end
-    def k(klass); end
-    def m(*values); end
-    def not?(arg); end
-    def q(*args); end
-    def s(*args); end
-    def t(name); end
-  end
-end
-
-class Sexp::All < ::Sexp::Matcher
-  def initialize(*options); end
-
-  def ==(o); end
-  def inspect; end
-  def options; end
-  def pretty_print(q); end
-  def satisfy?(o); end
-end
-
-class Sexp::Any < ::Sexp::Matcher
-  def initialize(*options); end
-
-  def ==(o); end
-  def inspect; end
-  def options; end
-  def pretty_print(q); end
-  def satisfy?(o); end
-end
-
-class Sexp::Atom < ::Sexp::Matcher
-  def inspect; end
-  def pretty_print(q); end
-  def satisfy?(o); end
-end
-
-class Sexp::Child < ::Sexp::Matcher
-  def initialize(child); end
-
-  def ==(o); end
-  def child; end
-  def inspect; end
-  def pretty_print(q); end
-  def satisfy?(o); end
-end
-
-class Sexp::Include < ::Sexp::Matcher
-  def initialize(value); end
-
-  def ==(o); end
-  def inspect; end
-  def pretty_print(q); end
-  def satisfy?(o); end
-  def value; end
-end
-
-class Sexp::Klass < ::Sexp::Pattern
-  def inspect; end
-  def pretty_print(q); end
-  def satisfy?(o); end
-end
-
-Sexp::MAX_INT32 = T.let(T.unsafe(nil), Integer)
-
-class Sexp::MatchCollection < ::Array
-  def /(pattern); end
-  def inspect; end
-  def pretty_print(q); end
-  def to_s; end
-end
-
-class Sexp::Matcher < ::Sexp
-  def &(other); end
-  def -@; end
-  def /(sexp); end
-  def ===(sexp); end
-  def =~(sexp); end
-  def >>(other); end
-  def greedy?; end
-  def inspect; end
-  def pretty_print(q); end
-  def satisfy?(o); end
-  def |(other); end
-
-  class << self
-    def match_subs=(o); end
-    def match_subs?; end
-    def parse(s); end
-  end
-end
-
-class Sexp::Matcher::Parser
-  def initialize(s); end
-
-  def lex(s); end
-  def next_token; end
-  def parse; end
-  def parse_cmd; end
-  def parse_list; end
-  def parse_sexp; end
-  def peek_token; end
-  def tokens; end
-  def tokens=(_arg0); end
-end
-
-Sexp::Matcher::Parser::ALLOWED = T.let(T.unsafe(nil), Array)
-Sexp::NODE_NAMES = T.let(T.unsafe(nil), Hash)
-
-class Sexp::Not < ::Sexp::Matcher
-  def initialize(value); end
-
-  def ==(o); end
-  def inspect; end
-  def pretty_print(q); end
-  def satisfy?(o); end
-  def value; end
-end
-
-class Sexp::Pattern < ::Sexp::Matcher
-  def initialize(pattern); end
-
-  def ==(o); end
-  def eql?(o); end
-  def hash; end
-  def inspect; end
-  def pattern; end
-  def pretty_print(q); end
-  def satisfy?(o); end
-end
-
-class Sexp::Remaining < ::Sexp::Matcher
-  def greedy?; end
-  def inspect; end
-  def pretty_print(q); end
-  def satisfy?(o); end
-end
-
-class Sexp::Sibling < ::Sexp::Matcher
-  def initialize(subject, sibling, distance = T.unsafe(nil)); end
-
-  def ==(o); end
-  def distance; end
-  def inspect; end
-  def pretty_print(q); end
-  def satisfy?(o); end
-  def sibling; end
-  def subject; end
-
-  private
-
-  def index_matches(pattern, o); end
-end
-
-class Sexp::Type < ::Sexp::Matcher
-  def initialize(type); end
-
-  def ==(o); end
-  def inspect; end
-  def pretty_print(q); end
-  def satisfy?(o); end
-  def sexp_type; end
-end
-
-Sexp::UNASSIGNED = T.let(T.unsafe(nil), Object)
-
-class Sexp::Wild < ::Sexp::Matcher
-  def inspect; end
-  def pretty_print(q); end
-  def satisfy?(o); end
-end
-
-class SexpInterpreter < ::SexpProcessor
-  def initialize; end
-end
-
-class SexpProcessor
-  def initialize; end
-
-  def assert_empty(meth, exp, exp_orig); end
-  def assert_type(list, typ); end
-  def auto_shift_type; end
-  def auto_shift_type=(_arg0); end
-  def context; end
-  def debug; end
-  def debug=(_arg0); end
-  def default_method; end
-  def default_method=(_arg0); end
-  def env; end
-  def error_handler(type, exp = T.unsafe(nil)); end
-  def expected; end
-  def expected=(_arg0); end
-  def in_context(type); end
-  def on_error_in(node_type, &block); end
-  def process(exp); end
-  def process_dummy(exp); end
-  def require_empty; end
-  def require_empty=(_arg0); end
-  def rewrite(exp); end
-  def scope(&block); end
-  def strict; end
-  def strict=(_arg0); end
-  def unsupported; end
-  def unsupported=(_arg0); end
-  def warn_on_default; end
-  def warn_on_default=(_arg0); end
-
-  class << self
-    def expand_dirs_to_files(*dirs); end
-    def processors; end
-    def rewriters; end
-  end
-end
-
-class SexpProcessor::Environment
-  def initialize; end
-
-  def [](name); end
-  def []=(name, val); end
-  def all; end
-  def current; end
-  def depth; end
-  def scope; end
-end
-
-SexpProcessor::VERSION = T.let(T.unsafe(nil), String)
-class SexpProcessorError < ::StandardError; end
-class SexpTypeError < ::SexpProcessorError; end
-class UnknownNodeError < ::SexpProcessorError; end
-class UnsupportedNodeError < ::SexpProcessorError; end

data/sorbet/rbi/gems/shellany@0.0.1.rbi

@@ -1,28 +0,0 @@
-# DO NOT EDIT MANUALLY
-# This is an autogenerated file for types exported from the `shellany` gem.
-# Please instead update this file by running `bin/tapioca sync`.
-
-# typed: true
-
-module Shellany; end
-
-class Shellany::Sheller
-  def initialize(*args); end
-
-  def ok?; end
-  def ran?; end
-  def run; end
-  def status; end
-  def stderr; end
-  def stdout; end
-
-  class << self
-    def _shellize_if_needed(args); end
-    def _system_with_capture(*args); end
-    def _system_with_no_capture(*args); end
-    def run(*args); end
-    def stderr(*args); end
-    def stdout(*args); end
-    def system(*args); end
-  end
-end

data/sorbet/rbi/gems/simplecov-html@0.12.3.rbi

@@ -1,89 +0,0 @@
-# DO NOT EDIT MANUALLY
-# This is an autogenerated file for types exported from the `simplecov-html` gem.
-# Please instead update this file by running `bin/tapioca sync`.
-
-# typed: true
-
-module SimpleCov
-  extend ::SimpleCov::Configuration
-
-  class << self
-    def at_exit_behavior; end
-    def clear_result; end
-    def collate(result_filenames, profile = T.unsafe(nil), ignore_timeout: T.unsafe(nil), &block); end
-    def exit_and_report_previous_error(exit_status); end
-    def exit_status_from_exception; end
-    def external_at_exit; end
-    def external_at_exit=(_arg0); end
-    def external_at_exit?; end
-    def filtered(files); end
-    def final_result_process?; end
-    def grouped(files); end
-    def load_adapter(name); end
-    def load_profile(name); end
-    def pid; end
-    def pid=(_arg0); end
-    def previous_error?(error_exit_status); end
-    def process_result(result); end
-    def process_results_and_report_error; end
-    def ready_to_process_results?; end
-    def result; end
-    def result?; end
-    def result_exit_status(result); end
-    def round_coverage(coverage); end
-    def run_exit_tasks!; end
-    def running; end
-    def running=(_arg0); end
-    def start(profile = T.unsafe(nil), &block); end
-    def wait_for_other_processes; end
-    def write_last_run(result); end
-
-    private
-
-    def adapt_coverage_result; end
-    def add_not_loaded_files(result); end
-    def initial_setup(profile, &block); end
-    def lookup_corresponding_ruby_coverage_name(criterion); end
-    def make_parallel_tests_available; end
-    def probably_running_parallel_tests?; end
-    def process_coverage_result; end
-    def remove_useless_results; end
-    def result_with_not_loaded_files; end
-    def start_coverage_measurement; end
-    def start_coverage_with_criteria; end
-  end
-end
-
-module SimpleCov::Formatter
-  class << self
-    def from_env(env); end
-  end
-end
-
-class SimpleCov::Formatter::HTMLFormatter
-  def initialize; end
-
-  def branchable_result?; end
-  def format(result); end
-  def line_status?(source_file, line); end
-  def output_message(result); end
-
-  private
-
-  def asset_output_path; end
-  def assets_path(name); end
-  def coverage_css_class(covered_percent); end
-  def covered_percent(percent); end
-  def formatted_file_list(title, source_files); end
-  def formatted_source_file(source_file); end
-  def id(source_file); end
-  def link_to_source_file(source_file); end
-  def output_path; end
-  def shortened_filename(source_file); end
-  def strength_css_class(covered_strength); end
-  def template(name); end
-  def timeago(time); end
-end
-
-SimpleCov::Formatter::HTMLFormatter::VERSION = T.let(T.unsafe(nil), String)
-SimpleCov::VERSION = T.let(T.unsafe(nil), String)