dirwatch 0.0.1 → 0.0.2

data/vendor/bundle/ruby/2.3.0/gems/byebug-9.1.0/lib/byebug/helpers/eval.rb

@@ -0,0 +1,124 @@
+module Byebug
+  module Helpers
+    #
+    # Utilities to assist evaluation of code strings
+    #
+    module EvalHelper
+      #
+      # Evaluates an +expression+ in a separate thread.
+      #
+      # @param expression [String] Expression to evaluate
+      #
+      def separate_thread_eval(expression)
+        allowing_other_threads do
+          in_new_thread { warning_eval(expression) }
+        end
+      end
+
+      #
+      # Evaluates an +expression+ that might use or defer execution to threads
+      # other than the current one.
+      #
+      # @note This is necessary because when in byebug's prompt, every thread is
+      # "frozen" so that nothing gets run. So we need to unlock threads prior
+      # to evaluation or we will run into a deadlock.
+      #
+      # @param expression [String] Expression to evaluate
+      #
+      def multiple_thread_eval(expression)
+        allowing_other_threads { warning_eval(expression) }
+      end
+
+      #
+      # Evaluates a string containing Ruby code in a specific binding,
+      # returning nil in an error happens.
+      #
+      def silent_eval(str, binding = frame._binding)
+        safe_eval(str, binding) { |_e| nil }
+      end
+
+      #
+      # Evaluates a string containing Ruby code in a specific binding,
+      # handling the errors at an error level.
+      #
+      def error_eval(str, binding = frame._binding)
+        safe_eval(str, binding) { |e| raise(e, msg(e)) }
+      end
+
+      #
+      # Evaluates a string containing Ruby code in a specific binding,
+      # handling the errors at a warning level.
+      #
+      def warning_eval(str, binding = frame._binding)
+        safe_eval(str, binding) { |e| errmsg(msg(e)) }
+      end
+
+      private
+
+      def safe_eval(str, binding)
+        binding.eval(str.gsub(/\Aeval /, ''), '(byebug)', 1)
+      rescue StandardError, ScriptError => e
+        yield(e)
+      end
+
+      def msg(e)
+        msg = Setting[:stack_on_error] ? error_msg(e) : warning_msg(e)
+
+        pr('eval.exception', text_message: msg)
+      end
+
+      def error_msg(e)
+        at = e.backtrace
+
+        locations = ["#{at.shift}: #{warning_msg(e)}"]
+        locations += at.map { |path| "  from #{path}" }
+        locations.join("\n")
+      end
+
+      def warning_msg(e)
+        "#{e.class} Exception: #{e.message}"
+      end
+
+      #
+      # Run block temporarily ignoring all TracePoint events.
+      #
+      # Used to evaluate stuff within Byebug's prompt. Otherwise, any code
+      # creating new threads won't be properly evaluated because new threads
+      # will get blocked by byebug's main thread.
+      #
+      def allowing_other_threads
+        Byebug.unlock
+
+        res = yield
+
+        Byebug.lock
+
+        res
+      end
+
+      #
+      # Runs the given block in a new thread, waits for it to finish and
+      # returns the new thred's result.
+      #
+      def in_new_thread
+        res = nil
+
+        Thread.new { res = yield }.join
+
+        res
+      end
+
+      def safe_inspect(var)
+        var.inspect
+      rescue
+        safe_to_s(var)
+      end
+
+      def safe_to_s(var)
+        var.to_s
+      rescue
+        '*Error in evaluation*'
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.3.0/gems/byebug-9.1.0/lib/byebug/helpers/file.rb

