dirwatch 0.0.2 → 0.0.3

data/vendor/bundle/ruby/2.3.0/gems/byebug-9.1.0/ext/byebug/locker.c

@@ -1,96 +0,0 @@
-#include "byebug.h"
-
-/**
- * A simple linked list containing locked threads, FIFO style.
- */
-
-typedef struct locked_thread_t
-{
-  VALUE thread;
-  struct locked_thread_t *next;
-} locked_thread_t;
-
-static locked_thread_t *locked_head = NULL;
-static locked_thread_t *locked_tail = NULL;
-
-static int
-is_in_locked(VALUE thread)
-{
-  locked_thread_t *node;
-
-  if (!locked_head)
-    return 0;
-
-  for (node = locked_head; node != locked_tail; node = node->next)
-    if (node->thread == thread)
-      return 1;
-
-  return 0;
-}
-
-extern void
-add_to_locked(VALUE thread)
-{
-  locked_thread_t *node;
-
-  if (is_in_locked(thread))
-    return;
-
-  node = ALLOC(locked_thread_t);
-  node->thread = thread;
-  node->next = NULL;
-
-  if (locked_tail)
-    locked_tail->next = node;
-
-  locked_tail = node;
-
-  if (!locked_head)
-    locked_head = node;
-}
-
-extern VALUE
-pop_from_locked()
-{
-  VALUE thread;
-  locked_thread_t *node;
-
-  if (!locked_head)
-    return Qnil;
-
-  node = locked_head;
-  locked_head = locked_head->next;
-
-  if (locked_tail == node)
-    locked_tail = NULL;
-
-  thread = node->thread;
-  xfree(node);
-
-  return thread;
-}
-
-extern void
-remove_from_locked(VALUE thread)
-{
-  locked_thread_t *node;
-  locked_thread_t *next_node;
-
-  if (NIL_P(thread) || !locked_head || !is_in_locked(thread))
-    return;
-
-  if (locked_head->thread == thread)
-  {
-    pop_from_locked();
-    return;
-  }
-
-  for (node = locked_head; node != locked_tail; node = node->next)
-    if (node->next && node->next->thread == thread)
-    {
-      next_node = node->next;
-      node->next = next_node->next;
-      xfree(next_node);
-      return;
-    }
-}

data/vendor/bundle/ruby/2.3.0/gems/byebug-9.1.0/ext/byebug/threads.c

