readapt 0.3.5 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e4b5e04188dcfb29b88bd7d6ffaecab9e9d6803e6dc4d376b925e672007f1b5f
-  data.tar.gz: 4feb9f343b159051ad41e45c93ee27e37d2da8d6fd5a7c2a5e09d3447956c8a2
+  metadata.gz: e935059da5afc7fe4f6a68e6574ad096dcf90c2b166b81f3c0e50260e3d740ba
+  data.tar.gz: 26f8dce0349345c4f0fa5953f179e833c8848e5cf90f57632661f97603967d4b
 SHA512:
-  metadata.gz: 7f45a365a1baa3217b6480755e6ad77bf8ac096b19e522c5770801682675b4c7261b21e66c21c2e75e8c8784b822fc5d31fc6001f3c62b0763a2a6c049e02bf4
-  data.tar.gz: 1cd6ca54346c2a4d9caac8516a25ab0e4e7f71773f9ff3b7b8b2a3651e582059f9bfd61d721813e59fc81be4b08c6ea5631c90621268da0b3a7824bbaafd784c
+  metadata.gz: 979309cb99c3e4eb81768965b2a564ae14dd057f424383b28ae4e9f4a38dded3a2afc135aaca70d04207e470fd241c195ed207ae4712e98e6efbf19ae79ec6a2
+  data.tar.gz: a22d57be02bb01fb3535cb7c6c3047dcb33ec6a132ead776dbea44022924cfe026de4e99eb28632e6690a3a0e920f78d2131f2a7f5dac70ecb6dda939b79e4fb

data/.rspec

@@ -1,3 +1,2 @@
---format documentation
 --color
 --require spec_helper

data/CHANGELOG.md

@@ -1,3 +1,7 @@
+# 0.4.0 - August 19. 2019
+- Breakpoints use C implementation of hash tables
+- Simplified entry point detection
+
 # 0.3.5 - August 16, 2019
 - Variables message checks for null frames
 

data/ext/readapt/breakpoints.c

@@ -0,0 +1,88 @@
+#include "ruby.h"
+#include "hash_table.h"
+
+static VALUE m_Breakpoints;
+ht_hash_table *ht;
+
+void breakpoints_set(char *file, long *lines)
+{
+
+}
+
+static VALUE breakpoints_set_s(VALUE self, VALUE file, VALUE lines)
+{
+    long length = NUM2LONG(rb_funcall(lines, rb_intern("length"), 0));
+    long *ll;
+    long i;
+
+    ll = malloc(sizeof(long) * length);
+    for (i = 0; i < length; i++)
+    {
+        ll[i] = NUM2LONG(rb_ary_entry(lines, i));
+    }
+    ht_insert(ht, StringValueCStr(file), ll, length);
+    free(ll);
+    return Qnil;
+}
+
+void breakpoints_delete(char *file)
+{
+
+}
+
+static VALUE breakpoints_delete_s(VALUE self, VALUE file)
+{
+    return Qnil;
+}
+
+int breakpoints_match(char *file, long line)
+{
+    ht_long_array *lines;
+    long i;
+
+    lines = ht_search(ht, file);
+    if (lines != NULL)
+    {
+        for (i = 0; i < lines->size; i++)
+        {
+            if (lines->items[i] == line)
+            {
+                return 1;
+            }
+        }
+    }
+    return 0;
+}
+
+// int breakpoints_match(char *file, long line)
+// {
+//     return breakpoints_match_id(rb_intern(file), line);
+// }
+
+static VALUE breakpoints_match_s(VALUE self, VALUE file, VALUE line)
+{
+    return breakpoints_match(StringValueCStr(file), NUM2LONG(line)) == 0 ? Qfalse : Qtrue;
+}
+
+static VALUE breakpoints_clear_s(VALUE self)
+{
+    ht_del_hash_table(ht);
+    ht = ht_new();
+    return Qnil;
+}
+
+long breakpoints_files()
+{
+    return ht->size;
+}
+
+void initialize_breakpoints(VALUE m_Readapt)
+{
+    m_Breakpoints = rb_define_module_under(m_Readapt, "Breakpoints");
+    rb_define_singleton_method(m_Breakpoints, "set", breakpoints_set_s, 2);
+    rb_define_singleton_method(m_Breakpoints, "delete", breakpoints_delete_s, 1);
+    rb_define_singleton_method(m_Breakpoints, "match", breakpoints_match_s, 2);
+    rb_define_singleton_method(m_Breakpoints, "clear", breakpoints_clear_s, 0);
+
+    ht = ht_new(); // TODO Need to free?
+}

