muina 0.2.7

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

@@ -0,0 +1,157 @@
+# 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

@@ -0,0 +1,359 @@
+# 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

@@ -0,0 +1,28 @@
+# 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

@@ -0,0 +1,89 @@
+# 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)