@@ -1,230 +0,0 @@
-#include "byebug.h"
-
-/* Threads table class */
-static VALUE cThreadsTable;
-
-/* If not Qnil, holds the next thread that must be run */
-VALUE next_thread = Qnil;
-
-/* To allow thread syncronization, we must stop threads when debugging */
-static VALUE locker = Qnil;
-
-static int
-t_tbl_mark_keyvalue(st_data_t key, st_data_t value, st_data_t tbl)
-{
-  UNUSED(tbl);
-
-  rb_gc_mark((VALUE) key);
-
-  if (!value)
-    return ST_CONTINUE;
-
-  rb_gc_mark((VALUE) value);
-
-  return ST_CONTINUE;
-}
-
-static void
-t_tbl_mark(void *data)
-{
-  threads_table_t *t_tbl = (threads_table_t *) data;
-  st_table *tbl = t_tbl->tbl;
-
-  st_foreach(tbl, t_tbl_mark_keyvalue, (st_data_t) tbl);
-}
-
-static void
-t_tbl_free(void *data)
-{
-  threads_table_t *t_tbl = (threads_table_t *) data;
-
-  st_free_table(t_tbl->tbl);
-  xfree(t_tbl);
-}
-
-/*
- *  Creates a numeric hash whose keys are the currently active threads and
- *  whose values are their associated contexts.
- */
-VALUE
-create_threads_table(void)
-{
-  threads_table_t *t_tbl;
-
-  t_tbl = ALLOC(threads_table_t);
-  t_tbl->tbl = st_init_numtable();
-  return Data_Wrap_Struct(cThreadsTable, t_tbl_mark, t_tbl_free, t_tbl);
-}
-
-/*
- *  Checks a single entry in the threads table.
- *
- *  If it has no associated context or the key doesn't correspond to a living
- *  thread, the entry is removed from the thread's list.
- */
-static int
-check_thread_i(st_data_t key, st_data_t value, st_data_t data)
-{
-  UNUSED(data);
-
-  if (!value)
-    return ST_DELETE;
-
-  if (!is_living_thread((VALUE) key))
-    return ST_DELETE;
-
-  return ST_CONTINUE;
-}
-
-/*
- *  Checks whether a thread is either in the running or sleeping state.
- */
-int
-is_living_thread(VALUE thread)
-{
-  VALUE status = rb_funcall(thread, rb_intern("status"), 0);
-
-  if (NIL_P(status) || status == Qfalse)
-    return 0;
-
-  if (rb_str_cmp(status, rb_str_new2("run")) == 0
-      || rb_str_cmp(status, rb_str_new2("sleep")) == 0)
-    return 1;
-
-  return 0;
-}
-
-/*
- *  Checks threads table for dead/finished threads.
- */
-static void
-cleanup_dead_threads(void)
-{
-  threads_table_t *t_tbl;
-
-  Data_Get_Struct(threads, threads_table_t, t_tbl);
-  st_foreach(t_tbl->tbl, check_thread_i, 0);
-}
-
-/*
- * Looks up a context in the threads table. If not present, it creates it.
- */
-void
-thread_context_lookup(VALUE thread, VALUE * context)
-{
-  threads_table_t *t_tbl;
-
-  Data_Get_Struct(threads, threads_table_t, t_tbl);
-
-  if (!st_lookup(t_tbl->tbl, thread, context) || !*context)
-  {
-    *context = context_create(thread);
-    st_insert(t_tbl->tbl, thread, *context);
-  }
-}
-
-/*
- * Holds thread execution while another thread is active.
- *
- * Thanks to this, all threads are "frozen" while the user is typing commands.
- */
-void
-acquire_lock(debug_context_t * dc)
-{
-  while ((!NIL_P(locker) && locker != rb_thread_current())
-         || CTX_FL_TEST(dc, CTX_FL_SUSPEND))
-  {
-    add_to_locked(rb_thread_current());
-    rb_thread_stop();
-
-    if (CTX_FL_TEST(dc, CTX_FL_SUSPEND))
-      CTX_FL_SET(dc, CTX_FL_WAS_RUNNING);
-  }
-
-  locker = rb_thread_current();
-}
-
-/*
- * Releases our global lock and passes execution on to another thread, either
- * the thread specified by +next_thread+ or any other thread if +next_thread+
- * is nil.
- */
-void
-release_lock(void)
-{
-  VALUE thread;
-
-  cleanup_dead_threads();
-
-  locker = Qnil;
-
-  if (NIL_P(next_thread))
-    thread = pop_from_locked();
-  else
-  {
-    remove_from_locked(next_thread);
-    thread = next_thread;
-    next_thread = Qnil;
-  }
-
-  if (!NIL_P(thread) && is_living_thread(thread))
-    rb_thread_run(thread);
-}
-
-/*
- *  call-seq:
- *    Byebug.unlock -> nil
- *
- *  Unlocks global switch so other threads can run.
- */
-static VALUE
-Unlock(VALUE self)
-{
-  UNUSED(self);
-
-  release_lock();
-
-  return locker;
-}
-
-/*
- *  call-seq:
- *    Byebug.lock -> Thread.current
- *
- *  Locks global switch to reserve execution to current thread exclusively.
- */
-static VALUE
-Lock(VALUE self)
-{
-  debug_context_t *dc;
-  VALUE context;
-
-  UNUSED(self);
-
-  if (!is_living_thread(rb_thread_current()))
-    rb_raise(rb_eRuntimeError, "Current thread is dead!");
-
-  thread_context_lookup(rb_thread_current(), &context);
-  Data_Get_Struct(context, debug_context_t, dc);
-
-  acquire_lock(dc);
-
-  return locker;
-}
-
-/*
- *
- *    Document-class: ThreadsTable
- *
- *    == Sumary
- *
- *    Hash table holding currently active threads and their associated contexts
- */
-void
-Init_threads_table(VALUE mByebug)
-{
-  cThreadsTable = rb_define_class_under(mByebug, "ThreadsTable", rb_cObject);
-
-  rb_define_module_function(mByebug, "unlock", Unlock, 0);
-  rb_define_module_function(mByebug, "lock", Lock, 0);
-}

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