data/ext/readapt/breakpoints.h

@@ -0,0 +1,12 @@
+#ifndef BREAKPOINTS_H_
+#define BREAKPOINTS_H_
+
+void initialize_breakpoints(VALUE m_Readapt);
+
+void breakpoints_set(char *file, long *lines);
+void breakpoints_delete(char *file);
+int breakpoints_match(char *file, long line);
+// int breakpoints_match_id(ht_key file, long line);
+long breakpoints_files();
+
+#endif

data/ext/readapt/hash_table.c

@@ -0,0 +1,216 @@
+#include <math.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "hash_table.h"
+#include "ruby.h"
+
+static ht_long_array *copy_array(const long *value, const long size)
+{
+    long i;
+    long *items = malloc(sizeof(long) * size);
+    ht_long_array *result;
+
+    for (i = 0; i < size; i++)
+    {
+        items[i] = value[i];
+    }
+    result = malloc(sizeof(ht_long_array));
+    result->items = (size ? items : NULL);
+    result->size = size;
+    return result;
+}
+
+/*
+ * Initialize a new item
+ */
+static ht_item *ht_new_item(char *key, const long *value, const long size)
+{
+    ht_item *i = malloc(sizeof(ht_item));
+    i->key = malloc(sizeof(char) * (strlen(key) + 1));
+    strcpy(i->key, key);
+    i->value = copy_array(value, size);
+    return i;
+}
+
+/*
+ * Delete the ht_item
+ */
+static void ht_del_item(ht_item *i)
+{
+    free(i->key);
+    free(i->value->items);
+    free(i);
+}
+
+/*
+ * Initialize a new empty hash table
+ */
+ht_hash_table *ht_new()
+{
+    ht_hash_table *ht = malloc(sizeof(ht_hash_table));
+    ht->items = NULL;
+    ht->size = 0;
+    return ht;
+}
+
+/*
+ * Delete the hash table
+ */
+void ht_del_hash_table(ht_hash_table *ht)
+{
+    int i;
+    ht_item *item;
+
+    // Iterate through items and delete any that are found
+    for (i = 0; i < ht->size; i++)
+    {
+        item = ht->items[i];
+        ht_del_item(item);
+    }
+    free(ht->items);
+    free(ht);
+}
+
+static ht_long_array *ht_search_part(ht_hash_table *ht, char *key, long cursor, long next)
+{
+    int cmp;
+
+    if (cursor >= ht->size)
+    {
+        return NULL;
+    }
+
+    cmp = strcmp(ht->items[cursor]->key, key);
+    if (cmp == 0)
+    {
+        return ht->items[cursor]->value;
+    }
+    if (next > cursor && next < ht->size)
+    {
+        cmp = strcmp(ht->items[next]->key, key);
+        if (cmp == 0)
+        {
+            return ht->items[next]->value;
+        }
+        else if (cmp < 0)
+        {
+            return ht_search_part(ht, key, next + 1, next + ((ht->size - next) / 2));
+        }
+        else
+        {
+            return ht_search_part(ht, key, cursor + 1, next / 2);
+        }
+    }
+    return ht_search_part(ht, key, cursor + 1, next / 2);
+}
+
+static ht_long_array *ht_search_key(ht_hash_table *ht, char *key)
+{
+    return ht_search_part(ht, key, 0, ht->size / 2);
+}
+
+static void ht_delete_key(ht_hash_table *ht, char *key)
+{
+    ht_long_array *found;
+    ht_item **tmp;
+    long i;
+    long cursor = 0;
+
+    found = ht_search_key(ht, key);
+    if (found)
+    {
+        tmp = malloc(sizeof(ht_item) * (ht->size - 1));
+        for (i = 0; i < ht->size; i++)
+        {
+            if (ht->items[i]->key == key)
+            {
+                ht_del_item(ht->items[i]);
+            }
+            else
+            {
+                tmp[cursor] = ht->items[cursor];
+                cursor++;
+            }
+        }
+        free(ht->items);
+        ht->items = tmp;
+        ht->size--;
+    }
+}
+
+static void ht_insert_key(ht_hash_table *ht, char *key, const long *value, const long size)
+{
+    ht_item *item;
+    ht_item **tmp;
+    long i;
+    long cursor = 0;
+    int inserted = 0;
+    int cmp;
+
+    ht_delete_key(ht, key);
+
+    if (size == 0)
+    {
+        return;
+    }
+
+    item = ht_new_item(key, value, size);
+    tmp = malloc(sizeof(ht_item) * (ht->size + 1));
+
+    for (i = 0; i <= ht->size; i++)
+    {
+        if (!inserted)
+        {
+            if (i == ht->size)
+            {
+                tmp[i] = item;
+                inserted = 1;
+            }
+            else
+            {
+                cmp = strcmp(item->key, ht->items[i]->key);
+                if (cmp > 0)
+                {
+                    tmp[i] = item;
+                    tmp[i + 1] = ht->items[cursor];
+                    inserted = 1;
+                    cursor++;
+                    i++;
+                }
+            }
+        }
+        else
+        {
+            tmp[i] = ht->items[cursor];
+            cursor++;
+        }
+    }
+    free(ht->items);
+    ht->items = tmp;
+    ht->size++;
+}
+
+/*
+ * Add an item to the hash table
+ */
+void ht_insert(ht_hash_table *ht, char *key, const long *value, const long size)
+{
+    ht_insert_key(ht, key, value, size);
+}
+
+/*
+ * Get the key's value or NULL if it doesn't exist
+ */
+ht_long_array *ht_search(ht_hash_table *ht, char *key)
+{
+    return ht_search_key(ht, key);
+}
+
+/*
+ * Delete the key's item if it exists
+ */
+void ht_delete(ht_hash_table *ht, char *key)
+{
+    ht_delete_key(ht, key);
+}