@@ -0,0 +1,61 @@
+module Byebug
+  module Helpers
+    #
+    # Utilities for interaction with files
+    #
+    module FileHelper
+      #
+      # Reads lines of source file +filename+ into an array
+      #
+      def get_lines(filename)
+        File.foreach(filename).reduce([]) { |acc, elem| acc << elem.chomp }
+      end
+
+      #
+      # Reads line number +lineno+ from file named +filename+
+      #
+      def get_line(filename, lineno)
+        File.open(filename) do |f|
+          f.gets until f.lineno == lineno - 1
+          f.gets
+        end
+      end
+
+      #
+      # Returns the number of lines in file +filename+ in a portable,
+      # one-line-at-a-time way.
+      #
+      def n_lines(filename)
+        File.foreach(filename).reduce(0) { |acc, _elem| acc + 1 }
+      end
+
+      #
+      # Regularize file name.
+      #
+      def normalize(filename)
+        return filename if virtual_file?(filename)
+
+        return File.basename(filename) if Setting[:basename]
+
+        File.exist?(filename) ? File.realpath(filename) : filename
+      end
+
+      #
+      # A short version of a long path
+      #
+      def shortpath(fullpath)
+        components = Pathname(fullpath).each_filename.to_a
+        return fullpath if components.size <= 2
+
+        File.join('...', components[-3..-1])
+      end
+
+      #
+      # True for special files like -e, false otherwise
+      #
+      def virtual_file?(name)
+        ['(irb)', '-e', '(byebug)', '(eval)'].include?(name)
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.3.0/gems/byebug-9.1.0/lib/byebug/helpers/frame.rb

@@ -0,0 +1,73 @@
+module Byebug
+  module Helpers
+    #
+    # Utilities to assist frame navigation
+    #
+    module FrameHelper
+      def switch_to_frame(frame)
+        new_frame = index_from_start(frame)
+        return frame_err('c_frame') if Frame.new(context, new_frame).c_frame?
+
+        adjust_frame(new_frame)
+      end
+
+      def jump_frames(steps)
+        adjust_frame(navigate_to_frame(steps))
+      end
+
+      private
+
+      def adjust_frame(new_frame)
+        return frame_err('too_low') if new_frame >= context.stack_size
+        return frame_err('too_high') if new_frame < 0
+
+        context.frame = new_frame
+        processor.prev_line = nil
+      end
+
+      def navigate_to_frame(jump_no)
+        current_jumps = 0
+        current_pos = context.frame.pos
+
+        loop do
+          current_pos += direction(jump_no)
+          break if out_of_bounds?(current_pos)
+
+          next if Frame.new(context, current_pos).c_frame?
+
+          current_jumps += 1
+          break if current_jumps == jump_no.abs
+        end
+
+        current_pos
+      end
+
+      def out_of_bounds?(pos)
+        !(0...context.stack_size).cover?(pos)
+      end
+
+      def frame_err(msg)
+        errmsg(pr("frame.errors.#{msg}"))
+      end
+
+      #
+      # @param step [Integer] A positive or negative integer
+      #
+      # @return [Integer] +1 if step is positive / -1 if negative
+      #
+      def direction(step)
+        step / step.abs
+      end
+
+      #
+      # Convert a possibly negative index to a positive index from the start
+      # of the callstack. -1 is the last position in the stack and so on.
+      #
+      # @param i [Integer] Integer to be converted in a proper positive index.
+      #
+      def index_from_start(i)
+        i >= 0 ? i : context.stack_size + i
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.3.0/gems/byebug-9.1.0/lib/byebug/helpers/parse.rb

@@ -0,0 +1,75 @@
+module Byebug
+  module Helpers
+    #
+    # Utilities to assist command parsing
+    #
+    module ParseHelper
+      #
+      # Parses +str+ of command +cmd+ as an integer between +min+ and +max+.
+      #
+      # If either +min+ or +max+ is nil, that value has no bound.
+      #
+      # @todo Remove the `cmd` parameter. It has nothing to do with the method's
+      # purpose.
+      #
+      def get_int(str, cmd, min = nil, max = nil)
+        if str !~ /\A-?[0-9]+\z/
+          return nil, pr('parse.errors.int.not_number', cmd: cmd, str: str)
+        end
+
+        int = str.to_i
+        if min && int < min
+          err = pr('parse.errors.int.too_low', cmd: cmd, str: str, min: min)
+          return nil, err
+        elsif max && int > max
+          err = pr('parse.errors.int.too_high', cmd: cmd, str: str, max: max)
+          return nil, err
+        end
+
+        int
+      end
+
+      #
+      # @return true if code is syntactically correct for Ruby, false otherwise
+      #
+      def syntax_valid?(code)
+        return true unless code
+
+        without_stderr do
+          begin
+            RubyVM::InstructionSequence.compile(code)
+            true
+          rescue SyntaxError
+            false
+          end
+        end
+      end
+
+      #
+      # @return +str+ as an integer or 1 if +str+ is empty.
+      #
+      def parse_steps(str, cmd)
+        return 1 unless str
+
+        steps, err = get_int(str, cmd, 1)
+        return nil, err unless steps
+
+        steps
+      end
+
+      private
+
+      #
+      # Temporarily disable output to $stderr
+      #
+      def without_stderr
+        old_stderr = $stderr
+        $stderr = StringIO.new
+
+        yield
+      ensure
+        $stderr = old_stderr
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.3.0/gems/byebug-9.1.0/lib/byebug/helpers/path.rb