@@ -1,34 +0,0 @@
-#
-# Main Container for all of Byebug's code
-#
-module Byebug
-  #
-  # Enters byebug right before (or right after if _before_ is false) return
-  # events occur. Before entering byebug the init script is read.
-  #
-  def self.attach
-    require 'byebug/core'
-
-    unless started?
-      self.mode = :attached
-
-      start
-      run_init_script
-    end
-
-    current_context.step_out(3, true)
-  end
-end
-
-#
-# Adds a `byebug` method to the Kernel module.
-#
-# Dropping a `byebug` call anywhere in your code, you get a debug prompt.
-#
-module Kernel
-  def byebug
-    Byebug.attach
-  end
-
-  alias debugger byebug
-end

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

@@ -1,89 +0,0 @@
-module Byebug
-  #
-  # Implements breakpoints
-  #
-  class Breakpoint
-    #
-    # First breakpoint, in order of creation
-    #
-    def self.first
-      Byebug.breakpoints.first
-    end
-
-    #
-    # Last breakpoint, in order of creation
-    #
-    def self.last
-      Byebug.breakpoints.last
-    end
-
-    #
-    # Adds a new breakpoint
-    #
-    # @param [String] file
-    # @param [Fixnum] line
-    # @param [String] expr
-    #
-    def self.add(file, line, expr = nil)
-      breakpoint = Breakpoint.new(file, line, expr)
-      Byebug.breakpoints << breakpoint
-      breakpoint
-    end
-
-    #
-    # Removes a breakpoint
-    #
-    # @param id [integer] breakpoint number
-    #
-    def self.remove(id)
-      Byebug.breakpoints.reject! { |b| b.id == id }
-    end
-
-    #
-    # Returns an array of line numbers in file named +filename+ where
-    # breakpoints could be set. The list will contain an entry for each
-    # distinct line event call so it is possible (and possibly useful) for a
-    # line number appear more than once.
-    #
-    # @param filename [String] File name to inspect for possible breakpoints
-    #
-    def self.potential_lines(filename)
-      name = "#{Time.new.to_i}_#{rand(2**31)}"
-      lines = {}
-      iseq = RubyVM::InstructionSequence.compile(File.read(filename), name)
-
-      iseq.disasm.each_line do |line|
-        res = /^\d+ (?<insn>\w+)\s+.+\(\s*(?<lineno>\d+)\)$/.match(line)
-        next unless res && res[:insn] == 'trace'
-
-        lines[res[:lineno].to_i] = true
-      end
-
-      lines.keys
-    end
-
-    #
-    # Returns true if a breakpoint could be set in line number +lineno+ in file
-    # name +filename.
-    #
-    def self.potential_line?(filename, lineno)
-      potential_lines(filename).member?(lineno)
-    end
-
-    #
-    # True if there's no breakpoints
-    #
-    def self.none?
-      Byebug.breakpoints.empty?
-    end
-
-    #
-    # Prints all information associated to the breakpoint
-    #
-    def inspect
-      meths = %w[id pos source expr hit_condition hit_count hit_value enabled?]
-      values = meths.map { |field| "#{field}: #{send(field)}" }.join(', ')
-      "#<Byebug::Breakpoint #{values}>"
-    end
-  end
-end

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

@@ -1,105 +0,0 @@
-require 'forwardable'
-require 'byebug/helpers/string'
-
-module Byebug
-  #
-  # Parent class of all byebug commands.
-  #
-  # Subclass it and name the subclass ending with the word Command to implement
-  # your own custom command.
-  #
-  # @example Define a custom command
-  #
-  # class MyCustomCommand < Command
-  #   def self.regexp
-  #     /custom_regexp/
-  #   end
-  #
-  #   def self.description
-  #     'Custom long desc'
-  #   end
-  #
-  #   def.short_description
-  #     'Custom short desc'
-  #   end
-  #
-  #   def execute
-  #     # My command's implementation
-  #   end
-  # end
-  #
-  class Command
-    extend Forwardable
-
-    attr_reader :processor
-
-    def initialize(processor, input = self.class.to_s)
-      @processor = processor
-      @match = match(input)
-    end
-
-    def context
-      @context ||= processor.context
-    end
-
-    def frame
-      @frame ||= context.frame
-    end
-
-    def arguments
-      @match[0].split(' ').drop(1).join(' ')
-    end
-
-    def_delegators :'self.class', :help, :match
-
-    def_delegator :'processor.printer', :print, :pr
-    def_delegator :'processor.printer', :print_collection, :prc
-    def_delegator :'processor.printer', :print_variables, :prv
-
-    def_delegators :'processor.interface', :errmsg, :puts, :print, :confirm
-
-    class << self
-      include Helpers::StringHelper
-
-      #
-      # Special methods to allow command filtering in processors
-      #
-      attr_accessor :allow_in_control, :allow_in_post_mortem
-
-      attr_writer :always_run
-
-      def always_run
-        @always_run ||= 0
-      end
-
-      #
-      # Name of the command, as executed by the user.
-      #
-      def to_s
-        name
-          .split('::')
-          .map { |n| n.gsub(/Command$/, '').downcase if n =~ /Command$/ }
-          .compact
-          .join(' ')
-      end
-
-      def columnize(width)
-        format("  %-#{width}s -- %s\n", to_s, short_description)
-      end
-
-      #
-      # Default help text for a command.
-      #
-      def help
-        prettify(description)
-      end
-
-      #
-      # Command's regexp match against an input
-      #
-      def match(input)
-        regexp.match(input)
-      end
-    end
-  end
-end

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