data/ext/readapt/hash_table.h

@@ -0,0 +1,32 @@
+#ifndef HASH_TABLE_H_
+#define HASH_TABLE_H_
+
+#include "ruby.h"
+
+typedef struct ht_long_array
+{
+    long *items;
+    long size;
+} ht_long_array;
+
+// ht_item is an item in the hash table
+typedef struct ht_item
+{
+    char *key;
+    ht_long_array *value;
+} ht_item;
+
+typedef struct ht_hash_table
+{
+    long size;
+    ht_item **items;
+} ht_hash_table;
+
+ht_hash_table *ht_new();
+void ht_del_hash_table(ht_hash_table *ht);
+
+void ht_insert(ht_hash_table *ht, char *key, const long *value, const long size);
+ht_long_array *ht_search(ht_hash_table *ht, char *key);
+void ht_delete(ht_hash_table *h, char *key);
+
+#endif // HASH_TABLE_H_

data/ext/readapt/monitor.c

@@ -2,6 +2,7 @@
 #include "ruby/debug.h"
 #include "threads.h"
 #include "normalize.h"
+#include "breakpoints.h"
 
 static VALUE readapt;
 static VALUE m_Monitor;
@@ -14,39 +15,16 @@ static VALUE tpReturn;
 static VALUE tpThreadBegin;
 static VALUE tpThreadEnd;
 static VALUE debugProc;
-static VALUE breakpoints;
-static int knownBreakpoints;
 static int firstLineEvent = 0;
+static VALUE entryFile;
 
