rackjour 0.1.8

data/vendor/gems/gems/ruby-debug-0.10.3/cli/ruby-debug/commands/frame.rb

@@ -0,0 +1,301 @@
+module Debugger
+  # Mix-in module to assist in command parsing.
+  module FrameFunctions # :nodoc:
+    def adjust_frame(frame_pos, absolute, context=@state.context)
+      @state.frame_pos = 0 if context != @state.context
+      if absolute
+        if frame_pos < 0
+          abs_frame_pos = context.stack_size + frame_pos
+        else
+          abs_frame_pos = frame_pos
+        end
+      else
+        abs_frame_pos = @state.frame_pos + frame_pos
+      end
+
+      if abs_frame_pos >= context.stack_size then
+        errmsg "Adjusting would put us beyond the oldest (initial) frame.\n"
+        return
+      elsif abs_frame_pos < 0 then
+        errmsg "Adjusting would put us beyond the newest (innermost) frame.\n"
+        return
+      end
+      if @state.frame_pos != abs_frame_pos then
+        @state.previous_line = nil
+        @state.frame_pos = abs_frame_pos
+      end
+      
+      @state.file = context.frame_file(@state.frame_pos)
+      @state.line = context.frame_line(@state.frame_pos)
+      
+      print_frame(@state.frame_pos, true)
+    end
+    
+    def get_frame_call(prefix, pos, context)
+      id = context.frame_method(pos)
+      klass = context.frame_class(pos)
+      call_str = ""
+      if id
+        args = context.frame_args(pos)
+        locals = context.frame_locals(pos)
+        if Command.settings[:callstyle] != :short && klass
+          if Command.settings[:callstyle] == :tracked
+            arg_info = context.frame_args_info(pos)
+          end
+          call_str << "#{klass}." 
+        end
+        call_str << id.id2name
+        if args.any?
+          call_str << "("
+          args.each_with_index do |name, i|
+            case Command.settings[:callstyle] 
+            when :short
+              call_str += "%s, " % [name]
+            when :last
+              klass = locals[name].class
+              if klass.inspect.size > 20+3
+                klass = klass.inspect[0..20]+"..." 
+              end
+              call_str += "%s#%s, " % [name, klass]
+            when :tracked
+              if arg_info && arg_info.size > i
+                call_str += "#{name}: #{arg_info[i].inspect}, "
+              else
+                call_str += "%s, " % name
+              end
+            end
+            if call_str.size > self.class.settings[:width] - prefix.size
+              # Strip off trailing ', ' if any but add stuff for later trunc
+              call_str[-2..-1] = ",...XX"
+              break
+            end
+          end
+          call_str[-2..-1] = ")" # Strip off trailing ', ' if any 
+        end
+      end
+      return call_str
+    end
+
+    def print_frame(pos, adjust = false, context=@state.context)
+      file = context.frame_file(pos)
+      line = context.frame_line(pos)
+      klass = context.frame_class(pos)
+
+      unless Command.settings[:full_path]
+        path_components = file.split(/[\\\/]/)
+        if path_components.size > 3
+          path_components[0...-3] = '...'
+          file = path_components.join(File::ALT_SEPARATOR || File::SEPARATOR)
+        end
+      end
+
+      frame_num = "#%d " % pos
+      call_str = get_frame_call(frame_num, pos, context)
+      file_line = "at line %s:%d\n" % [CommandProcessor.canonic_file(file), line]
+      print frame_num
+      unless call_str.empty?
+        print call_str
+        print ' '
+        if call_str.size + frame_num.size + file_line.size > self.class.settings[:width]
+          print "\n       "
+        end
+      end
+      print file_line
+      if ENV['EMACS'] && adjust
+        fmt = (Debugger.annotate.to_i > 1 ?
+               "\032\032source %s:%d\n" : "\032\032%s:%d\n")
+        print fmt % [CommandProcessor.canonic_file(file), line]
+      end
+    end
+
+    # Check if call stack is truncated.  This can happen if
+    # Debugger.start is not called low enough in the call stack. An
+    # array of additional callstack lines from caller is returned if
+    # definitely truncated, false if not, and nil if we don't know.
+    #
+    # We determine truncation based on a passed in sentinal set via
+    # caller which can be nil.  
+    #
+    # First we see if we can find our position in caller. If so, then
+    # we compare context position to that in caller using sentinal
+    # as a place to start ignoring additional caller entries. sentinal
+    # is set by rdebug, but if it's not set, i.e. nil then additional
+    # entries are presumably ones that we haven't recorded in context
+    def truncated_callstack?(context, sentinal=nil, cs=caller)
+      recorded_size = context.stack_size
+      to_find_fl = "#{context.frame_file(0)}:#{context.frame_line(0)}"
+      top_discard = false
+      cs.each_with_index do |fl, i|
+        fl.gsub!(/in `.*'$/, '')
+        fl.gsub!(/:$/, '')
+        if fl == to_find_fl
+          top_discard = i
+          break 
+        end
+      end
+      if top_discard
+        cs = cs[top_discard..-1]
+        return false unless cs
+        return cs unless sentinal
+        if cs.size > recorded_size+2 && cs[recorded_size+2] != sentinal 
+          # caller seems to truncate recursive calls and we don't.
+          # See if we can find sentinal in the first 0..recorded_size+1 entries
+          return false if cs[0..recorded_size+1].any?{ |f| f==sentinal }
+          return cs
+        end
+        return false
+      end
+      return nil
+    end
+
+
+  end
+
+  # Implements debugger "where" or "backtrace" command.
+  class WhereCommand < Command
+    def regexp
+      /^\s*(?:w(?:here)?|bt|backtrace)$/
+    end
+
+    def execute
+      (0...@state.context.stack_size).each do |idx|
+        if idx == @state.frame_pos
+          print "--> "
+        else
+          print "    "
+        end
+        print_frame(idx)
+
+      end
+      if truncated_callstack?(@state.context, Debugger.start_sentinal)
+        print "Warning: saved frames may be incomplete; compare with caller(0).\n" 
+      end
+    end
+
+    class << self
+      def help_command
+        %w|where backtrace|
+      end
+
+      def help(cmd)
+        s = if cmd == 'where'
+          %{
+            w[here]\tdisplay stack frames
+            }
+            else
+          %{
+            bt|backtrace\t\talias for where - display stack frames
+         }
+            end
+        s += %{
+Print the entire stack frame. Each frame is numbered, the most recent
+frame is 0. frame number can be referred to in the "frame" command;
+"up" and "down" add or subtract respectively to frame numbers shown.
+The position of the current frame is marked with -->.  } 
+      end 
+    end
+  end
+
+  class UpCommand < Command # :nodoc:
+    def regexp
+      /^\s* u(?:p)? (?:\s+(.*))?$/x
+    end
+
+    def execute
+      pos = get_int(@match[1], "Up")
+      return unless pos
+      adjust_frame(pos, false)
+    end
+
+    class << self
+      def help_command
+        'up'
+      end
+
+      def help(cmd)
+        %{
+          up[count]\tmove to higher frame
+        }
+      end
+    end
+  end
+
+  class DownCommand < Command # :nodoc:
+    def regexp
+      /^\s* down (?:\s+(.*))? .*$/x
+    end
+
+    def execute
+      pos = get_int(@match[1], "Down")
+      return unless pos
+      adjust_frame(-pos, false)
+    end
+
+    class << self
+      def help_command
+        'down'
+      end
+
+      def help(cmd)
+        %{
+          down[count]\tmove to lower frame
+        }
+      end
+    end
+  end
+  
+  class FrameCommand < Command # :nodoc:
+    def regexp
+      / ^\s* 
+        f(?:rame)? 
+        (?: \s+ (\S+))? \s*
+        (?: thread \s+ (.*))? \s*
+        $/x
+    end
+
+    def execute
+      if not @match[1]
+        errmsg "Missing a frame number argument.\n"
+        return
+      else
+        pos = get_int(@match[1], "Frame")
+        return unless pos
+      end
+      if @match[2]
+        context = parse_thread_num('frame', @match[2])
+        unless context
+          errmsg "Thread #{@match[2]} doesn't exist.\n"
+          return
+        end
+      else
+        context = @state.context
+      end
+      adjust_frame(pos, true, context)
+    end
+
+    class << self
+      def help_command
+        'frame'
+      end
+
+      def help(cmd)
+        %{
+          f[rame] frame-number [thread thread-number]
+          Move the current frame to the specified frame number.
+
+          A negative number indicates position from the other end.  So
+          'frame -1' moves to the oldest frame, and 'frame 0' moves to
+          the newest frame.
+
+          Without an argument, the command prints the current stack
+          frame. Since the current position is redisplayed, it may trigger a
+          resyncronization if there is a front end also watching over
+          things. 
+
+          If a thread number is given then we set the context for evaluating
+          expressions to that frame of that thread. 
+        }
+      end
+    end
+  end
+end

data/vendor/gems/gems/ruby-debug-0.10.3/cli/ruby-debug/commands/help.rb

@@ -0,0 +1,56 @@
+module Debugger
+
+  # Implements debugger "help" command.
+  class HelpCommand < Command
+    self.allow_in_control = true
+
+    def regexp
+      /^\s* h(?:elp)? (?:\s+(.+))? $/x
+    end
+
+    def execute
+      if @match[1]
+        args = @match[1].split
+        cmds = @state.commands.select do |cmd| 
+          [cmd.help_command].flatten.include?(args[0])
+        end
+      else
+        args = @match[1]
+        cmds = []
+      end
+      unless cmds.empty?
+        help = cmds.map{ |cmd| cmd.help(args) }.join
+        help = help.split("\n").map{|l| l.gsub(/^ +/, '')}
+        help.shift if help.first && help.first.empty?
+        help.pop if help.last && help.last.empty?
+        print help.join("\n")
+      else
+        if args and args[0]
+          errmsg "Undefined command: \"#{args[0]}\".  Try \"help\"."
+        else
+          print "ruby-debug help v#{Debugger::VERSION}\n" unless
+            self.class.settings[:debuggertesting]
+          print "Type 'help <command-name>' for help on a specific command\n\n"
+          print "Available commands:\n"
+          cmds = @state.commands.map{ |cmd| cmd.help_command }
+          cmds = cmds.flatten.uniq.sort
+          print columnize(cmds, self.class.settings[:width])
+        end
+      end
+      print "\n"
+    end
+
+    class << self
+      def help_command
+        'help'
+      end
+
+      def help(cmd)
+        %{
+          h[elp]\t\tprint this help
+          h[elp] command\tprint help on command
+        }
+      end
+    end
+  end
+end

data/vendor/gems/gems/ruby-debug-0.10.3/cli/ruby-debug/commands/info.rb

@@ -0,0 +1,469 @@
+module Debugger
+  module InfoFunctions # :nodoc:
+    def info_catch(*args)
+      unless @state.context
+        print "No frame selected.\n"
+        return 
+      end
+      if Debugger.catchpoints and not Debugger.catchpoints.empty?
+        # FIXME: show whether Exception is valid or not
+        # print "Exception: is_a?(Class)\n"
+        Debugger.catchpoints.each do |exception, hits|
+          # print "#{exception}: #{exception.is_a?(Class)}\n"
+           print "#{exception}\n"
+        end
+      else
+        print "No exceptions set to be caught.\n"
+      end
+    end
+  end
+
+  # Implements debugger "info" command.
+  class InfoCommand < Command
+    self.allow_in_control = true
+    Subcommands = 
+      [
+       ['args', 1, 'Argument variables of current stack frame'],
+       ['breakpoints', 1, 'Status of user-settable breakpoints',
+        'Without argument, list info about all breakpoints.  With an
+integer argument, list info on that breakpoint.'],
+       ['catch', 3, 'Exceptions that can be caught in the current stack frame'],
+       ['display', 2, 'Expressions to display when program stops'],
+       ['file', 4, 'Info about a particular file read in',
+'
+After the file name is supplied, you can list file attributes that
+you wish to see.
+
+Attributes include: "all", "basic", "breakpoint", "lines", "mtime", "path" 
+and "sha1".'],
+       ['files', 5, 'File names and timestamps of files read in'],
+       ['global_variables', 2, 'Global variables'],
+       ['instance_variables', 2, 
+        'Instance variables of the current stack frame'],
+       ['line', 2, 
+        'Line number and file name of current position in source file'],
+       ['locals', 2, 'Local variables of the current stack frame'],
+       ['program', 2, 'Execution status of the program'],
+       ['stack', 2, 'Backtrace of the stack'],
+       ['thread', 6,  'List info about thread NUM', '
+If no thread number is given, we list info for all threads. \'terse\' and \'verbose\' 
+options are possible. If terse, just give summary thread name information. See 
+"help info threads" for more detail about this summary information.
+
+If \'verbose\' appended to the end of the command, then the entire
+stack trace is given for each thread.'],
+       ['threads', 7, 'information of currently-known threads', '
+This information includes whether the thread is current (+), if it is
+suspended ($), or ignored (!).  The thread number and the top stack
+item. If \'verbose\' is given then the entire stack frame is shown.'],
+       ['variables', 1, 
+        'Local and instance variables of the current stack frame']
+      ].map do |name, min, short_help, long_help| 
+      SubcmdStruct.new(name, min, short_help, long_help)
+    end unless defined?(Subcommands)
+
+    InfoFileSubcommands = 
+      [
+       ['all', 1, 
+        'All file information available - breakpoints, lines, mtime, path, and sha1'],
+       ['basic', 2, 
+        'basic information - path, number of lines'],
+       ['breakpoints', 2, 'Show trace line numbers',
+        'These are the line number where a breakpoint can be set.'],
+       ['lines', 1, 'Show number of lines in the file'],
+       ['mtime', 1, 'Show modification time of file'],
+       ['path', 4, 'Show full file path name for file'],
+       ['sha1', 1, 'Show SHA1 hash of contents of the file']
+      ].map do |name, min, short_help, long_help|
+      SubcmdStruct.new(name, min, short_help, long_help)
+    end unless defined?(InfoFileSubcommands)
+
+    InfoThreadSubcommands = 
+      [
+       ['terse', 1,   'summary information'],
+       ['verbose', 1, 'summary information and stack frame info'],
+      ].map do |name, min, short_help, long_help|
+      SubcmdStruct.new(name, min, short_help, long_help)
+    end unless defined?(InfoThreadSubcommands)
+
+    def regexp
+      /^\s* i(?:nfo)? (?:\s+(.*))?$/ix
+    end
+    
+    def execute
+      if @match[1].empty?
+        errmsg "\"info\" must be followed by the name of an info command:\n"
+        print "List of info subcommands:\n\n"
+        for subcmd in Subcommands do
+          print "info #{subcmd.name} -- #{subcmd.short_help}\n"
+        end
+      else
+        args = @match[1].split(/[ \t]+/)
+        param = args.shift
+        subcmd = find(Subcommands, param)
+        if subcmd
+          send("info_#{subcmd.name}", *args)
+        else
+          errmsg "Unknown info command #{param}\n"
+        end
+      end
+    end
+    
+    def info_args(*args)
+      unless @state.context
+        print "No frame selected.\n"
+        return 
+      end
+      locals = @state.context.frame_locals(@state.frame_pos)
+      args = @state.context.frame_args(@state.frame_pos)
+      args.each do |name|
+        s = "#{name} = #{locals[name].inspect}"
+        if s.size > self.class.settings[:width]
+          s[self.class.settings[:width]-3 .. -1] = "..."
+        end
+        print "#{s}\n"
+      end
+    end
+    
+    def info_breakpoints(*args)
+      unless @state.context
+        print "info breakpoints not available here.\n"
+        return 
+      end
+      unless Debugger.breakpoints.empty?
+        brkpts = Debugger.breakpoints.sort_by{|b| b.id}
+        unless args.empty?
+          a = args.map{|a| a.to_i}
+          brkpts = brkpts.select{|b| a.member?(b.id)}
+          if brkpts.empty?
+            errmsg "No breakpoints found among list given.\n"
+            return
+          end
+        end
+        print "Num Enb What\n"
+        brkpts.each do |b|
+          if b.expr.nil?
+            print "%3d %s   at %s:%s\n", 
+            b.id, (b.enabled? ? 'y' : 'n'), b.source, b.pos
+          else
+            print "%3d %s   at %s:%s if %s\n", 
+            b.id, (b.enabled? ? 'y' : 'n'), b.source, b.pos, b.expr
+          end
+          hits = b.hit_count
+          if hits > 0
+            s = (hits > 1) ? 's' : ''
+            print "\tbreakpoint already hit #{hits} time#{s}\n"
+          end
+        end
+      else
+        print "No breakpoints.\n"
+      end
+    end
+    
+    def info_display(*args)
+      unless @state.context
+        print "info display not available here.\n"
+        return 
+      end
+      if @state.display.find{|d| d[0]}
+        print "Auto-display expressions now in effect:\n"
+        print "Num Enb Expression\n"
+        n = 1
+        for d in @state.display
+          print "%3d: %s  %s\n", n, (d[0] ? 'y' : 'n'), d[1] if
+            d[0] != nil
+          n += 1
+        end
+      else
+        print "There are no auto-display expressions now.\n"
+      end
+    end
+    
+    def info_file(*args)
+      unless args[0] 
+        info_files
+        return
+      end
+      file = args[0]
+      param =  args[1]
+      
+      param = 'basic' unless param
+      subcmd = find(InfoFileSubcommands, param)
+      unless subcmd
+        errmsg "Invalid parameter #{param}\n"
+        return
+      end
+      
+      unless LineCache::cached?(file)
+        unless LineCache::cached_script?(file)
+          print "File #{file} is not cached\n"
+          return
+        end
+        LineCache::cache(file, Command.settings[:reload_source_on_change])
+      end
+      
+      print "File %s", file
+      path = LineCache.path(file)
+      if %w(all basic path).member?(subcmd.name) and path != file
+        print " - %s\n", path 
+      else
+        print "\n"
+      end
+
+      if %w(all basic lines).member?(subcmd.name)
+        lines = LineCache.size(file)
+        print "\t %d lines\n", lines if lines
+      end
+
+      if %w(all breakpoints).member?(subcmd.name)
+        breakpoints = LineCache.trace_line_numbers(file)
+        if breakpoints
+          print "\tbreakpoint line numbers:\n" 
+          print columnize(breakpoints.to_a.sort, self.class.settings[:width])
+        end
+      end
+
+      if %w(all mtime).member?(subcmd.name)
+        stat = LineCache.stat(file)
+        print "\t%s\n", stat.mtime if stat
+      end
+      if %w(all sha1).member?(subcmd.name)
+        print "\t%s\n", LineCache.sha1(file)
+      end
+    end
+    
+    def info_files(*args)
+      files = LineCache::cached_files
+      files += SCRIPT_LINES__.keys unless 'stat' == args[0] 
+      files.uniq.sort.each do |file|
+        stat = LineCache::stat(file)
+        path = LineCache::path(file)
+        print "File %s", file
+        if path and path != file
+          print " - %s\n", path 
+        else
+          print "\n"
+        end
+        print "\t%s\n", stat.mtime if stat
+      end
+    end
+    
+    def info_instance_variables(*args)
+      unless @state.context
+        print "info instance_variables not available here.\n"
+        return 
+      end
+      obj = debug_eval('self')
+      var_list(obj.instance_variables)
+    end
+    
+    def info_line(*args)
+      unless @state.context
+        errmsg "info line not available here.\n"
+        return 
+      end
+      print "Line %d of \"%s\"\n",  @state.line, @state.file
+    end
+    
+    def info_locals(*args)
+      unless @state.context
+        errmsg "info line not available here.\n"
+        return 
+      end
+      locals = @state.context.frame_locals(@state.frame_pos)
+      locals.keys.sort.each do |name|
+        ### FIXME: make a common routine
+        begin
+          s = "#{name} = #{locals[name].inspect}"
+        rescue
+          begin
+          s = "#{name} = #{locals[name].to_s}"
+          rescue
+            s = "*Error in evaluation*"
+          end
+        end  
+        if s.size > self.class.settings[:width]
+          s[self.class.settings[:width]-3 .. -1] = "..."
+        end
+        print "#{s}\n"
+      end
+    end
+    
+    def info_program(*args)
+      if not @state.context
+        print "The program being debugged is not being run.\n"
+        return
+      elsif @state.context.dead? 
+        print "The program crashed.\n"
+        if Debugger.last_exception
+          print("Exception: #{Debugger.last_exception.inspect}\n")
+        end
+        return
+      end
+      
+      print "Program stopped. "
+      case @state.context.stop_reason
+      when :step
+        print "It stopped after stepping, next'ing or initial start.\n"
+      when :breakpoint
+        print("It stopped at a breakpoint.\n")
+      when :catchpoint
+        print("It stopped at a catchpoint.\n")
+      when :catchpoint
+        print("It stopped at a catchpoint.\n")
+      else
+        print "unknown reason: %s\n" % @state.context.stop_reason.to_s
+      end
+    end
+    
+    def info_stack(*args)
+      if not @state.context
+        errmsg "info stack not available here.\n"
+        return
+      end
+      (0...@state.context.stack_size).each do |idx|
+        if idx == @state.frame_pos
+          print "--> "
+        else
+          print "    "
+        end
+        print_frame(idx)
+      end
+    end
+
+    def info_thread_preamble(arg)
+      if not @state.context
+        errmsg "info threads not available here.\n"
+        return false, false
+      end
+      verbose = if arg
+        subcmd = find(InfoThreadSubcommands, arg)
+        unless subcmd
+          errmsg "'terse' or 'verbose' expected. Got '#{arg}'\n"
+          return false, false
+        end
+        'verbose' == subcmd.name
+      else
+        false
+      end
+      return true, verbose
+    end
+    private :info_thread_preamble
+      
+    def info_threads(*args)
+      ok, verbose = info_thread_preamble(args[0])
+      return unless ok
+      threads = Debugger.contexts.sort_by{|c| c.thnum}.each do |c|
+        display_context(c, !verbose)
+        if verbose and not c.ignored?
+          (0...c.stack_size).each do |idx|
+            print "\t"
+            print_frame(idx, false, c)
+          end
+        end
+      end
+    end
+    
+    def info_thread(*args)
+      unless args[0]
+        info_threads(args[0])
+        return
+      end
+      ok, verbose = info_thread_preamble(args[1])
+      return unless ok
+      c = parse_thread_num("info thread" , args[0])
+      return unless c
+      display_context(c, !verbose)
+      if verbose and not c.ignored?
+        (0...c.stack_size).each do |idx|
+          print "\t"
+          print_frame(idx, false, c) 
+        end
+      end
+    end
+    
+    def info_global_variables(*args)
+      unless @state.context
+        errmsg "info global_variables not available here.\n"
+        return 
+      end
+      var_list(global_variables)
+    end
+    
+    def info_variables(*args)
+      if not @state.context
+        errmsg "info variables not available here.\n"
+        return
+      end
+      obj = debug_eval('self')
+      locals = @state.context.frame_locals(@state.frame_pos)
+      locals['self'] = @state.context.frame_self(@state.frame_pos)
+      locals.keys.sort.each do |name|
+        next if name =~ /^__dbg_/ # skip debugger pollution
+        ### FIXME: make a common routine
+        begin
+          s = "#{name} = #{locals[name].inspect}"
+        rescue
+          begin
+            s = "#{name} = #{locals[name].to_s}"
+          rescue
+            s = "#{name} = *Error in evaluation*"
+          end
+        end
+        if s.size > self.class.settings[:width]
+          s[self.class.settings[:width]-3 .. -1] = "..."
+        end
+        s.gsub!('%', '%%')  # protect against printf format strings
+        print "#{s}\n"
+      end
+      var_list(obj.instance_variables, obj.instance_eval{binding()})
+      var_class_self
+    end
+    
+    class << self
+      def help_command
+        'info'
+      end
+
+      def help(args)
+        if args[1] 
+          s = args[1]
+          subcmd = Subcommands.find do |try_subcmd| 
+            (s.size >= try_subcmd.min) and
+              (try_subcmd.name[0..s.size-1] == s)
+          end
+          if subcmd
+            str = subcmd.short_help + '.'
+            if 'file' == subcmd.name and args[2]
+              s = args[2]
+              subsubcmd = InfoFileSubcommands.find do |try_subcmd|
+                (s.size >= try_subcmd.min) and
+                  (try_subcmd.name[0..s.size-1] == s)
+              end
+              if subsubcmd
+                str += "\n" + subsubcmd.short_help + '.'
+              else
+                str += "\nInvalid file attribute #{args[2]}."
+              end
+            else
+              str += "\n" + subcmd.long_help if subcmd.long_help
+            end
+            return str
+          else
+            return "Invalid 'info' subcommand '#{args[1]}'."
+          end
+        end
+        s = %{
+          Generic command for showing things about the program being debugged.
+          -- 
+          List of info subcommands:
+          --  
+        }
+        for subcmd in Subcommands do
+          s += "info #{subcmd.name} -- #{subcmd.short_help}\n"
+        end
+        return s
+      end
+    end
+  end
+end