parlour 0.1.0 → 0.1.1

data/lib/parlour/rbi_generator/module_namespace.rb

@@ -0,0 +1,68 @@
+# typed: true
+module Parlour
+  class RbiGenerator
+    class ModuleNamespace < Namespace
+      extend T::Sig
+
+      sig do
+        params(
+          name: String,
+          interface: T::Boolean,
+          block: T.nilable(T.proc.params(x: ClassNamespace).void)
+        ).void
+      end
+      def initialize(name, interface, &block)
+        super(&block)
+        @name = name
+        @interface = interface
+      end
+
+      sig do
+        override.params(
+          indent_level: Integer,
+          options: Options
+        ).returns(T::Array[String])
+      end
+      def generate_rbi(indent_level, options)        
+        lines = []
+        lines << options.indented(indent_level, "module #{name}")
+        lines += [options.indented(indent_level + 1, "interface!"), ""] if interface
+        lines += super(indent_level + 1, options)
+        lines << options.indented(indent_level, "end")
+      end
+
+      sig { returns(String) }
+      attr_reader :name
+
+      sig { returns(T::Boolean) }
+      attr_reader :interface
+
+      sig do
+        override.params(
+          others: T::Array[RbiGenerator::RbiObject]
+        ).returns(T::Boolean)
+      end
+      def mergeable?(others)
+        others = T.cast(others, T::Array[RbiGenerator::ModuleNamespace]) rescue (return false)
+        all = others + [self]
+
+        all.map(&:interface).uniq.length == 1
+      end
+
+      sig do 
+        override.params(
+          others: T::Array[RbiGenerator::RbiObject]
+        ).void
+      end
+      def merge_into_self(others)
+        others.each do |other|
+          other = T.cast(other, ModuleNamespace)
+
+          other.children.each { |c| children << c }
+          other.extends.each { |e| extends << e }
+          other.includes.each { |i| includes << i }
+        end
+      end
+    end
+  end
+end

data/lib/parlour/rbi_generator/namespace.rb

@@ -0,0 +1,144 @@
+# typed: true
+module Parlour
+  class RbiGenerator
+    class Namespace
+      extend T::Sig
+
+      include RbiObject
+
+      sig do
+        implementation.overridable.params(
+          indent_level: Integer,
+          options: Options
+        ).returns(T::Array[String])
+      end
+      def generate_rbi(indent_level, options)
+        result = []
+
+        if includes.any? || extends.any?
+          result += includes.map do |i|
+            options.indented(indent_level, "include #{i}")
+          end
+          result += extends.map do |e|
+            options.indented(indent_level, "extend #{e}")
+          end
+          result << ""
+        end
+
+        first, *rest = children
+        return [] unless first
+
+        result += first.generate_rbi(indent_level, options) + T.must(rest)
+          .map { |obj| obj.generate_rbi(indent_level, options) }
+          .map { |lines| [""] + lines }
+          .flatten
+
+        result
+      end
+
+      sig { params(block: T.nilable(T.proc.params(x: Namespace).void)).void }
+      def initialize(&block)
+        @children = []
+        @extends = []
+        @includes = []
+        yield_self(&block)
+      end
+
+      sig { returns(T::Array[RbiObject]) }
+      attr_reader :children
+
+      sig { returns(T::Array[String]) }
+      attr_reader :extends
+
+      sig { returns(T::Array[String]) }
+      attr_reader :includes
+
+      sig do
+        params(
+          name: String,
+          superclass: T.nilable(String),
+          abstract: T::Boolean,
+          block: T.nilable(T.proc.params(x: ClassNamespace).void)
+        ).returns(ClassNamespace)
+      end
+      def create_class(name, superclass: nil, abstract: false, &block)
+        new_class = ClassNamespace.new(name, superclass, abstract, &block)
+        children << new_class
+        new_class
+      end
+
+      sig do
+        params(
+          name: String,
+          interface: T::Boolean,
+          block: T.nilable(T.proc.params(x: ClassNamespace).void)
+        ).returns(ModuleNamespace)
+      end
+      def create_module(name, interface: false, &block)
+        new_module = ModuleNamespace.new(name, interface, &block)
+        children << new_module
+        new_module
+      end
+
+      sig do
+        params(
+          name: String,
+          parameters: T::Array[Parameter],
+          return_type: T.nilable(String),
+          abstract: T::Boolean,
+          implementation: T::Boolean,
+          override: T::Boolean,
+          overridable: T::Boolean,
+          class_method: T::Boolean
+        ).returns(Method)
+      end
+      def create_method(name, parameters, return_type = nil, abstract: false, implementation: false, override: false, overridable: false, class_method: false)
+        new_method = RbiGenerator::Method.new(
+          name,
+          parameters,
+          return_type,
+          abstract: abstract,
+          implementation: implementation, 
+          override: override,
+          overridable: overridable,
+          class_method: class_method
+        )
+        children << new_method
+        new_method
+      end
+
+      sig { params(name: String).void }
+      def add_extend(name)
+        extends << name
+      end
+      sig { params(name: String).void }
+      def add_include(name)
+        includes << name
+      end
+
+      sig do
+        implementation.overridable.params(
+          others: T::Array[RbiGenerator::RbiObject]
+        ).returns(T::Boolean)
+      end
+      def mergeable?(others)
+        true
+      end
+
+      sig do 
+        implementation.overridable.params(
+          others: T::Array[RbiGenerator::RbiObject]
+        ).void
+      end
+      def merge_into_self(others)
+        others.each do |other|
+          other = T.cast(other, Namespace)
+
+          other.children.each { |c| children << c }
+          other.extends.each { |e| extends << e }
+          other.includes.each { |i| includes << i }
+        end
+      end
+    end
+  end
+end