-static int match_line(VALUE next_file, int next_line, thread_reference_t *ptr)
-{
-	if (rb_str_equal(next_file, ptr->prev_file) && next_line == ptr->prev_line) {
-		return 1;
-	}
-	return 0;
-}
-
-static int match_breakpoint(VALUE file, int line)
-{
-	VALUE bps, b;
-	long len, i;
-
-	bps = rb_funcall(breakpoints, rb_intern("for"), 1, file);
-	len = rb_array_len(bps);
-	for (i = 0; i < len; i++)
-	{
-		b = rb_ary_entry(bps, i);
-		if (NUM2INT(rb_funcall(b, rb_intern("line"), 0)) == line)
-		{
-			return 1;
-		}
-	}
-	return 0;
-}
+static ID id_continue;
+static ID id_pause;
+static ID id_entry;
 
 static int match_step(thread_reference_t *ptr)
 {
-	if (ptr->control == rb_intern("continue"))
+	if (ptr->control == id_continue)
 	{
 		return 0;
 	}
@@ -66,7 +44,7 @@ static int match_step(thread_reference_t *ptr)
 }
 
 static ID
-monitor_debug(VALUE file, int line, VALUE tracepoint, thread_reference_t *ptr, ID event)
+monitor_debug(VALUE file, long line, VALUE tracepoint, thread_reference_t *ptr, ID event)
 {
 	VALUE bind, bid, snapshot, result;
 
@@ -90,8 +68,6 @@ monitor_debug(VALUE file, int line, VALUE tracepoint, thread_reference_t *ptr, I
 		ptr->cursor = ptr->depth;
 		ptr->control = result;
 	}
-	ptr->prev_file = file;
-	ptr->prev_line = line;
 	return result;
 }
 
