sord 0.9.0 → 3.0.0.beta.2

data/sorbet/rbi/gems/parlour.rbi

@@ -1,214 +0,0 @@
-# This file is autogenerated. Do not edit it by hand. Regenerate it with:
-#   srb rbi gems
-
-# typed: true
-#
-# If you would like to make changes to this file, great! Please create the gem's shim here:
-#
-#   https://github.com/sorbet/sorbet-typed/new/master?filename=lib/parlour/all/parlour.rbi
-#
-# parlour-0.6.1
-module Parlour
-end
-module Kernel
-end
-class Parlour::Plugin
-  def generate(*args, &blk); end
-  def initialize(*args, &blk); end
-  def self.inherited(*args, &blk); end
-  def self.method_added(name); end
-  def self.registered_plugins(*args, &blk); end
-  def self.run_plugins(*args, &blk); end
-  def self.singleton_method_added(name); end
-  extend T::Helpers
-  extend T::InterfaceWrapper::Helpers
-  extend T::Private::Abstract::Hooks
-  extend T::Sig
-end
-class Parlour::RbiGenerator
-  def current_plugin(*args, &blk); end
-  def current_plugin=(arg0); end
-  def initialize(*args, &blk); end
-  def options(*args, &blk); end
-  def rbi(*args, &blk); end
-  def root(*args, &blk); end
-  def self.method_added(name); end
-  def self.singleton_method_added(name); end
-  extend T::Sig
-end
-class Parlour::RbiGenerator::Parameter
-  def ==(*args, &blk); end
-  def default(*args, &blk); end
-  def initialize(*args, &blk); end
-  def kind(*args, &blk); end
-  def name(*args, &blk); end
-  def name_without_kind(*args, &blk); end
-  def self.method_added(name); end
-  def self.singleton_method_added(name); end
-  def to_def_param(*args, &blk); end
-  def to_sig_param(*args, &blk); end
-  def type(*args, &blk); end
-  extend T::Sig
-end
-class Parlour::RbiGenerator::RbiObject
-  def add_comment(*args, &blk); end
-  def add_comments(*args, &blk); end
-  def comments(*args, &blk); end
-  def describe(*args, &blk); end
-  def generate_comments(*args, &blk); end
-  def generate_rbi(*args, &blk); end
-  def generated_by(*args, &blk); end
-  def generator(*args, &blk); end
-  def initialize(*args, &blk); end
-  def merge_into_self(*args, &blk); end
-  def mergeable?(*args, &blk); end
-  def name(*args, &blk); end
-  def self.method_added(name); end
-  def self.singleton_method_added(name); end
-  extend T::Helpers
-  extend T::InterfaceWrapper::Helpers
-  extend T::Private::Abstract::Hooks
-  extend T::Sig
-end
-class Parlour::RbiGenerator::Method < Parlour::RbiGenerator::RbiObject
-  def ==(*args, &blk); end
-  def abstract(*args, &blk); end
-  def class_method(*args, &blk); end
-  def describe(*args, &blk); end
-  def generate_definition(*args, &blk); end
-  def generate_rbi(*args, &blk); end
-  def implementation(*args, &blk); end
-  def initialize(*args, &blk); end
-  def merge_into_self(*args, &blk); end
-  def mergeable?(*args, &blk); end
-  def overridable(*args, &blk); end
-  def override(*args, &blk); end
-  def parameters(*args, &blk); end
-  def qualifiers(*args, &blk); end
-  def return_type(*args, &blk); end
-  def self.method_added(name); end
-  def self.singleton_method_added(name); end
-  extend T::Sig
-end
-class Parlour::RbiGenerator::Attribute < Parlour::RbiGenerator::Method
-  def generate_definition(*args, &blk); end
-  def initialize(*args, &blk); end
-  def kind(*args, &blk); end
-  def self.method_added(name); end
-  def self.singleton_method_added(name); end
-end
-class Parlour::RbiGenerator::Arbitrary < Parlour::RbiGenerator::RbiObject
-  def ==(*args, &blk); end
-  def code(*args, &blk); end
-  def code=(arg0); end
-  def describe(*args, &blk); end
-  def generate_rbi(*args, &blk); end
-  def initialize(*args, &blk); end
-  def merge_into_self(*args, &blk); end
-  def mergeable?(*args, &blk); end
-  def self.method_added(name); end
-  def self.singleton_method_added(name); end
-end
-class Parlour::RbiGenerator::Options
-  def break_params(*args, &blk); end
-  def indented(*args, &blk); end
-  def initialize(*args, &blk); end
-  def self.method_added(name); end
-  def self.singleton_method_added(name); end
-  def tab_size(*args, &blk); end
-  extend T::Sig
-end
-class Parlour::RbiGenerator::Include < Parlour::RbiGenerator::RbiObject
-  def ==(*args, &blk); end
-  def describe(*args, &blk); end
-  def generate_rbi(*args, &blk); end
-  def initialize(*args, &blk); end
-  def merge_into_self(*args, &blk); end
-  def mergeable?(*args, &blk); end
-  def self.method_added(name); end
-  def self.singleton_method_added(name); end
-end
-class Parlour::RbiGenerator::Extend < Parlour::RbiGenerator::RbiObject
-  def ==(*args, &blk); end
-  def describe(*args, &blk); end
-  def generate_rbi(*args, &blk); end
-  def initialize(*args, &blk); end
-  def merge_into_self(*args, &blk); end
-  def mergeable?(*args, &blk); end
-  def self.method_added(name); end
-  def self.singleton_method_added(name); end
-end
-class Parlour::RbiGenerator::Constant < Parlour::RbiGenerator::RbiObject
-  def ==(*args, &blk); end
-  def describe(*args, &blk); end
-  def generate_rbi(*args, &blk); end
-  def initialize(*args, &blk); end
-  def merge_into_self(*args, &blk); end
-  def mergeable?(*args, &blk); end
-  def self.method_added(name); end
-  def self.singleton_method_added(name); end
-  def value(*args, &blk); end
-end
-class Parlour::RbiGenerator::Namespace < Parlour::RbiGenerator::RbiObject
-  def add_comment_to_next_child(*args, &blk); end
-  def children(*args, &blk); end
-  def constants(*args, &blk); end
-  def create_arbitrary(code:, &block); end
-  def create_attr(name, kind:, type:, &block); end
-  def create_attr_accessor(name, type:, &block); end
-  def create_attr_reader(name, type:, &block); end
-  def create_attr_writer(name, type:, &block); end
-  def create_attribute(name, kind:, type:, &block); end
-  def create_class(*args, &blk); end
-  def create_constant(*args, &blk); end
-  def create_extend(*args, &blk); end
-  def create_extends(*args, &blk); end
-  def create_include(*args, &blk); end
-  def create_includes(*args, &blk); end
-  def create_method(*args, &blk); end
-  def create_module(*args, &blk); end
-  def describe(*args, &blk); end
-  def extends(*args, &blk); end
-  def generate_body(*args, &blk); end
-  def generate_rbi(*args, &blk); end
-  def includes(*args, &blk); end
-  def initialize(*args, &blk); end
-  def merge_into_self(*args, &blk); end
-  def mergeable?(*args, &blk); end
-  def move_next_comments(*args, &blk); end
-  def path(*args, &blk); end
-  def self.method_added(name); end
-  def self.singleton_method_added(name); end
-  extend T::Sig
-end
-class Parlour::RbiGenerator::ModuleNamespace < Parlour::RbiGenerator::Namespace
-  def describe(*args, &blk); end
-  def generate_rbi(*args, &blk); end
-  def initialize(*args, &blk); end
-  def interface(*args, &blk); end
-  def merge_into_self(*args, &blk); end
-  def mergeable?(*args, &blk); end
-  def self.method_added(name); end
-  def self.singleton_method_added(name); end
-  extend T::Sig
-end
-class Parlour::RbiGenerator::ClassNamespace < Parlour::RbiGenerator::Namespace
-  def abstract(*args, &blk); end
-  def describe(*args, &blk); end
-  def generate_rbi(*args, &blk); end
-  def initialize(*args, &blk); end
-  def merge_into_self(*args, &blk); end
-  def mergeable?(*args, &blk); end
-  def self.method_added(name); end
-  def self.singleton_method_added(name); end
-  def superclass(*args, &blk); end
-  extend T::Sig
-end
-class Parlour::ConflictResolver
-  def all_eql?(*args, &blk); end
-  def resolve_conflicts(*args, &blk); end
-  def self.method_added(name); end
-  def self.singleton_method_added(name); end
-  def single_type_of_array(*args, &blk); end
-  extend T::Sig
-end