@@ -1,32 +0,0 @@
-require 'byebug/errors'
-
-module Byebug
-  #
-  # Holds an array of subcommands for a command
-  #
-  class CommandList
-    include Enumerable
-
-    def initialize(commands)
-      @commands = commands.sort_by(&:to_s)
-    end
-
-    def match(input)
-      find { |cmd| cmd.match(input) }
-    end
-
-    def each
-      @commands.each { |cmd| yield(cmd) }
-    end
-
-    def to_s
-      "\n" + map { |cmd| cmd.columnize(width) }.join + "\n"
-    end
-
-    private
-
-    def width
-      @width ||= map(&:to_s).max_by(&:size).size
-    end
-  end
-end

data/vendor/bundle/ruby/2.3.0/gems/byebug-9.1.0/lib/byebug/commands/break.rb

@@ -1,98 +0,0 @@
-require 'byebug/command'
-require 'byebug/helpers/eval'
-require 'byebug/helpers/file'
-require 'byebug/helpers/parse'
-
-module Byebug
-  #
-  # Implements breakpoint functionality
-  #
-  class BreakCommand < Command
-    include Helpers::EvalHelper
-    include Helpers::FileHelper
-    include Helpers::ParseHelper
-
-    self.allow_in_control = true
-
-    def self.regexp
-      /^\s* b(?:reak)? (?:\s+ (.+?))? (?:\s+ if \s+(.+))? \s*$/x
-    end
-
-    def self.description
-      <<-EOD
-        b[reak] [file:]line [if expr]
-        b[reak] [module::...]class(.|#)method [if expr]
-
-        They can be specified by line or method and an expression can be added
-        for conditionally enabled breakpoints.
-
-        #{short_description}
-      EOD
-    end
-
-    def self.short_description
-      'Sets breakpoints in the source code'
-    end
-
-    def execute
-      return puts(help) unless @match[1]
-
-      b = line_breakpoint(@match[1]) || method_breakpoint(@match[1])
-      return errmsg(pr('break.errors.location')) unless b
-
-      if syntax_valid?(@match[2])
-        return puts(pr('break.created', id: b.id, file: b.source, line: b.pos))
-      end
-
-      errmsg(pr('break.errors.expression', expr: @match[2]))
-      b.enabled = false
-    end
-
-    private
-
-    def line_breakpoint(location)
-      line_match = location.match(/^(\d+)$/)
-      file_line_match = location.match(/^(.+):(\d+)$/)
-      return unless line_match || file_line_match
-
-      file = line_match ? frame.file : file_line_match[1]
-      line = line_match ? line_match[1].to_i : file_line_match[2].to_i
-
-      add_line_breakpoint(file, line)
-    end
-
-    def method_breakpoint(location)
-      location.match(/([^.#]+)[.#](.+)/) do |match|
-        klass = target_object(match[1])
-        method = match[2].intern
-
-        Breakpoint.add(klass, method, @match[2])
-      end
-    end
-
-    def target_object(str)
-      k = error_eval(str)
-
-      k && k.is_a?(Module) ? k.name : str
-    rescue
-      errmsg('Warning: breakpoint source is not yet defined')
-      str
-    end
-
-    def add_line_breakpoint(file, line)
-      raise(pr('break.errors.source', file: file)) unless File.exist?(file)
-
-      fullpath = File.realpath(file)
-
-      if line > n_lines(file)
-        raise(pr('break.errors.far_line', lines: n_lines(file), file: fullpath))
-      end
-
-      unless Breakpoint.potential_line?(fullpath, line)
-        raise(pr('break.errors.line', file: fullpath, line: line))
-      end
-
-      Breakpoint.add(fullpath, line, @match[2])
-    end
-  end
-end