@@ -99,67 +75,57 @@ static void
 process_line_event(VALUE tracepoint, void *data)
 {
 	VALUE ref, tp_file;
-	int tp_line;
+	long tp_line;
 	thread_reference_t *ptr;
 	rb_trace_arg_t *tp;
 	int threadPaused;
-	ID dapEvent, result;
+	ID dapEvent;
 
 	ref = thread_current_reference();
 	if (ref != Qnil)
 	{
 		ptr = thread_reference_pointer(ref);
-		if (ptr->depth > 0 /*|| !firstLineEvent*/)
+		if (ptr->depth > 0)
 		{
-			threadPaused = (ptr->control == rb_intern("pause"));
-			if (!firstLineEvent || threadPaused || knownBreakpoints || ptr->control != rb_intern("continue"))
+			threadPaused = (ptr->control == id_pause);
+			if (firstLineEvent && ptr->control == id_continue && breakpoints_files() == 0)
 			{
-				tp = rb_tracearg_from_tracepoint(tracepoint);
-				tp_file = normalize_path(rb_tracearg_path(tp));
-				tp_line = NUM2INT(rb_tracearg_lineno(tp));
-
-				dapEvent = rb_intern("continue");
-				if (!firstLineEvent)
-				{
-					dapEvent = rb_intern("initialize");
-				}
-				else if (threadPaused)
-				{
-					dapEvent = rb_intern("pause");
-				}
-				else if (match_step(ptr))
-				{
-					dapEvent = rb_intern("step");
-				}
-				else if (match_breakpoint(tp_file, tp_line))
-				{
-					dapEvent = rb_intern("breakpoint");
-				}
-				else if (ptr->control == rb_intern("entry"))
-				{
-					dapEvent = rb_intern("entry");
-				}
+				return;
+			}
+			tp = rb_tracearg_from_tracepoint(tracepoint);
+			tp_file = normalize_path(rb_tracearg_path(tp));
+			tp_line = NUM2LONG(rb_tracearg_lineno(tp));
 
-				if (dapEvent != rb_intern("continue"))
-				{
-					result = monitor_debug(tp_file, tp_line, tracepoint, ptr, dapEvent);
-					if (dapEvent == rb_intern("initialize") && result == rb_intern("ready"))
-					{
-						firstLineEvent = 1;
-						ptr->control = rb_intern("entry");
-						process_line_event(tracepoint, data);
-					}
-				}
-				else
+			dapEvent = id_continue;
+			if (!firstLineEvent)
+			{
+				if (rb_str_equal(tp_file, entryFile))
 				{
-					ptr->prev_file = Qnil;
-					ptr->prev_line = Qnil;
+					firstLineEvent = 1;
+					ptr->control = rb_intern("entry");
+					process_line_event(tracepoint, data);
 				}
 			}
-			else
+			else if (threadPaused)
+			{
+				dapEvent = id_pause;
+			}
+			else if (match_step(ptr))
+			{
+				dapEvent = rb_intern("step");
+			}
+			else if (breakpoints_match(StringValueCStr(tp_file), tp_line))
+			{
+				dapEvent = rb_intern("breakpoint");
+			}
+			else if (ptr->control == id_entry)
+			{
+				dapEvent = id_entry;
+			}
+
+			if (dapEvent != id_continue)
 			{
-				ptr->prev_file = Qnil;
-				ptr->prev_line = Qnil;
+				monitor_debug(tp_file, tp_line, tracepoint, ptr, dapEvent);
 			}
 		}
 	}
@@ -214,7 +180,7 @@ process_thread_begin_event(VALUE tracepoint, void *data)
 					ptr = thread_reference_pointer(ref);
 					monitor_debug(
 						rb_funcall(tracepoint, rb_intern("path"), 0),
-						NUM2INT(rb_funcall(tracepoint, rb_intern("lineno"), 0)),
+						NUM2LONG(rb_funcall(tracepoint, rb_intern("lineno"), 0)),
 						tracepoint,
 						ptr,
 						rb_intern("thread_begin")
@@ -236,13 +202,13 @@ process_thread_end_event(VALUE tracepoint, void *data)
 	if (ref != Qnil)
 	{
 		ptr = thread_reference_pointer(ref);
-		monitor_debug(ptr->prev_file, ptr->prev_line, tracepoint, ptr, rb_intern("thread_end"));
+		monitor_debug(rb_funcall(tracepoint, rb_intern("path"), 0), NUM2LONG(rb_funcall(tracepoint, rb_intern("lineno"), 0)), tracepoint, ptr, rb_intern("thread_end"));
 		thread_delete_reference(thr);
 	}
 }
 
 static VALUE
-monitor_enable_s(VALUE self)
+monitor_enable_s(VALUE self, VALUE file)
 {
 	VALUE previous, ref;
 	thread_reference_t *ptr;
@@ -254,7 +220,8 @@ monitor_enable_s(VALUE self)
 		rb_raise(rb_eArgError, "must be called with a block");
 	}
 
-	firstLineEvent = 0;
+	entryFile = file;
+	firstLineEvent = (entryFile == Qnil ? 1 : 0);
 
 	ref = thread_add_reference(rb_thread_current());
 	ptr = thread_reference_pointer(ref);
@@ -286,7 +253,7 @@ monitor_disable_s(VALUE self)
 	rb_tracepoint_disable(tpReturn);
 	rb_tracepoint_disable(tpThreadBegin);
 	rb_tracepoint_disable(tpThreadEnd);
-	
+
 	return previous;
 }
 
@@ -302,12 +269,6 @@ monitor_pause_s(VALUE self, VALUE id)
 		ptr = thread_reference_pointer(ref);
 		ptr->control = rb_intern("pause");
 	}
-}
-
-static VALUE
-monitor_know_breakpoints_s(VALUE self)
-{
-	knownBreakpoints = (rb_funcall(breakpoints, rb_intern("empty?"), 0) == Qfalse) ? 1 : 0;
 	return Qnil;
 }
 
@@ -319,9 +280,8 @@ void initialize_monitor(VALUE m_Readapt)
 
 	initialize_threads();
 
-	rb_define_singleton_method(m_Monitor, "start", monitor_enable_s, 0);
+	rb_define_singleton_method(m_Monitor, "start", monitor_enable_s, 1);
 	rb_define_singleton_method(m_Monitor, "stop", monitor_disable_s, 0);
-	rb_define_singleton_method(m_Monitor, "know_breakpoints", monitor_know_breakpoints_s, 0);
 	rb_define_singleton_method(m_Monitor, "pause", monitor_pause_s, 1);
 
 	tpLine = rb_tracepoint_new(Qnil, RUBY_EVENT_LINE, process_line_event, NULL);
