dirwatch 0.0.2 → 0.0.3

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

@@ -1,124 +0,0 @@
-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

@@ -1,61 +0,0 @@
-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

@@ -1,73 +0,0 @@
-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

@@ -1,75 +0,0 @@
-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

@@ -1,38 +0,0 @@
-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

@@ -1,17 +0,0 @@
-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

@@ -1,34 +0,0 @@
-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

@@ -1,65 +0,0 @@
-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

@@ -1,62 +0,0 @@
-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

@@ -1,52 +0,0 @@
-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