data/sorbet/rbi/gems/rainbow.rbi

@@ -1,117 +0,0 @@
-# This file is autogenerated. Do not edit it by hand. Regenerate it with:
-#   srb rbi gems
-
-# typed: true
-#
-# If you would like to make changes to this file, great! Please create the gem's shim here:
-#
-#   https://github.com/sorbet/sorbet-typed/new/master?filename=lib/rainbow/all/rainbow.rbi
-#
-# rainbow-3.0.0
-module Rainbow
-  def self.enabled; end
-  def self.enabled=(value); end
-  def self.global; end
-  def self.new; end
-  def self.uncolor(string); end
-end
-class Rainbow::StringUtils
-  def self.uncolor(string); end
-  def self.wrap_with_sgr(string, codes); end
-end
-module Rainbow::X11ColorNames
-end
-class Rainbow::Color
-  def ground; end
-  def self.build(ground, values); end
-  def self.parse_hex_color(hex); end
-end
-class Rainbow::Color::Indexed < Rainbow::Color
-  def codes; end
-  def initialize(ground, num); end
-  def num; end
-end
-class Rainbow::Color::Named < Rainbow::Color::Indexed
-  def initialize(ground, name); end
-  def self.color_names; end
-  def self.valid_names; end
-end
-class Rainbow::Color::RGB < Rainbow::Color::Indexed
-  def b; end
-  def code_from_rgb; end
-  def codes; end
-  def g; end
-  def initialize(ground, *values); end
-  def r; end
-  def self.to_ansi_domain(value); end
-end
-class Rainbow::Color::X11Named < Rainbow::Color::RGB
-  def initialize(ground, name); end
-  def self.color_names; end
-  def self.valid_names; end
-  include Rainbow::X11ColorNames
-end
-class Rainbow::Presenter < String
-  def background(*values); end
-  def bg(*values); end
-  def black; end
-  def blink; end
-  def blue; end
-  def bold; end
-  def bright; end
-  def color(*values); end
-  def cyan; end
-  def dark; end
-  def faint; end
-  def fg(*values); end
-  def foreground(*values); end
-  def green; end
-  def hide; end
-  def inverse; end
-  def italic; end
-  def magenta; end
-  def method_missing(method_name, *args); end
-  def red; end
-  def reset; end
-  def respond_to_missing?(method_name, *args); end
-  def underline; end
-  def white; end
-  def wrap_with_sgr(codes); end
-  def yellow; end
-end
-class Rainbow::NullPresenter < String
-  def background(*_values); end
-  def bg(*_values); end
-  def black; end
-  def blink; end
-  def blue; end
-  def bold; end
-  def bright; end
-  def color(*_values); end
-  def cyan; end
-  def dark; end
-  def faint; end
-  def fg(*_values); end
-  def foreground(*_values); end
-  def green; end
-  def hide; end
-  def inverse; end
-  def italic; end
-  def magenta; end
-  def method_missing(method_name, *args); end
-  def red; end
-  def reset; end
-  def respond_to_missing?(method_name, *args); end
-  def underline; end
-  def white; end
-  def yellow; end
-end
-class Rainbow::Wrapper
-  def enabled; end
-  def enabled=(arg0); end
-  def initialize(enabled = nil); end
-  def wrap(string); end
-end
-class Object < BasicObject
-  def Rainbow(string); end
-end