@@ -330,8 +290,10 @@ void initialize_monitor(VALUE m_Readapt)
 	tpThreadBegin = rb_tracepoint_new(Qnil, RUBY_EVENT_THREAD_BEGIN, process_thread_begin_event, NULL);
 	tpThreadEnd = rb_tracepoint_new(Qnil, RUBY_EVENT_THREAD_END, process_thread_end_event, NULL);
 	debugProc = Qnil;
-	breakpoints = rb_funcall(m_Monitor, rb_intern("breakpoints"), 0);
-	knownBreakpoints = 0;
+
+	id_continue = rb_intern("continue");
+	id_pause = rb_intern("pause");
+	id_entry = rb_intern("entry");
 
 	// Avoid garbage collection
 	rb_global_variable(&tpLine);
@@ -339,4 +301,5 @@ void initialize_monitor(VALUE m_Readapt)
 	rb_global_variable(&tpReturn);
 	rb_global_variable(&tpThreadBegin);
 	rb_global_variable(&tpThreadEnd);
+	rb_global_variable(&entryFile);
 }

data/ext/readapt/monitor.h

@@ -1 +1,6 @@
+#ifndef MONITOR_H_
+#define MONITOR_H_
+
 void initialize_monitor(VALUE);
+
+#endif

data/ext/readapt/normalize.c

@@ -1,5 +1,6 @@
 #include "ruby.h"
 #include "ruby/debug.h"
+#include <ctype.h>
 
 static int isWindows;
 

data/ext/readapt/normalize.h

@@ -1,2 +1,7 @@
+#ifndef NORMALIZE_H_
+#define NORMALIZE_H_
+
 void initialize_normalize(VALUE);
 VALUE normalize_path(VALUE);
+
+#endif

data/ext/readapt/readapt.c

@@ -2,6 +2,7 @@
 #include "ruby/debug.h"
 #include "monitor.h"
 #include "normalize.h"
+#include "breakpoints.h"
 
 static VALUE m_Readapt;
 
@@ -10,5 +11,6 @@ void Init_readapt()
 	m_Readapt = rb_define_module("Readapt");
 
 	initialize_normalize(m_Readapt);
+	initialize_breakpoints(m_Readapt);
 	initialize_monitor(m_Readapt);
 }

data/ext/readapt/threads.h

@@ -1,9 +1,10 @@
+#ifndef THREADS_H_
+#define THREADS_H_
+
 typedef struct thread_reference_struct {
 	long id;
 	int depth;
 	int cursor;
-	VALUE prev_file;
-	int prev_line;
 	ID control;
 } thread_reference_t;
 
@@ -16,3 +17,5 @@ VALUE thread_delete_reference(VALUE);
 thread_reference_t *thread_reference_pointer(VALUE);
 void thread_pause();
 void thread_reset();
+
+#endif

data/lib/readapt.rb

@@ -1,9 +1,7 @@
 require 'backport'
 
-require "readapt/version"
+require 'readapt/version'
 require 'readapt/location'
-require 'readapt/breakpoint'
-require 'readapt/breakpoints'
 require 'readapt/thread'
 require 'readapt/frame'
 require 'readapt/monitor'

data/lib/readapt/debugger.rb

@@ -67,7 +67,7 @@ module Readapt
       send_event('process', {
         name: @file
       })
-      Monitor.start do |snapshot|
+      Monitor.start @file do |snapshot|
         debug snapshot
       end
       yield if block_given?
@@ -123,12 +123,6 @@ module Readapt
           threadId: snapshot.thread_id
         })
         snapshot.control = :continue
-      elsif snapshot.event == :initialize
-        if snapshot.file != @file
-          snapshot.control = :wait
-        else
-          snapshot.control = :ready
-        end
       elsif snapshot.event == :entry
         snapshot.control = :continue
       else

data/lib/readapt/message/set_breakpoints.rb

@@ -5,21 +5,16 @@ module Readapt
     class SetBreakpoints < Base
       def run
         path = Readapt.normalize_path(arguments['source']['path'])