@@ -0,0 +1,38 @@
+module Byebug
+  module Helpers
+    #
+    # Utilities for managing gem paths
+    #
+    module PathHelper
+      def bin_file
+        @bin_file ||= File.join(root_path, 'bin', 'byebug')
+      end
+
+      def root_path
+        @root_path ||= File.expand_path(File.join('..', '..', '..'), __dir__)
+      end
+
+      def lib_files
+        @lib_files ||= glob_for('lib')
+      end
+
+      def test_files
+        @test_files ||= glob_for('test')
+      end
+
+      def gem_files
+        @gem_files ||= [bin_file] + lib_files
+      end
+
+      def all_files
+        @all_files ||= gem_files + test_files
+      end
+
+      private
+
+      def glob_for(dir)
+        Dir.glob(File.join(root_path, dir, '**', '*.rb'))
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.3.0/gems/byebug-9.1.0/lib/byebug/helpers/reflection.rb

@@ -0,0 +1,17 @@
+module Byebug
+  module Helpers
+    #
+    # Reflection utilitie
+    #
+    module ReflectionHelper
+      #
+      # List of "command" classes in the including module
+      #
+      def commands
+        constants(false)
+          .map { |const| const_get(const, false) }
+          .select { |c| c.is_a?(Class) && c.name =~ /[a-z]Command$/ }
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.3.0/gems/byebug-9.1.0/lib/byebug/helpers/string.rb

