rubybreaker 0.0.1

data/lib/rubybreaker/typing/subtyping.rb

@@ -0,0 +1,480 @@
+#--
+# This file is the mechanism behind the default type system of RubyBreaker.
+# Typing works as follows:
+#
+# In RubyBreaker, there are two *kinds* of modules (classes)--Broken and
+# non-Broken. The former refers to modules that already have type
+# information, and the latter refers to ones without prior type information.
+# Although it might be optional as an add-on, RubyBreaker does not generate
+# any constraint graph to resolve subtype relations. This is the main
+# difference between Rubydust and RubyBreaker. 
+#
+# If a module is not Broken but is Breakable (i.e., monitored), then it is
+# treated as non-Broken. At the end of the execution, the module will be
+# Broken--i.e., its type information is now revealed. If the user wishes to
+# use the result of the analysis, this type information will be documented
+# and the module itself can be used as Broken in future execution. 
+#
+# Consider the following examples:
+#
+#   class Numeric
+#     typesig("+(numeric) -> numeric")
+#     ...
+#   end
+#
+#   class A
+#     include RubyBreaker::Breakable
+#     def m(x,y)
+#       return x+y
+#     end
+#   end
+#
+# a = A.new
+# assert_equal(3,a.m(1,2))
+#
+# Type of A#m will be "m(fixnum[+],numeric) -> numeric". Note that the type
+# signature for Numeric#+ is given by RubyBreaker in base.rb. The first
+# argument of A#m gets fixnum[+] since x is a Numeric and was invoked +
+# method. The second argument simply gets Numeric since no method was
+# invoked on the object but + method takes a Numeric.
+#
+# The basis of RubyBreaker typing is object subtyping. It is object typing
+# because RubyBreaker supports duck types and fusion types where individual
+# methods can be specified in the type.
+#
+
+require_relative "rubytype"
+require_relative "../type"
+
+module RubyBreaker
+  
+  # This module contains subtyping logic used in RubyBreaker. See
+  # _rubytype.rb_ for logic related to subclassing which is directly related
+  # to pure Ruby types.
+  module Typing 
+
+    include TypeDefs
+
+    private
+
+    # Thie method checks if the module has all the methods specified in
+    # meths array
+    def self.module_has_methods?(mod, meths)
+      has_all = true
+      mod_meths = mod.instance_methods
+      meths.each do |m|
+        if !mod_meths.include?(m)
+          has_all = false
+          break
+        end
+      end
+      return has_all
+    end
+    
+    # This method checks if the duck type has all the methods specified in
+    # meths array
+    def self.duck_has_methods?(duck, meths)
+      has_all = true
+      meths.each do |m|
+        if !duck.meth_names.include?(m)
+          has_all = false
+          break
+        end 
+      end
+      return has_all
+    end
+    
+    # This method checks if a duck type (LHS) is a subtype of the other
+    # type. There are a few cases to consider:
+    #
+    #   If RHS is a nominal type, every method in RHS must exist in LHS.
+    #   This is because the subtype has the same number of or more methods
+    #   than supertype.
+    #
+    #   If RHS is a duck type OR a fusion type, every method in RHS must
+    #   exist in LHS.
+    #
+    #   If RHS is an "or" type, LHS must be a subtype of one of RHS'es inner
+    #   types.
+    #
+    #   All other cases would not satisfy this subtyping relationship.
+    #
+    def self.duck_subtype_rel?(lhs,rhs)
+      return false unless lhs.kind_of?(DuckType)
+      if rhs.instance_of?(NominalType) # Don't include self type
+        # Ok, this is unlikely but we still do a check
+        is_subtype = self.duck_has_methods?(lhs, rhs.mod.instance_methods)
+      elsif rhs.kind_of?(DuckType) # duck type and fusion type
+        is_subtype = self.duck_has_methods?(lhs, rhs.meth_names)
+      elsif rhs.instance_of?(OrType) 
+        is_subtype = false
+        rhs.types.each {|rhs_inner_t|
+          # Only one has to be in subtype relation
+          if self.duck_subtype_rel?(lhs,rhs_inner_t)
+            is_subtype = true
+            break
+          end
+        }
+      else
+        is_subtype = false
+      end
+      return is_subtype
+    end
+    
+    # Procedure subtype relation check is for both methods and blocks. A
+    # typical "method" subtype is satified if
+    #
+    #   - Each argument in RHS is a subtype of its counterpart in LHS. This
+    #     includes the block argument. It's called contra-variance.
+    #   - The return in LHS is a subtype of its counterpart in RHS. It's
+    #     called co-variance.
+    #
+    # Here is the explanation to why we do this:
+    #
+    #   Assume m1 <: m2 (i.e, m1 is a subtype of m2)
+    #
+    #   Then, any place where m2 is used, m1 should be able to replace m2.
+    #   In other words, m1's arguments should accept more types than m2's
+    #   arguments. On the other hand, m1's return should be more restrictive
+    #   than m2's return to make sure it would work after the call. There it
+    #   is, you just received a mini type systems class without paying
+    #   thousands of dollars.
+    #
+    # This method also takes care of optional argument and variable length
+    # argument. This method is the ONLY one that should handle those types.
+    #
+    def self.proc_subtype_rel?(lhs, rhs)
+
+      # use kind_of? because method_subtype_rel? calls this method
+      return false unless lhs.kind_of?(BlockType) & rhs.kind_of?(BlockType)
+
+      is_subtype = true
+
+      if lhs.arg_types.length != rhs.arg_types.length
+        is_subtype = false
+      # elsif !self.subtype_rel?(rhs.blk_type, lhs.blk_type)
+      #   is_subtype = false
+      elsif !self.subtype_rel?(lhs.ret_type, rhs.ret_type)
+        is_subtype = false
+      else
+
+        # Subtyping with optional type and variable length type works as
+        # follows:
+        #
+        # (x?) <: (x) since optional argument can replace original
+        #             argument
+        #
+        # (x*) <: (x) for the same reason
+        #
+        # (x*) <: (x?) since LHS can have more arguments
+        #
+
+        is_subtype = true
+        # check arguments
+        rhs.arg_types.each_with_index {|rhs_arg,i|
+          lhs_arg = lhs.arg_types[i]
+          if lhs_arg.kind_of?(OptionalType) 
+            lhs_arg = lhs_arg.type
+            if rhs_arg.kind_of?(OptionalType)
+              rhs_arg = rhs_arg.type
+            elsif rhs_arg.kind_of?(VarLengthType)
+              is_subtype = false
+              break
+            end
+          elsif lhs_arg.kind_of?(VarLengthType)
+            lhs_arg = lhs_arg.type
+            if rhs_arg.kind_of?(OptionalType) ||
+               rhs_arg.kind_of?(VarLengthType) 
+              rhs_arg = rhs_arg.type
+            end
+          end
+          if !self.subtype_rel?(rhs_arg, lhs_arg)
+            is_subtype = false
+            break
+          end
+        }
+      end
+      return is_subtype
+    end
+    
+    # This method checks the subtype relation between two method types.
+    # There are several cases to consider:
+    # 
+    #   Case 1: If RHS is a MethodListType, we give up. It is actually
+    #           difficult to figure out the subtype relation in this case.
+    #   Case 2: If LHS is a MethodListType, only one of them has to be in 
+    #           subtype relation to RHS.
+    #   Case 3: If both are Methods, then do a typical method subtype
+    #           comparison.
+    #
+    # Note: See methodtypelist_subtype_rel? if LHS is a MethodListType.
+    #
+    def self.method_subtype_rel?(lhs,rhs)
+      is_subtype = true
+      # First check if LHS and RHS are either a method type or a method list
+      # type. Otherwise, return false.
+      if (!lhs.instance_of?(MethodType) && !lhs.instance_of?(MethodListType)) ||
+         (!rhs.instance_of?(MethodType) && !rhs.instance_of?(MethodListType))
+        is_subtype = false
+      elsif lhs.instance_of?(MethodListType)
+        # Every method type in LHS must be a subtype of RHS
+        is_subtype = true
+        lhs.types.each {|type|
+          if !self.method_subtype_rel?(type,rhs)
+            is_subtype = false
+            break
+          end
+        }
+      elsif rhs.instance_of?(MethodListType)
+        # One of the RHS has to be a supertype
+        is_subtype = false
+        rhs.types.each {|type|
+          if self.method_subtype_rel?(lhs,type)
+            is_subtype = true
+            break
+          end
+        }
+      else # ok, both are MethodType        
+        # Remember the contra-variance in arguments, co-variance in return
+        if lhs.meth_name != rhs.meth_name 
+          is_subtype = false
+        else
+          # re-use block subtype relation check
+          is_subtype = self.proc_subtype_rel?(lhs, rhs)
+        end
+      end
+      return is_subtype
+    end
+    
+    # This method checks if each method in the subtype is indeed a subtype
+    # of the counterpart in the supertype.
+    def self.methods_subtype_rel?(sub_meth_types, super_meth_types)
+      # wider means, a fewer number of methods
+      return false unless sub_meth_types.size <= super_meth_types 
+      is_subtype = true
+      sub_meth_types.each_pair { |meth_name, sub_meth_type|
+        super_meth_type = super_meth_types[meth_name]
+        if super_meth_type == nil || 
+           !method_subtype_rel?(sub_meth_type, super_meth_type)
+          is_subtype = false
+          break
+        end
+      }      
+      return is_subtype
+    end
+    
+    # This method determines if the fusion type (LHS) is a subtype of the
+    # other type (RHS). There are many cases to consider:
+    #
+    #   If LHS is Broken, there are several cases to consider:
+    #   
+    #     If RHS is a nominal type, there are a few cases to consider:
+    #
+    #       If LHS is a subclass of RHS, then there is a subtype relation
+    #
+    #       If RHS is Broken, each method in RHS must be a supertype of the
+    #         counterpart in LHS.
+    #
+    #       Otherwise, each in LHS must exist in RHS.
+    #
+    #     If RHS is a fusion type, ther eare a few cases to consider:
+    #
+    #       If LHS is a subclass of RHS, then LHS is a subtype
+    #       
+    #       If RHS is Broken, each method in RHS must be a supertype of the
+    #         counterpart in LHS.
+    #
+    #       Otherwise, every method in RHS must exist in LHS.
+    #
+    #     If RHS is a duck type, then every method in RHS must exist in LHS.
+    #
+    #     Otherwise, there is no subtype relation.
+    #
+    #   If LHS is not Broken, subtyping satifies only when LHS has all
+    #   methods in RHS
+    #
+    def self.fusion_subtype_rel?(lhs,rhs)
+      return false unless lhs.kind_of?(FusionType)
+      if lhs.mod.kind_of?(Broken)        
+        if rhs.instance_of?(NominalType) # don't include self type
+          if RubyTypeUtils.subclass_rel?(lhs.mod, rhs.mod)
+            is_subtype = true
+          elsif rhs.mod.kind_of?(Broken)
+            # then do a type check for each method
+            lhs_meths = Inspect.inspect_all(lhs.mod)
+            rhs_meths = Inspect.inspect_all(rhs.mod)
+            is_subtype = self.methods_subtype_rel?(lhs_meths,rhs_meths)
+          else 
+            # if not, the only possible way is if lhs has all the rhs' methods
+            is_subtype = self.duck_has_methods?(lhs, rhs.mod.instance_methods)
+          end
+        elsif rhs.instance_of?(FusionType)
+          if RubyTypeUtils.subclass_rel?(lhs.mod, rhs.mod)
+            is_subtype = true
+          elsif rhs.mod.kind_of?(Broken)
+            # then do a type check for each method
+            lhs_meths = Inspect.inspect_all(lhs.mod)
+            rhs_meths = Inspect.inspect_meths(rhs.mod, lhs.meths.keys)
+            is_subtype = self.methods_subtype_rel?(lhs_meths,rhs_meths)
+          else
+            is_subtype = self.duck_has_methods?(lhs, rhs.meth_names)
+          end            
+        elsif rhs.instance_of?(DuckType)
+          is_subtype = self.duck_has_methods?(lhs, rhs.meth_names)
+        else
+          is_subtype = false
+        end
+      else
+        # lhs is not broken, so only thing we can do is method check
+        is_subtype = self.duck_subtype_rel?(lhs, rhs)
+      end 
+      return is_subtype
+    end
+    
+		# Self type works exactly like nominal type except that, if RHS is a
+		# self type, then only self type is allowed in LHS.
+		#
+		# For example, consider you are inside Fixnum
+		#
+		#   self <: Fixnum
+		#   self <: Numeric
+		#   self <: Object
+		#   self <: self
+		#
+		#   but,
+		#
+		#   Fixnum !<: self
+		#
+		def self.self_subtype_rel?(lhs,rhs)
+			self.nominal_subtype_rel?(lhs,rhs)
+		end
+
+    # This method checks the subtype relation when LHS is a nominal type.
+    # There are several cases to consider:
+    #
+    #   my_class <: your_class  is true only if MyClass and YourClass have
+    #                           (Ruby) subclass relationship.
+    #
+    #   my_class <: a[foo]      is true if
+    #
+    #     (1) MyClass is a subtype of A or
+    #     (2) Both MyClass and A are Broken and every method in MyClass is a
+    #         subtype of the counterpart method in A. (This should be rare).
+    #         Or,
+    #     (3) A are not Broken and MyClass has all methods of A.
+    #   
+    # 
+    def self.nominal_subtype_rel?(lhs,rhs)
+      return false unless lhs.kind_of?(NominalType) # Self type is a nominal type
+      if rhs.instance_of?(SelfType)
+				is_subtype = lhs.instance_of?(SelfType)
+			elsif rhs.instance_of?(NominalType) # don't include self type
+        is_subtype = RubyTypeUtils.subclass_rel?(lhs.mod, rhs.mod)
+      elsif rhs.instance_of?(FusionType)
+        # If RHS is a superclass or included module then true
+        # If both LHS and RHS are Broken, do a subtype check on each method
+        # If only RHS is broken, look at each method's type
+        # If RHS is not broken, sorry no subtype relationship
+        if RubyTypeUtils.subclass_rel?(lhs.mod, rhs.mod)
+          is_subtype = true
+        elsif lhs.kind_of?(Broken) && rhs.kind_of?(Broken)
+          is_subtype = true
+          lhs_methods = lhs.mod.instance_methods
+          rhs.meth_names.each {|m| 
+            lhs_m = Inspector.inspect_meth(lhs, m)
+            rhs_m = Inspector.inspect_meth(rhs, m)
+            if !meth_subtype_rel?(lhs_m, rhs_m)
+              is_subtype = false
+              break
+            end
+          }
+        else
+          is_subtype = self.module_has_methods?(lhs.mod, rhs.meth_names)
+        end 
+      elsif rhs.instance_of?(DuckType)
+        # Do simple method existence check since there is no nominal type to
+        # inspect.
+        is_subtype = self.module_has_methods?(lhs.mod, rhs.meth_names)
+      else
+        # No other possibility of subtype relation
+        is_subtype = false
+      end 
+      return is_subtype
+    end
+
+    # If OrType is on the LHS, the only possible subtype relation is if each
+    # child type in OrType is a subtype of RHS. For example,
+    #  
+    #   numeric or string <: object
+    #
+    # is true only if numeric is subype of object and string is subtype of
+    # object.
+    # 
+    def self.or_subtype_rel?(lhs,rhs)
+      return false if !lhs.kind_of?(OrType)
+      is_subtype = true
+      # Each type in LHS has to be a subtype of RHS
+      lhs.types.each do |t|
+        if !self.subtype_rel?(t,rhs)
+          is_subtype = false
+          break
+        end
+      end
+      return is_subtype
+    end
+
+    public
+    
+    # This method determines if one type is a subtype of another. This check
+    # is for RubyBreaker defined types. See _TypeDefs_ module for more
+    # detail.
+    #
+    # lhs:: The allegedly "subtype"
+    # rhs:: The allegedly "supertype"
+    #
+    def self.subtype_rel?(lhs, rhs)
+
+      # Don't even bother if they are same object or syntactically
+      # equivalent. NOTE: would this really help improve performance???
+      return true if (lhs.equal?(rhs) || lhs.eql?(rhs))
+
+      # Break down the cases by what LHS is.
+      is_subtype = false
+      if lhs.instance_of?(NilType)
+        is_subtype = rhs.instance_of?(NilType)
+      elsif lhs.instance_of?(AnyType)
+        is_subtype = true 
+			elsif lhs.instance_of?(SelfType)
+				is_subtype = self.self_subtype_rel?(lhs,rhs)
+      elsif lhs.instance_of?(NominalType)
+        is_subtype = self.nominal_subtype_rel?(lhs,rhs)
+      elsif lhs.instance_of?(FusionType)
+        is_subtype = self.fusion_subtype_rel?(lhs,rhs)
+      elsif lhs.instance_of?(DuckType)
+        is_subtype = self.duck_subtype_rel?(lhs,rhs)
+      elsif lhs.instance_of?(MethodType)
+        is_subtype = self.method_subtype_rel?(lhs,rhs)
+      elsif lhs.instance_of?(OrType)
+        is_subtype = self.or_subtype_rel?(lhs,rhs)
+      elsif lhs.instance_of?(BlockType)
+        is_subtype = self.proc_subtype_rel?(lhs,rhs)
+      elsif lhs.instance_of?(MethodListType)
+        is_subtype = self.method_subtype_rel?(lhs,rhs)
+      end
+      return is_subtype
+    end
+
+  end
+  
+  #--
+  # Reopening the class to allow subtyping more accessible.
+  class TypeDefs::Type
+
+    # This is a shorthand for calling Typing.subtype_rel? 
+    def subtype_of?(rhs)
+      return Typing.subtype_rel?(self,rhs)
+    end
+  end
+
+end
+

