sord 0.10.0 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ca2e726bf2e1ec8e4baa524ae7111296a18068d1a5d63959abc967bcc01b2651
-  data.tar.gz: 6e71373e3eb57ed98395aa0ecca42a5da3cd45ae5212712de151230f0cfa0870
+  metadata.gz: 86ef36c437c7c9a02b0cc18fddd6c11253f4d0be6f9d68283c8039cfd69d310e
+  data.tar.gz: 38f53748c92a22b44745d8fff1dfca5fe41ee4b4424b3c61c63853d07eb5d396
 SHA512:
-  metadata.gz: 04c0bc1d1b2a74d5d428530cfafe9d21686be9d2bfb032379e7a705478f16ba53c027d85736d4f378104bb443d99706feca733ee1d465b2bf59200bfc61dbd70
-  data.tar.gz: 11a6fab0f1bd64e0c3b454bfa4c32ec84cc36b9f7dc2d30d726ab950e1091a0a53328b81666d3767adde2b6ff733af46647e4129a747a15f55db9a39227df8e9
+  metadata.gz: 3359eca2a431b010b81c9920f6dd2705422df7ee3b47ab014caf63d498168945e14e5b3ba789ab08dff2b1a081682ae0d05de3c1796d2ac948778ca1a8a8c9c5
+  data.tar.gz: 92ef1253541f9d4a837486fe51a886341251db0acc145d224048e8e3d94368beb86e59edab5a3638e486bb877f65a188da38c1543a2708cac10b14eef81e5da1

data/CHANGELOG.md

@@ -3,6 +3,21 @@ All notable changes to this project will be documented in this file.
 
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
 
+## [1.0.0] - 2020-02-16
+### Added
+- Added the `--skip-constants` flag to avoid generating RBIs for constants.
+
+### Changed
+- Parlour 2.0.0 is now being used.
+
+### Fixed
+- Fixed a bug where blank parameters were sometimes treated like non-blank
+parameters.
+- Fixed parameter order sometimes being incorrect.
+- Fixed multiline parameter lists sometimes generating invalid RBIs.
+- Multiline comments are now generated correctly.
+- Fixed an incorrect README link.
+
 ## [0.10.0] - 2019-09-14
 ### Added
 - Comments in RBIs are now converted from YARD into Markdown format, making them

data/README.md

@@ -2,7 +2,7 @@
 
 ## Overview
 
-Sord is a [**So**rbet](https://sorbet.org) and [YA**RD**](https://sorbet.org)
+Sord is a [**So**rbet](https://sorbet.org) and [YA**RD**](https://yardoc.org/)
 crossover. It can automatically generate Sorbet type signatures files by
 looking at the types specified in YARD documentation comments.
 

data/Rakefile

@@ -10,6 +10,7 @@ REPOS = {
   bundler: 'https://github.com/bundler/bundler',
   discordrb: 'https://github.com/meew0/discordrb',
   gitlab: 'https://github.com/NARKOZ/gitlab',
+  'graphql-ruby': 'https://github.com/rmosolgo/graphql-ruby',
   haml: 'https://github.com/haml/haml',
   oga: 'https://gitlab.com/yorickpeterse/oga',
   rouge: 'https://github.com/rouge-ruby/rouge',

data/exe/sord

@@ -19,6 +19,7 @@ command :gen do |c|
   c.option '--exclude-messages STRING', String, 'Blacklists a comma-separated string of log message types'
   c.option '--include-messages STRING', String, 'Whitelists a comma-separated string of log message types'
   c.option '--keep-original-comments', 'Retains original YARD comments rather than converting them to Markdown'
+  c.option '--skip-constants', 'Excludes constants from generated RBI'
 
   c.action do |args, options|
     options.default(
@@ -29,7 +30,8 @@ command :gen do |c|
       replace_unresolved_with_untyped: false,
       exclude_messages: nil,
       include_messages: nil,
-      keep_original_comments: false
+      keep_original_comments: false,
+      skip_constants: false
     )
 
     if args.length != 1

data/lib/sord/rbi_generator.rb

@@ -39,6 +39,7 @@ module Sord
       @replace_errors_with_untyped = options[:replace_errors_with_untyped]
       @replace_unresolved_with_untyped = options[:replace_unresolved_with_untyped]
       @keep_original_comments = options[:keep_original_comments]
+      @skip_constants = options[:skip_constants]
 
       # Hook the logger so that messages are added as comments to the RBI file
       Logging.add_hook do |type, msg, item|
@@ -109,6 +110,8 @@ module Sord
           next
         end
 
+        # Sort parameters
+        meth.parameters.reverse.sort! { |pair1, pair2| sort_params(pair1, pair2) }
         # This is better than iterating over YARD's "@param" tags directly 
         # because it includes parameters without documentation
         # (The gsubs allow for better splat-argument compatibility)
@@ -235,10 +238,10 @@ module Sord
               # Output params in the form of:
               # _@param_ `foo` — Lorem ipsum.
               # _@param_ `foo`
-              if param.text.nil?
+              if param.text.nil? || param.text == ''
                 docs_array << "_@param_ `#{param.name}`"
               else
-                docs_array << "_@param_ `#{param.name}` — #{param.text}"
+                docs_array << "_@param_ `#{param.name}` — #{param.text.gsub("\n", " ")}"
               end
             end
 
@@ -297,6 +300,9 @@ module Sord
               end
             end
 
+            # fix: yard text may contains multiple line. should deal \n.
+            # else generate text will be multiple line and only first line is commented
+            docs_array = docs_array.flat_map {|line| line.empty? ? [""] : line.split("\n")}
             m.add_comments(docs_array)
           end
         end
@@ -321,7 +327,7 @@ module Sord
 
       add_mixins(item)
       add_methods(item)
-      add_constants(item)
+      add_constants(item) unless @skip_constants
 
       item.children.select { |x| [:class, :module].include?(x.type) }
         .each { |child| add_namespace(child) }
@@ -387,5 +393,45 @@ module Sord
         puts "         #{line}"
       end
     end
+
+    # Given two pairs of arrays representing method parameters, in the form
+    # of ["variable_name", "default_value"], sort the parameters so they're
+    # valid for Sorbet. Sorbet requires that, e.g. required kwargs go before
+    # optional kwargs.
+    #
+    # @param [Array] pair1
+    # @param [Array] pair2
+    # @return Integer
+    def sort_params(pair1, pair2)
+      pair1_type, pair2_type = [pair1, pair2].map do |pair|
+        if pair[0].start_with?('&')
+          :blk
+        elsif pair[0].start_with?('**')
+          :doublesplat
+        elsif pair[0].start_with?('*')
+          :splat
+        elsif !pair[0].end_with?(':') && pair[1].nil?
+          :required_ordered_param
+        elsif !pair[0].end_with?(':') && !pair[1].nil?
+          :optional_ordered_param
+        elsif pair[0].end_with?(':') && pair[1].nil?
+          :required_kwarg
+        elsif pair[0].end_with?(':') && !pair[1].nil?
+          :optional_kwarg
+        end
+      end
+
+      pair_type_order = {
+        required_ordered_param: 1,
+        optional_ordered_param: 2,
+        splat: 3,
+        required_kwarg: 4,
+        optional_kwarg: 5,
+        doublesplat: 6,
+        blk: 7
+      }
+
+      return pair_type_order[pair1_type] <=> pair_type_order[pair2_type]
+    end
   end
 end

data/lib/sord/version.rb

@@ -1,4 +1,4 @@
 # typed: strong
 module Sord
-  VERSION = '0.10.0'
+  VERSION = '1.0.0'
 end

data/sord.gemspec

@@ -16,7 +16,7 @@ Gem::Specification.new do |spec|
   # Specify which files should be added to the gem when it is released.
   # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
   spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
-    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features|sorbet)/}) }
   end
   spec.bindir        = "exe"
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
@@ -24,8 +24,8 @@ Gem::Specification.new do |spec|
 
   spec.add_dependency 'yard'
   spec.add_dependency 'sorbet-runtime'