data/lib/parlour/rbi_generator/options.rb

@@ -0,0 +1,25 @@
+# typed: true
+module Parlour
+  class RbiGenerator
+    class Options
+      extend T::Sig
+
+      sig { params(break_params: Integer, tab_size: Integer).void }
+      def initialize(break_params:, tab_size:)
+        @break_params = break_params
+        @tab_size = tab_size
+      end
+      
+      sig { returns(Integer) }
+      attr_reader :break_params
+
+      sig { returns(Integer) }
+      attr_reader :tab_size
+
+      sig { params(level: Integer, str: String).returns(String) }
+      def indented(level, str)
+        " " * (level * tab_size) + str
+      end
+    end
+  end
+end

data/lib/parlour/rbi_generator/parameter.rb

@@ -0,0 +1,81 @@
+# typed: true
+module Parlour
+  class RbiGenerator
+    class Parameter
+      extend T::Sig
+
+      sig do
+        params(
+          name: String,
+          type: T.nilable(String),
+          default: T.nilable(String)
+        ).void
+      end
+      def initialize(name, type: nil, default: nil)
+        @name = name
+
+        prefix = /^(\*\*|\*|\&)?/.match(name)&.captures&.first || ''
+        @kind = PREFIXES.rassoc(prefix).first
+
+        @kind = :keyword if kind == :normal && name.end_with?(':')
+
+        @type = type
+        @default = default
+      end
+
+      sig { params(other: Object).returns(T::Boolean) }
+      def ==(other)
+        Parameter === other &&
+          name    == other.name &&
+          kind    == other.kind &&
+          type    == other.type &&
+          default == other.default
+      end
+
+      sig { returns(String) }
+      attr_reader :name
+
+      sig { returns(String) }
+      def name_without_kind
+        return T.must(name[0..-2]) if kind == :keyword
+
+        prefix_match = /^(\*\*|\*|\&)?[a-zA-Z_]/.match(name)
+        raise 'unknown prefix' unless prefix_match
+        prefix = prefix_match.captures.first || ''
+        T.must(name[prefix.length..-1])
+      end
+
+      sig { returns(T.nilable(String)) }
+      attr_reader :type
+
+      sig { returns(T.nilable(String)) }
+      attr_reader :default
+
+      sig { returns(Symbol) }
+      attr_reader :kind
+
+      sig { returns(String) }
+      def to_def_param
+        if default.nil?
+          "#{name}"
+        elsif !default.nil? && kind == :keyword
+          "#{name} #{default}"
+        else
+          "#{name} = #{default}"
+        end
+      end
+
+      sig { returns(String) }
+      def to_sig_param
+        "#{name_without_kind}: #{type || 'T.untyped'}"
+      end
+
+      PREFIXES = {
+        normal: '',
+        splat: '*',
+        double_splat: '**',
+        block: '&'
+      }.freeze
+    end
+  end
+end

data/lib/parlour/rbi_generator/rbi_object.rb

@@ -0,0 +1,32 @@
+# typed: true
+module Parlour
+  class RbiGenerator
+    module RbiObject
+      extend T::Helpers
+      extend T::Sig
+      interface!
+
+      sig do
+        abstract.params(
+          indent_level: Integer,
+          options: Options
+        ).returns(T::Array[String])
+      end
+      def generate_rbi(indent_level, options); end
+
+      sig do
+        abstract.params(
+          others: T::Array[RbiGenerator::RbiObject]
+        ).returns(T::Boolean)
+      end
+      def mergeable?(others); end
+
+      sig do 
+        abstract.params(
+          others: T::Array[RbiGenerator::RbiObject]
+        ).void
+      end
+      def merge_into_self(others); end
+    end
+  end
+end

data/lib/parlour/version.rb

@@ -1,3 +1,4 @@
+# typed: strong
 module Parlour
-  VERSION = "0.1.0"
+  VERSION = '0.1.1'
 end

data/parlour.gemspec

@@ -7,9 +7,9 @@ Gem::Specification.new do |spec|
   spec.name          = "parlour"
   spec.version       = Parlour::VERSION
   spec.authors       = ["Aaron Christiansen"]
-  spec.email         = ["aaronc20000@gmail.com"]
+  spec.email         = ["hello@aaronc.cc"]
 
-  spec.summary       = %q{Will be something for Sorbet}
+  spec.summary       = %q{An RBI generator}
   spec.homepage      = "https://github.com/AaronC81/parlour"
   spec.license       = "MIT"
 
@@ -22,7 +22,11 @@ Gem::Specification.new do |spec|
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
 
+  spec.add_dependency "sorbet-runtime"
+
   spec.add_development_dependency "bundler", "~> 2.0"
   spec.add_development_dependency "rake", "~> 10.0"
   spec.add_development_dependency "rspec", "~> 3.0"
+  spec.add_development_dependency "sorbet"
+  spec.add_development_dependency "simplecov"
 end

data/sorbet/config

@@ -0,0 +1,2 @@
+--dir
+.

data/sorbet/rbi/gems/rake.rbi

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