data/lib/rubybreaker/typing.rb

@@ -0,0 +1,3 @@
+require_relative "type/type_comparer"
+require_relative "typing/subtyping"
+

data/lib/rubybreaker/util.rb

@@ -0,0 +1,31 @@
+#--
+# This file contains utility functions that are useful for RubyBreaker. They
+# may have been taken from other sources.
+
+module RubyBreaker
+
+  module Utilities
+
+    # File activesupport/lib/active_support/inflector/methods.rb, line 48
+    def self.underscore(camel_cased_word)
+      word = camel_cased_word.to_s.dup
+      word.gsub!(/::/, '/')
+      word.gsub!(/([A-Z]+)([A-Z][a-z])/,'\1_\2')
+      word.gsub!(/([a-z\d])([A-Z])/,'\1_\2')
+      word.tr!("-", "_")
+      word.downcase!
+      word
+    end
+    
+		# File activesupport/lib/active_support/inflector/methods.rb
+    def self.camelize(lower_case_and_underscored_word, first_letter_in_uppercase = true)
+      if first_letter_in_uppercase
+        lower_case_and_underscored_word.to_s.gsub(/\/(.?)/) { "::#{$1.upcase}" }.gsub(/(?:^|_)(.)/) { $1.upcase }
+      else  
+        lower_case_and_underscored_word.to_s[0].chr.downcase + camelize(lower_case_and_underscored_word)[1..-1]
+      end   
+    end    
+
+  end
+
+end