-  spec.add_dependency 'commander', '~> 4.4'
-  spec.add_dependency 'parlour', '~> 0.8.0'
+  spec.add_dependency 'commander', '~> 4.5'
+  spec.add_dependency 'parlour', '~> 2.0'
 
   spec.add_development_dependency "bundler", "~> 2.0"
   spec.add_development_dependency "rake", "~> 10.0"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sord
 version: !ruby/object:Gem::Version
-  version: 0.10.0
+  version: 1.0.0
 platform: ruby
 authors:
 - Aaron Christiansen
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-09-14 00:00:00.000000000 Z
+date: 2020-02-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: yard
@@ -44,28 +44,28 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '4.4'
+        version: '4.5'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '4.4'
+        version: '4.5'
 - !ruby/object:Gem::Dependency
   name: parlour
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.8.0
+        version: '2.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.8.0
+        version: '2.0'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -165,25 +165,6 @@ files:
 - lib/sord/type_converter.rb
 - lib/sord/version.rb
 - rbi/sord.rbi
-- sorbet/config
-- sorbet/rbi/gems/docile.rbi
-- sorbet/rbi/gems/parlour.rbi
-- sorbet/rbi/gems/rainbow.rbi
-- sorbet/rbi/gems/rake.rbi
-- sorbet/rbi/gems/rspec-core.rbi
-- sorbet/rbi/gems/rspec-expectations.rbi
-- sorbet/rbi/gems/rspec-mocks.rbi
-- sorbet/rbi/gems/rspec-support.rbi
-- sorbet/rbi/gems/rspec.rbi
-- sorbet/rbi/gems/simplecov-html.rbi
-- sorbet/rbi/gems/simplecov.rbi
-- sorbet/rbi/gems/sorbet-runtime.rbi
-- sorbet/rbi/gems/yard.rbi
-- sorbet/rbi/hidden-definitions/errors.txt
-- sorbet/rbi/hidden-definitions/hidden.rbi
-- sorbet/rbi/sorbet-typed/lib/bundler/all/bundler.rbi
-- sorbet/rbi/sorbet-typed/lib/ruby/all/open3.rbi
-- sorbet/rbi/sorbet-typed/lib/ruby/all/resolv.rbi
 - sord.gemspec
 homepage: https://github.com/AaronC81/sord
 licenses:
@@ -204,7 +185,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
+rubygems_version: 3.1.2
 signing_key: 
 specification_version: 4
 summary: Generate Sorbet RBI files from YARD documentation

data/sorbet/rbi/gems/docile.rbi

@@ -1,31 +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/docile/all/docile.rbi
-#
-# docile-1.3.2
-module Docile
-  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
-  def self.dsl_eval(dsl, *args, &block); end
-  def self.dsl_eval_immutable(dsl, *args, &block); end
-  def self.dsl_eval_with_block_return(dsl, *args, &block); end
-  extend Docile::Execution
-end
-module Docile::Execution
-  def exec_in_proxy_context(dsl, proxy_type, *args, &block); end
-  def self.exec_in_proxy_context(dsl, proxy_type, *args, &block); end
-end
-class Docile::FallbackContextProxy
-  def initialize(receiver, fallback); end
-  def instance_variables; end
-  def method_missing(method, *args, &block); end
-end
-class Docile::ChainingFallbackContextProxy < Docile::FallbackContextProxy
-  def method_missing(method, *args, &block); end
-end

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