-        Monitor.breakpoints.clear path
-        result = arguments['lines'].map do |l|
-          # @todo Assuming breakpoints are verified
-          Breakpoint.new(path, l, true)
-        end
-        Monitor.breakpoints.concat result
-        set_body({
-          breakpoints: result.map { |bp|
+        Breakpoints.set(path, arguments['lines'])
+        set_body(
+          breakpoints: arguments['lines'].map do |l|
             {
-              verified: bp.verified,
+              verified: true, # @todo Verify
               source: arguments['source'],
-              line: bp.line
+              line: l
             }
-          }
-        })
+          end
+        )
       end
     end
   end

data/lib/readapt/monitor.rb

@@ -11,21 +11,5 @@ module Readapt
   #   Disable tracepoints.
   #   @return [Boolean]
   module Monitor
-    @@breakpoints = Breakpoints.new
-
-    # @return [Breakpoints]
-    def self.breakpoints
-      @@breakpoints
-    end
-
-    def self.set_breakpoints bps
-      @@breakpoints = bps
-    end
-
-    def self.update
-      know_breakpoints
-    end
-
-    @@breakpoints.add_observer self
   end
 end

data/lib/readapt/version.rb

@@ -1,3 +1,3 @@
 module Readapt
-  VERSION = "0.3.5"
+  VERSION = "0.4.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: readapt
 version: !ruby/object:Gem::Version
-  version: 0.3.5
+  version: 0.4.0
 platform: ruby
 authors:
 - Fred Snyder
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-08-16 00:00:00.000000000 Z
+date: 2019-08-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: backport
@@ -116,7 +116,11 @@ files:
 - bin/console
 - bin/setup
 - exe/readapt
+- ext/readapt/breakpoints.c
+- ext/readapt/breakpoints.h
 - ext/readapt/extconf.rb
+- ext/readapt/hash_table.c
+- ext/readapt/hash_table.h
 - ext/readapt/monitor.c
 - ext/readapt/monitor.h
 - ext/readapt/normalize.c
@@ -126,8 +130,6 @@ files:
 - ext/readapt/threads.h
 - lib/readapt.rb
 - lib/readapt/adapter.rb
-- lib/readapt/breakpoint.rb
-- lib/readapt/breakpoints.rb
 - lib/readapt/debugger.rb
 - lib/readapt/finder.rb
 - lib/readapt/frame.rb

data/lib/readapt/breakpoint.rb

@@ -1,16 +0,0 @@
-# frozen_string_literal: true
-
-module Readapt
-  class Breakpoint < Location
-    attr_reader :verified
-
-    def initialize file, line, verified = true
-      super(file, line)
-      @verified = verified
-    end
-
-    def enabled?
-      @verified
-    end
-  end
-end

data/lib/readapt/breakpoints.rb

@@ -1,58 +0,0 @@
-require 'observer'
-
-module Readapt
-  class Breakpoints
-    include Observable
-
-    def initialize
-      @sources = {}
-      @concatting = false
-    end
-
-    # @return [Array<String>]
-    def sources
-      @sources.keys
-    end
-
-    # @param breakpoint [Breakpoint]
-    # @return [void]
-    def add breakpoint
-      @sources[breakpoint.file] ||= []
-      @sources[breakpoint.file].push breakpoint
-      changed
-      notify_observers unless @concatting
-    end
-
-    # @param breakpoints [Array<Breakpoint>]
-    # @return [void]
-    def concat breakpoints
-      @concatting = true
-      breakpoints.each { |bp| add bp }
-      @concatting = false
-      notify_observers
-    end
-
-    # @param file [String]
-    # @return [void]
-    def clear file
-      @sources.delete file
-      changed
-      notify_observers
-    end
-
-    # @param file [String]
-    # @return [Array<Breakpoint>]
-    def for file
-      @sources[file] || []
-    end
-
-    # @return [Array<Breakpoint>]
-    def all
-      @sources.values.flatten
-    end
-
-    def empty?
-      @sources.empty?
-    end
-  end
-end