@@ -0,0 +1,34 @@
+module Byebug
+  module Helpers
+    #
+    # Utilities for interaction with strings
+    #
+    module StringHelper
+      #
+      # Converts +str+ from an_underscored-or-dasherized_string to
+      # ACamelizedString.
+      #
+      def camelize(str)
+        str.dup.split(/[_-]/).map(&:capitalize).join('')
+      end
+
+      #
+      # Improves indentation and spacing in +str+ for readability in Byebug's
+      # command prompt.
+      #
+      def prettify(str)
+        "\n" + deindent(str) + "\n"
+      end
+
+      #
+      # Removes a number of leading whitespace for each input line.
+      #
+      # @note Might be unnecessary when Ruby 2.2 support is dropped and we can
+      # use squiggly heredoc's.
+      #
+      def deindent(str, leading_spaces: 6)
+        str.gsub(/^ {#{leading_spaces}}/, '')
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.3.0/gems/byebug-9.1.0/lib/byebug/helpers/thread.rb

@@ -0,0 +1,65 @@
+module Byebug
+  module Helpers
+    #
+    # Utilities for thread subcommands
+    #
+    module ThreadHelper
+      def display_context(ctx)
+        puts pr('thread.context', thread_arguments(ctx))
+      end
+
+      def thread_arguments(ctx)
+        {
+          status_flag: status_flag(ctx),
+          debug_flag: debug_flag(ctx),
+          id: ctx.thnum,
+          thread: ctx.thread.inspect,
+          file_line: location(ctx),
+          pid: Process.pid,
+          status: ctx.thread.status,
+          current: current_thread?(ctx)
+        }
+      end
+
+      def current_thread?(ctx)
+        ctx.thread == Thread.current
+      end
+
+      def context_from_thread(thnum)
+        ctx = Byebug.contexts.find { |c| c.thnum.to_s == thnum }
+
+        err = if ctx.nil?
+                pr('thread.errors.no_thread')
+              elsif ctx == context
+                pr('thread.errors.current_thread')
+              elsif ctx.ignored?
+                pr('thread.errors.ignored', arg: thnum)
+              end
+
+        [ctx, err]
+      end
+
+      private
+
+      # @todo Check whether it is Byebug.current_context or context
+      def location(ctx)
+        return context.location if ctx == Byebug.current_context
+
+        backtrace = ctx.thread.backtrace_locations
+        return '' unless backtrace && backtrace[0]
+
+        "#{backtrace[0].path}:#{backtrace[0].lineno}"
+      end
+
+      def status_flag(ctx)
+        return '$' if ctx.suspended?
+
+        current_thread?(ctx) ? '+' : ' '
+      end
+
+      def debug_flag(ctx)
+        ctx.ignored? ? '!' : ' '
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.3.0/gems/byebug-9.1.0/lib/byebug/helpers/toggle.rb

@@ -0,0 +1,62 @@
+require 'byebug/helpers/parse'
+
+module Byebug
+  module Helpers
+    #
+    # Utilities to assist breakpoint/display enabling/disabling.
+    #
+    module ToggleHelper
+      include ParseHelper
+
+      def enable_disable_breakpoints(is_enable, args)
+        raise pr('toggle.errors.no_breakpoints') if Breakpoint.none?
+
+        select_breakpoints(is_enable, args).each do |b|
+          enabled = (is_enable == 'enable')
+          if enabled && !syntax_valid?(b.expr)
+            raise pr('toggle.errors.expression', expr: b.expr)
+          end
+
+          puts pr('toggle.messages.toggled', bpnum: b.id,
+                                             endis: enabled ? 'en' : 'dis')
+          b.enabled = enabled
+        end
+      end
+
+      def enable_disable_display(is_enable, args)
+        raise pr('toggle.errors.no_display') if n_displays.zero?
+
+        selected_displays = args ? args.split(/ +/) : [1..n_displays + 1]
+
+        selected_displays.each do |pos|
+          pos, err = get_int(pos, "#{is_enable} display", 1, n_displays)
+          raise err unless err.nil?
+
+          Byebug.displays[pos - 1][0] = (is_enable == 'enable')
+        end
+      end
+
+      private
+
+      def select_breakpoints(is_enable, args)
+        all_breakpoints = Byebug.breakpoints.sort_by(&:id)
+        return all_breakpoints if args.nil?
+
+        selected_ids = []
+        args.split(/ +/).each do |pos|
+          last_id = all_breakpoints.last.id
+          pos, err = get_int(pos, "#{is_enable} breakpoints", 1, last_id)
+          raise(ArgumentError, err) unless pos
+
+          selected_ids << pos
+        end
+
+        all_breakpoints.select { |b| selected_ids.include?(b.id) }
+      end
+
+      def n_displays
+        Byebug.displays.size
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.3.0/gems/byebug-9.1.0/lib/byebug/helpers/var.rb

@@ -0,0 +1,52 @@
+require 'byebug/helpers/eval'
+
+module Byebug
+  module Helpers
+    #
+    # Utilities for variable subcommands
+    #
+    module VarHelper
+      include EvalHelper
+
+      def var_list(ary, binding = context.frame._binding)
+        vars = ary.sort.map do |name|
+          [name, safe_inspect(silent_eval(name.to_s, binding))]
+        end
+
+        puts prv(vars, 'instance')
+      end
+
+      def var_global
+        globals = global_variables.reject do |v|
+          %i[$IGNORECASE $= $KCODE $-K $binding].include?(v)
+        end
+
+        var_list(globals)
+      end
+
+      def var_instance(str)
+        obj = warning_eval(str || 'self')
+
+        var_list(obj.instance_variables, obj.instance_eval { binding })
+      end
+
+      def var_local
+        locals = context.frame.locals
+        cur_self = context.frame._self
+        locals[:self] = cur_self unless cur_self.to_s == 'main'
+        puts prv(locals.keys.sort.map { |k| [k, locals[k]] }, 'instance')
+      end
+
+      def var_args
+        args = context.frame.args
+        return if args == [[:rest]]
+
+        all_locals = context.frame.locals
+        arg_values = args.map { |arg| arg[1] }
+
+        locals = all_locals.select { |k, _| arg_values.include?(k) }
+        puts prv(locals.keys.sort.map { |k| [k, locals[k]] }, 'instance')
+      end
+    end
+  end
+end