Class: FastCov::Coverage

Inherits:

Object

• Object
• FastCov::Coverage

Defined in:

ext/fast_cov/fast_cov.c

Instance Method Summary

• #initialize(*args) ⇒ Object constructor

  —- Ruby instance methods ———————————————-.

• #start ⇒ Object
• #stop ⇒ Object

Constructor Details

#initialize(*args) ⇒ Object

—- Ruby instance methods ———————————————-

# File 'ext/fast_cov/fast_cov.c', line 145

static VALUE fast_cov_initialize(int argc, VALUE *argv, VALUE self) {
  VALUE opt;
  rb_scan_args(argc, argv, "01", &opt);
  if (NIL_P(opt)) opt = rb_hash_new();

  // root: defaults to Dir.pwd
  VALUE rb_root = rb_hash_lookup(opt, ID2SYM(rb_intern("root")));
  if (!RTEST(rb_root)) {
    rb_root = rb_funcall(rb_cDir, rb_intern("pwd"), 0);
  }
  Check_Type(rb_root, T_STRING);

  // ignored_paths: optional array, [] if not provided
  VALUE rb_ignored_paths =
      rb_hash_lookup(opt, ID2SYM(rb_intern("ignored_paths")));
  if (!NIL_P(rb_ignored_paths)) {
    Check_Type(rb_ignored_paths, T_ARRAY);
  }

  // threads: true (multi) or false (single), defaults to true
  VALUE rb_threads = rb_hash_lookup(opt, ID2SYM(rb_intern("threads")));
  bool threads = (rb_threads != Qfalse);

  struct fast_cov_data *data;
  TypedData_Get_Struct(self, struct fast_cov_data, &fast_cov_data_type, data);

  char *root = fast_cov_ruby_strndup(RSTRING_PTR(rb_root), RSTRING_LEN(rb_root));

  data->threads = threads;
  if (data->root) xfree(data->root);
  data->root = root;
  data->root_len = RSTRING_LEN(rb_root);

  if (data->ignored_paths) {
    long i;
    for (i = 0; i < data->ignored_paths_count; i++) {
      xfree(data->ignored_paths[i]);
    }
    xfree(data->ignored_paths);
    data->ignored_paths = NULL;
  }
  if (data->ignored_path_lens) {
    xfree(data->ignored_path_lens);
    data->ignored_path_lens = NULL;
  }
  data->ignored_paths_count = 0;

  if (!NIL_P(rb_ignored_paths) && RARRAY_LEN(rb_ignored_paths) > 0) {
    long i;
    long ignored_paths_count = RARRAY_LEN(rb_ignored_paths);

    for (i = 0; i < ignored_paths_count; i++) {
      Check_Type(rb_ary_entry(rb_ignored_paths, i), T_STRING);
    }

    data->ignored_paths_count = ignored_paths_count;
    data->ignored_paths = xcalloc(data->ignored_paths_count, sizeof(char *));
    data->ignored_path_lens = xcalloc(data->ignored_paths_count, sizeof(long));

    for (i = 0; i < data->ignored_paths_count; i++) {
      VALUE rb_ignored_path = rb_ary_entry(rb_ignored_paths, i);

      data->ignored_path_lens[i] = RSTRING_LEN(rb_ignored_path);
      data->ignored_paths[i] =
          fast_cov_ruby_strndup(RSTRING_PTR(rb_ignored_path),
                                data->ignored_path_lens[i]);
    }
  }

  return Qnil;
}

Instance Method Details

#start ⇒ Object

# File 'ext/fast_cov/fast_cov.c', line 217

static VALUE fast_cov_start(VALUE self) {
  struct fast_cov_data *data;
  TypedData_Get_Struct(self, struct fast_cov_data, &fast_cov_data_type, data);

  if (data->root_len == 0) {
    rb_raise(rb_eRuntimeError, "root is required");
  }

  if (data->started) {
    if (rb_block_given_p()) {
      rb_raise(rb_eRuntimeError, "Coverage is already started");
    }
    return self;
  }

  if (!data->threads) {
    VALUE thval = rb_thread_current();
    rb_thread_add_event_hook(thval, on_line_event, RUBY_EVENT_LINE, self);
    data->th_covered = thval;
  } else {
    rb_add_event_hook(on_line_event, RUBY_EVENT_LINE, self);
  }
  data->started = true;

  // Block form: start { ... } runs the block then returns stop result
  if (rb_block_given_p()) {
    int exception_state = 0;
    rb_protect(fast_cov_yield_block, Qnil, &exception_state);
    VALUE result = fast_cov_stop(self);
    if (exception_state != 0) {
      rb_jump_tag(exception_state);
    }
    return result;
  }

  return self;
}

#stop ⇒ Object

# File 'ext/fast_cov/fast_cov.c', line 255

static VALUE fast_cov_stop(VALUE self) {
  struct fast_cov_data *data;
  TypedData_Get_Struct(self, struct fast_cov_data, &fast_cov_data_type, data);

  if (!data->started) {
    return rb_hash_new();
  }

  if (!data->threads) {
    VALUE thval = rb_thread_current();
    if (thval != data->th_covered) {
      rb_raise(rb_eRuntimeError, "Coverage was not started by this thread");
    }
    rb_thread_remove_event_hook(data->th_covered, on_line_event);
    data->th_covered = Qnil;
  } else {
    rb_remove_event_hook(on_line_event);
  }

  VALUE res = data->impacted_files;

  data->impacted_files = rb_hash_new();
  data->last_filename_ptr = 0;
  data->started = false;

  return res;
}