data/sorbet/rbi/gems/rake.rbi

@@ -1,643 +0,0 @@
-# This file is autogenerated. Do not edit it by hand. Regenerate it with:
-#   srb rbi gems
-
-# typed: true
-#
-# If you would like to make changes to this file, great! Please create the gem's shim here:
-#
-#   https://github.com/sorbet/sorbet-typed/new/master?filename=lib/rake/all/rake.rbi
-#
-# rake-10.5.0
-module Rake
-  def self.add_rakelib(*files); end
-  def self.application; end
-  def self.application=(app); end
-  def self.each_dir_parent(dir); end
-  def self.from_pathname(path); end
-  def self.load_rakefile(path); end
-  def self.original_dir; end
-  def self.suggested_thread_count; end
-  extend Rake::FileUtilsExt
-end
-module Rake::Version
-end
-class Module
-  def rake_extension(method); end
-end
-class String
-  def ext(newext = nil); end
-  def pathmap(spec = nil, &block); end
-  def pathmap_explode; end
-  def pathmap_partial(n); end
-  def pathmap_replace(patterns, &block); end
-end
-class Rake::EarlyTime
-  def <=>(other); end
-  def self.allocate; end
-  def self.instance; end
-  def self.new(*arg0); end
-  def to_s; end
-  extend Singleton::SingletonClassMethods
-  include Comparable
-  include Singleton
-end
-class Rake::LateTime
-  def <=>(other); end
-  def self.allocate; end
-  def self.instance; end
-  def self.new(*arg0); end
-  def to_s; end
-  extend Singleton::SingletonClassMethods
-  include Comparable
-  include Singleton
-end
-module Rake::AltSystem
-  def `(arg0); end
-  def backticks(arg0); end
-  def self.`(arg0); end
-  def self.backticks(arg0); end
-  def self.define_module_function(name, &block); end
-  def self.system(*arg0); end
-  def system(*arg0); end
-end
-module Rake::Win32
-  def self.normalize(path); end
-  def self.rake_system(*cmd); end
-  def self.win32_system_dir; end
-  def self.windows?; end
-end
-class Rake::Win32::Win32HomeError < RuntimeError
-end
-class Rake::LinkedList
-  def ==(other); end
-  def conj(item); end
-  def each; end
-  def empty?; end
-  def head; end
-  def initialize(head, tail = nil); end
-  def inspect; end
-  def self.cons(head, tail); end
-  def self.empty; end
-  def self.make(*args); end
-  def tail; end
-  def to_s; end
-  include Enumerable
-end
-class Rake::LinkedList::EmptyLinkedList < Rake::LinkedList
-  def empty?; end
-  def initialize; end
-  def self.cons(head, tail); end
-end
-class Rake::CpuCounter
-  def count; end
-  def count_with_default(default = nil); end
-  def self.count; end
-end
-class Rake::Scope < Rake::LinkedList
-  def path; end
-  def path_with_task_name(task_name); end
-  def trim(n); end
-end
-class Rake::Scope::EmptyScope < Rake::LinkedList::EmptyLinkedList
-  def path; end
-  def path_with_task_name(task_name); end
-end
-class Rake::TaskArgumentError < ArgumentError
-end
-class Rake::RuleRecursionOverflowError < StandardError
-  def add_target(target); end
-  def initialize(*args); end
-  def message; end
-end
-module Rake::TaskManager
-  def [](task_name, scopes = nil); end
-  def add_location(task); end
-  def attempt_rule(task_name, args, extensions, block, level); end
-  def clear; end
-  def create_rule(*args, &block); end
-  def current_scope; end
-  def define_task(task_class, *args, &block); end
-  def enhance_with_matching_rule(task_name, level = nil); end
-  def find_location; end
-  def generate_name; end
-  def get_description(task); end
-  def in_namespace(name); end
-  def initialize; end
-  def intern(task_class, task_name); end
-  def last_comment; end
-  def last_description; end
-  def last_description=(arg0); end
-  def lookup(task_name, initial_scope = nil); end
-  def lookup_in_scope(name, scope); end
-  def make_sources(task_name, extensions); end
-  def resolve_args(args); end
-  def resolve_args_with_dependencies(args, hash); end
-  def resolve_args_without_dependencies(args); end
-  def self.record_task_metadata; end
-  def self.record_task_metadata=(arg0); end
-  def synthesize_file_task(task_name); end
-  def tasks; end
-  def tasks_in_scope(scope); end
-  def trace_rule(level, message); end
-end
-module Rake::Cloneable
-  def initialize_copy(source); end
-end
-module FileUtils
-  def create_shell_runner(cmd); end
-  def rake_system(*cmd); end
-  def ruby(*args, &block); end
-  def safe_ln(*args); end
-  def set_verbose_option(options); end
-  def sh(*cmd, &block); end
-  def split_all(path); end
-end
-module Rake::FileUtilsExt
-  def cd(*args, &block); end
-  def chdir(*args, &block); end
-  def chmod(*args, &block); end
-  def chmod_R(*args, &block); end
-  def chown(*args, &block); end
-  def chown_R(*args, &block); end
-  def copy(*args, &block); end
-  def cp(*args, &block); end
-  def cp_lr(*args, &block); end
-  def cp_r(*args, &block); end
-  def install(*args, &block); end
-  def link(*args, &block); end
-  def ln(*args, &block); end
-  def ln_s(*args, &block); end
-  def ln_sf(*args, &block); end
-  def makedirs(*args, &block); end
-  def mkdir(*args, &block); end
-  def mkdir_p(*args, &block); end
-  def mkpath(*args, &block); end
-  def move(*args, &block); end
-  def mv(*args, &block); end
-  def nowrite(value = nil); end
-  def rake_check_options(options, *optdecl); end
-  def rake_merge_option(args, defaults); end
-  def rake_output_message(message); end
-  def remove(*args, &block); end
-  def rm(*args, &block); end
-  def rm_f(*args, &block); end
-  def rm_r(*args, &block); end
-  def rm_rf(*args, &block); end
-  def rmdir(*args, &block); end
-  def rmtree(*args, &block); end
-  def ruby(*args, &block); end
-  def safe_unlink(*args, &block); end
-  def self.nowrite_flag; end
-  def self.nowrite_flag=(arg0); end
-  def self.verbose_flag; end
-  def self.verbose_flag=(arg0); end
-  def sh(*args, &block); end
-  def symlink(*args, &block); end
-  def touch(*args, &block); end
-  def verbose(value = nil); end
-  def when_writing(msg = nil); end
-  extend Rake::FileUtilsExt
-  include FileUtils
-end
-class Rake::FileList
-  def &(*args, &block); end
-  def *(other); end
-  def +(*args, &block); end
-  def -(*args, &block); end
-  def <<(obj); end
-  def <=>(*args, &block); end
-  def ==(array); end
-  def [](*args, &block); end
-  def []=(*args, &block); end
-  def add(*filenames); end
-  def add_matching(pattern); end
-  def all?(*args, &block); end
-  def any?(*args, &block); end
-  def append(*args, &block); end
-  def assoc(*args, &block); end
-  def at(*args, &block); end
-  def bsearch(*args, &block); end
-  def bsearch_index(*args, &block); end
-  def chain(*args, &block); end
-  def chunk(*args, &block); end
-  def chunk_while(*args, &block); end
-  def clear(*args, &block); end
-  def clear_exclude; end
-  def collect!(*args, &block); end
-  def collect(*args, &block); end
-  def collect_concat(*args, &block); end
-  def combination(*args, &block); end
-  def compact!(*args, &block); end
-  def compact(*args, &block); end
-  def concat(*args, &block); end
-  def count(*args, &block); end
-  def cycle(*args, &block); end
-  def delete(*args, &block); end
-  def delete_at(*args, &block); end
-  def delete_if(*args, &block); end
-  def detect(*args, &block); end
-  def difference(*args, &block); end
-  def dig(*args, &block); end
-  def drop(*args, &block); end
-  def drop_while(*args, &block); end
-  def each(*args, &block); end
-  def each_cons(*args, &block); end
-  def each_entry(*args, &block); end
-  def each_index(*args, &block); end
-  def each_slice(*args, &block); end
-  def each_with_index(*args, &block); end
-  def each_with_object(*args, &block); end
-  def egrep(pattern, *options); end
-  def empty?(*args, &block); end
-  def entries(*args, &block); end
-  def exclude(*patterns, &block); end
-  def excluded_from_list?(fn); end
-  def existing!; end
-  def existing; end
-  def ext(newext = nil); end
-  def fetch(*args, &block); end
-  def fill(*args, &block); end
-  def filter!(*args, &block); end
-  def filter(*args, &block); end
-  def find(*args, &block); end
-  def find_all(*args, &block); end
-  def find_index(*args, &block); end
-  def first(*args, &block); end
-  def flat_map(*args, &block); end
-  def flatten!(*args, &block); end
-  def flatten(*args, &block); end
-  def grep(*args, &block); end
-  def grep_v(*args, &block); end
-  def group_by(*args, &block); end
-  def gsub!(pat, rep); end
-  def gsub(pat, rep); end
-  def import(array); end
-  def include(*filenames); end
-  def include?(*args, &block); end
-  def index(*args, &block); end
-  def initialize(*patterns); end
-  def inject(*args, &block); end
-  def insert(*args, &block); end
-  def inspect(*args, &block); end
-  def is_a?(klass); end
-  def join(*args, &block); end
-  def keep_if(*args, &block); end
-  def kind_of?(klass); end
-  def last(*args, &block); end
-  def lazy(*args, &block); end
-  def length(*args, &block); end
-  def map!(*args, &block); end
-  def map(*args, &block); end
-  def max(*args, &block); end
-  def max_by(*args, &block); end
-  def member?(*args, &block); end
-  def min(*args, &block); end
-  def min_by(*args, &block); end
-  def minmax(*args, &block); end
-  def minmax_by(*args, &block); end
-  def none?(*args, &block); end
-  def one?(*args, &block); end
-  def pack(*args, &block); end
-  def partition(&block); end
-  def pathmap(spec = nil); end
-  def permutation(*args, &block); end
-  def pop(*args, &block); end
-  def prepend(*args, &block); end
-  def product(*args, &block); end
-  def push(*args, &block); end
-  def rassoc(*args, &block); end
-  def reduce(*args, &block); end
-  def reject!(*args, &block); end
-  def reject(*args, &block); end
-  def repeated_combination(*args, &block); end
-  def repeated_permutation(*args, &block); end
-  def replace(*args, &block); end
-  def resolve; end
-  def resolve_add(fn); end
-  def resolve_exclude; end
-  def reverse!(*args, &block); end
-  def reverse(*args, &block); end
-  def reverse_each(*args, &block); end
-  def rindex(*args, &block); end
-  def rotate!(*args, &block); end
-  def rotate(*args, &block); end
-  def sample(*args, &block); end
-  def select!(*args, &block); end
-  def select(*args, &block); end
-  def self.[](*args); end
-  def self.glob(pattern, *args); end
-  def shelljoin(*args, &block); end
-  def shift(*args, &block); end
-  def shuffle!(*args, &block); end
-  def shuffle(*args, &block); end
-  def size(*args, &block); end
-  def slice!(*args, &block); end
-  def slice(*args, &block); end
-  def slice_after(*args, &block); end
-  def slice_before(*args, &block); end
-  def slice_when(*args, &block); end
-  def sort!(*args, &block); end
-  def sort(*args, &block); end
-  def sort_by!(*args, &block); end
-  def sort_by(*args, &block); end
-  def sub!(pat, rep); end
-  def sub(pat, rep); end
-  def sum(*args, &block); end
-  def take(*args, &block); end
-  def take_while(*args, &block); end
-  def to_a; end
-  def to_ary; end
-  def to_h(*args, &block); end
-  def to_s; end
-  def to_set(*args, &block); end
-  def transpose(*args, &block); end
-  def union(*args, &block); end
-  def uniq!(*args, &block); end
-  def uniq(*args, &block); end
-  def unshift(*args, &block); end
-  def values_at(*args, &block); end
-  def zip(*args, &block); end
-  def |(*args, &block); end
-  include Rake::Cloneable
-end
-class Rake::Promise
-  def chore; end
-  def complete?; end
-  def discard; end
-  def error?; end
-  def initialize(args, &block); end
-  def recorder; end
-  def recorder=(arg0); end
-  def result?; end
-  def stat(*args); end
-  def value; end
-  def work; end
-end
-class Rake::ThreadPool
-  def __queue__; end
-  def future(*args, &block); end
-  def gather_history; end
-  def history; end
-  def initialize(thread_count); end
-  def join; end
-  def process_queue_item; end
-  def safe_thread_count; end
-  def start_thread; end
-  def stat(event, data = nil); end
-  def statistics; end
-end
-module Rake::PrivateReader
-  def self.included(base); end
-end
-module Rake::PrivateReader::ClassMethods
-  def private_reader(*names); end
-end
-class Rake::ThreadHistoryDisplay
-  def initialize(stats); end
-  def items; end
-  def rename(hash, key, renames); end
-  def show; end
-  def stats; end
-  def threads; end
-  extend Rake::PrivateReader::ClassMethods
-  include Rake::PrivateReader
-end
-module Rake::TraceOutput
-  def trace_on(out, *strings); end
-end
-class Rake::CommandLineOptionError < StandardError
-end
-class Rake::Application
-  def add_import(fn); end
-  def add_loader(ext, loader); end
-  def collect_command_line_tasks(args); end
-  def default_task_name; end
-  def deprecate(old_usage, new_usage, call_site); end
-  def display_error_message(ex); end
-  def display_exception_backtrace(ex); end
-  def display_exception_details(ex); end
-  def display_exception_message_details(ex); end
-  def display_prerequisites; end
-  def display_tasks_and_comments; end
-  def dynamic_width; end
-  def dynamic_width_stty; end
-  def dynamic_width_tput; end
-  def exit_because_of_exception(ex); end
-  def find_rakefile_location; end
-  def glob(path, &block); end
-  def handle_options; end
-  def has_cause?(ex); end
-  def has_chain?(exception); end
-  def have_rakefile; end
-  def init(app_name = nil); end
-  def initialize; end
-  def invoke_task(task_string); end
-  def load_imports; end
-  def load_rakefile; end
-  def name; end
-  def options; end
-  def original_dir; end
-  def parse_task_string(string); end
-  def print_rakefile_directory(location); end
-  def rake_require(file_name, paths = nil, loaded = nil); end
-  def rakefile; end
-  def rakefile_location(backtrace = nil); end
-  def raw_load_rakefile; end
-  def run; end
-  def run_with_threads; end
-  def select_tasks_to_show(options, show_tasks, value); end
-  def select_trace_output(options, trace_option, value); end
-  def sort_options(options); end
-  def standard_exception_handling; end
-  def standard_rake_options; end
-  def standard_system_dir; end
-  def system_dir; end
-  def terminal_columns; end
-  def terminal_columns=(arg0); end
-  def terminal_width; end
-  def thread_pool; end
-  def top_level; end
-  def top_level_tasks; end
-  def trace(*strings); end
-  def truncate(string, width); end
-  def truncate_output?; end
-  def tty_output=(tty_output_state); end
-  def tty_output?; end
-  def unix?; end
-  def windows?; end
-  include Rake::TaskManager
-  include Rake::TraceOutput
-end
-class Rake::PseudoStatus
-  def >>(n); end
-  def exited?; end
-  def exitstatus; end
-  def initialize(code = nil); end
-  def stopped?; end
-  def to_i; end
-end
-class Rake::TaskArguments
-  def [](index); end
-  def each(&block); end
-  def extras; end
-  def has_key?(key); end
-  def initialize(names, values, parent = nil); end
-  def inspect; end
-  def lookup(name); end
-  def method_missing(sym, *args); end
-  def names; end
-  def new_scope(names); end
-  def to_a; end
-  def to_hash; end
-  def to_s; end
-  def values_at(*keys); end
-  def with_defaults(defaults); end
-  include Enumerable
-end
-class Rake::InvocationChain < Rake::LinkedList
-  def append(invocation); end
-  def member?(invocation); end
-  def prefix; end
-  def self.append(invocation, chain); end
-  def to_s; end
-end
-class Rake::InvocationChain::EmptyInvocationChain < Rake::LinkedList::EmptyLinkedList
-  def append(invocation); end
-  def member?(obj); end
-  def to_s; end
-end
-module Rake::InvocationExceptionMixin
-  def chain; end
-  def chain=(value); end
-end
-class Rake::Task
-  def actions; end
-  def add_chain_to(exception, new_chain); end
-  def add_comment(comment); end
-  def add_description(description); end
-  def all_prerequisite_tasks; end
-  def application; end
-  def application=(arg0); end
-  def arg_description; end
-  def arg_names; end
-  def clear; end
-  def clear_actions; end
-  def clear_comments; end
-  def clear_prerequisites; end
-  def collect_prerequisites(seen); end
-  def comment; end
-  def comment=(comment); end
-  def enhance(deps = nil, &block); end
-  def execute(args = nil); end
-  def first_sentence(string); end
-  def format_trace_flags; end
-  def full_comment; end
-  def initialize(task_name, app); end
-  def inspect; end
-  def investigation; end
-  def invoke(*args); end
-  def invoke_prerequisites(task_args, invocation_chain); end
-  def invoke_prerequisites_concurrently(task_args, invocation_chain); end
-  def invoke_with_call_chain(task_args, invocation_chain); end
-  def locations; end
-  def lookup_prerequisite(prerequisite_name); end
-  def name; end
-  def name_with_args; end
-  def needed?; end
-  def prerequisite_tasks; end
-  def prerequisites; end
-  def reenable; end
-  def scope; end
-  def self.[](task_name); end
-  def self.clear; end
-  def self.create_rule(*args, &block); end
-  def self.define_task(*args, &block); end
-  def self.scope_name(scope, task_name); end
-  def self.task_defined?(task_name); end
-  def self.tasks; end
-  def set_arg_names(args); end
-  def source; end
-  def sources; end
-  def sources=(arg0); end
-  def timestamp; end
-  def to_s; end
-  def transform_comments(separator, &block); end
-end
-class Rake::FileTask < Rake::Task
-  def needed?; end
-  def out_of_date?(stamp); end
-  def self.scope_name(scope, task_name); end
-  def timestamp; end
-end
-class Rake::FileCreationTask < Rake::FileTask
-  def needed?; end
-  def timestamp; end
-end
-class Rake::MultiTask < Rake::Task
-  def invoke_prerequisites(task_args, invocation_chain); end
-end
-module Rake::DSL
-  def cd(*args, &block); end
-  def chdir(*args, &block); end
-  def chmod(*args, &block); end
-  def chmod_R(*args, &block); end
-  def chown(*args, &block); end
-  def chown_R(*args, &block); end
-  def copy(*args, &block); end
-  def cp(*args, &block); end
-  def cp_lr(*args, &block); end
-  def cp_r(*args, &block); end
-  def desc(description); end
-  def directory(*args, &block); end
-  def file(*args, &block); end
-  def file_create(*args, &block); end
-  def import(*fns); end
-  def install(*args, &block); end
-  def link(*args, &block); end
-  def ln(*args, &block); end
-  def ln_s(*args, &block); end
-  def ln_sf(*args, &block); end
-  def makedirs(*args, &block); end
-  def mkdir(*args, &block); end
-  def mkdir_p(*args, &block); end
-  def mkpath(*args, &block); end
-  def move(*args, &block); end
-  def multitask(*args, &block); end
-  def mv(*args, &block); end
-  def namespace(name = nil, &block); end
-  def nowrite(value = nil); end
-  def rake_check_options(options, *optdecl); end
-  def rake_merge_option(args, defaults); end
-  def rake_output_message(message); end
-  def remove(*args, &block); end
-  def rm(*args, &block); end
-  def rm_f(*args, &block); end
-  def rm_r(*args, &block); end
-  def rm_rf(*args, &block); end
-  def rmdir(*args, &block); end
-  def rmtree(*args, &block); end
-  def ruby(*args, &block); end
-  def rule(*args, &block); end
-  def safe_ln(*args); end
-  def safe_unlink(*args, &block); end
-  def sh(*args, &block); end
-  def split_all(path); end
-  def symlink(*args, &block); end
-  def task(*args, &block); end
-  def touch(*args, &block); end
-  def verbose(value = nil); end
-  def when_writing(msg = nil); end
-  include Rake::FileUtilsExt
-end
-class Rake::DefaultLoader
-  def load(fn); end
-end
-class Rake::NameSpace
-  def [](name); end
-  def initialize(task_manager, scope_list); end
-  def scope; end
-  def tasks; end
-end
-module Rake::Backtrace
-  def self.collapse(backtrace); end
-end