data/lib/rubybreaker.rb

@@ -0,0 +1,193 @@
+#--
+# This library dynamically profiles and resolves the type information
+# observed at runtime and generates type annotation at the end.  It can be
+# run as either a stand-alone script or as a Ruby library. 
+
+require_relative "rubybreaker/runtime"
+require_relative "rubybreaker/test"
+
+# RubyBreaker is a dynamic instrumentation and monitoring tool that
+# documents type information automatically.
+module RubyBreaker
+
+  # This constant contains the copyright information.
+  COPYRIGHT = "Copyright (c) 2012 Jong-hoon (David) An. All Rights Reserved."
+
+  # Options for RubyBreaker
+  OPTIONS = {
+    :debug => false,               # in debug mode?
+    :verbose => true,              # in verbose mode?
+    :mode => :lib,                 # bin or lib?
+    :io_file => nil,               # generate input/output other than default?
+    :append => true,               # append to the input file (if there is)?
+    :stdout => true,               # also display on the screen?
+    :rubylib => true,              # include core ruby library documentation?
+  }
+
+  # Broken takes higher precedence than Breakable. Once a module is
+  # "declared" to be Broken, it cannot be Breakable. 
+  #
+  # TODO: In future, there will be a module to support both states.
+
+  # This array lists modules/classes that will be monitored.
+  BREAKABLE = []
+
+  # This array lists modules/classes that are actually instrumented with a
+  # monitor.
+  INSTALLED = []
+  
+  # This array lists "broken" classes--i.e., with type signatures
+  BROKEN = []
+
+  # This array lists monitored modules/classes that are outputed.
+  DOCUMENTED = []
+
+  # Extension used by RubyBreaker for output/input
+  EXTENSION = "rubybreaker"
+
+  # This module has a set of entry points to the program and misc. methods
+  # for running RubyBreaker.
+  module Main
+
+    include TypeDefs
+    include Runtime
+
+    public
+
+    # This method is the trigger point to install a monitor in each
+    # module/class.
+    def self.setup()
+
+      BREAKABLE.each do |m|
+        # Avoid already installed module or now Broken module. Remember,
+        # once a module is a declared to be Broken, it wins. Broken modules
+        # cannot be Breakable!
+        unless INSTALLED.include?(m) || BROKEN.include?(m)
+          MonitorInstaller.install_module_monitor(m,true)
+          INSTALLED << m
+        end
+      end
+
+      # At the end, we generate an output of the type information.
+      at_exit do 
+        self.output
+      end
+
+    end
+
+    # Reads the input file if specified or exists
+    def self.input()
+      return unless OPTIONS[:io_file] && File.exist?(OPTIONS[:io_file])
+      eval "load \"#{OPTIONS[:io_file]}\"", TOPLEVEL_BINDING
+    end
+
+    # This method will generate the output 
+    def self.output()
+
+      io_exist = OPTIONS[:io_file] && File.exist?(OPTIONS[:io_file])
+
+      str = ""
+      pp = PrettyPrint.new(str)
+
+      # Document each module that was monitored
+      INSTALLED.each do |mod|
+
+        # Skip it if we already have seen it
+        next if DOCUMENTED.include?(mod)
+        DOCUMENTED << mod 
+
+        pp.text("class #{mod.to_s}")
+        pp.nest(2) do 
+          pp.breakable("")
+          pp.text("include RubyBreaker::Broken")
+          meth_type_map = Inspector.inspect_all(mod)
+          meth_type_map.each { |meth_name, meth_type|
+            case meth_type
+            when MethodType
+              pp.breakable()
+              pp.text("typesig(\"")
+              TypeUnparser.unparse_pp(pp,meth_type)
+              pp.text("\")")
+            when MethodListType
+              meth_type.types.each { |real_meth_type|
+                pp.breakable()
+                pp.text("typesig(\"")
+                TypeUnparser.unparse_pp(pp,real_meth_type)
+                pp.text("\")")
+              }
+            else
+              # Can't happen
+            end
+          }
+        end
+        pp.breakable() 
+        pp.text("end")
+        pp.breakable()
+      end
+      pp.flush
+
+      # First, display the result on the stdout if set
+      puts str if OPTIONS[:stdout]
+
+      # If this was a library mode run, exit now. 
+      return if OPTIONS[:mode] == :lib
+
+      # Append the result to the input file (or create a new file)
+      open(OPTIONS[:io_file],"a") do |f|
+        unless io_exist 
+          f.puts "# This file is auto-generated by RubyBreaker"
+          # f.puts "require \"rubybreaker\""
+        end
+        f.puts str
+      end
+
+    end
+
+    # This method will run the input file
+    def self.run()
+
+      # First, take care of the program file.
+
+      argv0 = ARGV[0]
+      prog_file = argv0
+      prog_file = File.expand_path(prog_file)
+
+      # It is ok to omit .rb extension. So try to see if prog_file.rb exists
+      if !File.exist?(prog_file) && !File.extname(prog_file) == ".rb" 
+        prog_file = "#{prog_file}.rb"
+      end 
+
+      if !File.exist?(prog_file)
+        puts "ERROR: '#{argv0}' is an invalid file."
+        exit(1)
+      end
+
+      # Then, input/output file if specified
+      if !OPTIONS[:io_file] || OPTIONS[:io_file].empty?
+        OPTIONS[:io_file] = "#{File.basename(argv0, ".rb")}.#{EXTENSION}"
+      end
+      OPTIONS[:io_file] = File.absolute_path(OPTIONS[:io_file])
+
+      if OPTIONS[:rubylib]
+        # Load the core library type documentation
+        eval("require \"#{File.dirname(__FILE__)}/rubybreaker/rubylib\"", TOPLEVEL_BINDING)
+      end
+
+      # Read the input file first (as it might contain type documentation
+      # already)
+      Main.input()
+
+      # Finally, require the program file! Let it run! Wheeee!
+      eval "require '#{prog_file}'", TOPLEVEL_BINDING
+
+    end
+
+  end
+
+  # Just redirecting
+  def self.monitor()
+    Main.setup()
+  end
+
+end
+