yerba 0.4.2 → 0.5.0

data/ext/yerba/yerba.c

@@ -146,53 +146,6 @@ static VALUE document_s_parse(VALUE klass, VALUE content) {
   return instance;
 }
 
-/* document.get(path) */
-static VALUE document_get(VALUE self, VALUE path) {
-  struct Document *document = get_document(self);
-  YerbaGetResult result = yerba_document_get(document, StringValueCStr(path));
-
-  if (result.error) {
-    VALUE message = make_utf8_string(result.error);
-    yerba_get_result_free(result);
-
-    rb_raise(rb_ePathValidationError, "%s", StringValueCStr(message));
-  }
-
-  if (!result.is_list) {
-    VALUE ruby_value = typed_value_to_ruby(result.single);
-    yerba_get_result_free(result);
-
-    return ruby_value;
-  } else {
-    VALUE json_string = make_utf8_string(result.list.json);
-    yerba_get_result_free(result);
-
-    VALUE items = rb_funcall(rb_path2class("JSON"), rb_intern("parse"), 1, json_string);
-    long length = RARRAY_LEN(items);
-    VALUE array = rb_ary_new_capa(length);
-
-    for (long i = 0; i < length; i++) {
-      VALUE item = rb_ary_entry(items, i);
-      VALUE text = rb_hash_aref(item, rb_str_new_cstr("text"));
-      int type_value = NUM2INT(rb_hash_aref(item, rb_str_new_cstr("type")));
-
-      if (NIL_P(text)) {
-        rb_ary_push(array, Qnil);
-
-        continue;
-      }
-
-      YerbaTypedValue typed_value;
-      typed_value.text = (char *)StringValueCStr(text);
-      typed_value.value_type = (YerbaValueType)type_value;
-
-      rb_ary_push(array, typed_value_to_ruby(typed_value));
-    }
-
-    return array;
-  }
-}
-
 static VALUE location_to_ruby(YerbaLocation location) {
   VALUE klass = rb_path2class("Yerba::Location");
 
@@ -206,11 +159,9 @@ static VALUE location_to_ruby(YerbaLocation location) {
   );
 }
 
-/* document[](path) → Yerba::Scalar, Yerba::Map, Yerba::Sequence, or nil */
-static VALUE document_bracket(VALUE self, VALUE path) {
-  struct Document *document = get_document(self);
-  YerbaGetResult result = yerba_document_get(document, StringValueCStr(path));
-
+/* Build a Yerba::Scalar, Map, Sequence, or nil from a YerbaGetResult.
+   Frees the result internally. */
+static VALUE node_from_get_result(YerbaGetResult result, VALUE self, VALUE path) {
   if (result.error) {
     VALUE message = make_utf8_string(result.error);
     yerba_get_result_free(result);
@@ -218,7 +169,6 @@ static VALUE document_bracket(VALUE self, VALUE path) {
     rb_raise(rb_ePathValidationError, "%s", StringValueCStr(message));
   }
 
-  VALUE instance;
   VALUE location = location_to_ruby(result.location);
   VALUE key = Qnil;
 
@@ -226,37 +176,31 @@ static VALUE document_bracket(VALUE self, VALUE path) {
     VALUE key_location = location_to_ruby(result.key_location);
     VALUE key_value = make_utf8_string(result.key_name);
 
-    key = rb_funcall(rb_path2class("Yerba::Scalar"), rb_intern("new"), 4, Qnil, Qnil, key_value, key_location);
+    VALUE key_kwargs = rb_hash_new();
+    rb_hash_aset(key_kwargs, ID2SYM(rb_intern("value")), key_value);
+    key = rb_funcallv_kw(rb_path2class("Yerba::Scalar"), rb_intern("from_document"), 5, (VALUE[]){ Qnil, Qnil, key_location, Qnil, key_kwargs }, RB_PASS_KEYWORDS);
   }
 
   switch (result.node_type) {
     case NODE_TYPE_SCALAR: {
-      VALUE klass = rb_path2class("Yerba::Scalar");
       VALUE value = typed_value_to_ruby(result.single);
       yerba_get_result_free(result);
 
-      instance = rb_funcall(klass, rb_intern("new"), 5, self, path, value, location, key);
+      VALUE kwargs = rb_hash_new();
+      rb_hash_aset(kwargs, ID2SYM(rb_intern("value")), value);
 
-      return instance;
+      return rb_funcallv_kw(rb_path2class("Yerba::Scalar"), rb_intern("from_document"), 5, (VALUE[]){ self, path, location, key, kwargs }, RB_PASS_KEYWORDS);
     }
 
-    case NODE_TYPE_MAP: {
+    case NODE_TYPE_MAP:
       yerba_get_result_free(result);
-      VALUE klass = rb_path2class("Yerba::Map");
-
-      instance = rb_funcall(klass, rb_intern("new"), 4, self, path, location, key);
 
-      return instance;
-    }
+      return rb_funcall(rb_path2class("Yerba::Map"), rb_intern("from_document"), 4, self, path, location, key);
 
-    case NODE_TYPE_SEQUENCE: {
+    case NODE_TYPE_SEQUENCE:
       yerba_get_result_free(result);
-      VALUE klass = rb_path2class("Yerba::Sequence");
-
-      instance = rb_funcall(klass, rb_intern("new"), 4, self, path, location, key);
 
-      return instance;
-    }
+      return rb_funcall(rb_path2class("Yerba::Sequence"), rb_intern("from_document"), 4, self, path, location, key);
 
     default:
       yerba_get_result_free(result);
@@ -265,6 +209,47 @@ static VALUE document_bracket(VALUE self, VALUE path) {
   }
 }
 
+/* document[](path) → Yerba::Scalar, Yerba::Map, Yerba::Sequence, Array, or nil */
+static VALUE document_bracket(VALUE self, VALUE path) {
+  struct Document *document = get_document(self);
+  char index_buffer[32];
+
+  if (RB_TYPE_P(path, T_FIXNUM)) {
+    snprintf(index_buffer, sizeof(index_buffer), "[%ld]", FIX2LONG(path));
+    path = rb_str_new_cstr(index_buffer);
+  }
+
+  const char *selector = StringValueCStr(path);
+
+  /* Wildcard: resolve to concrete selectors and return array of nodes */
+  if (strstr(selector, "[]") != NULL) {
+    char *json = yerba_document_resolve_selectors(document, selector);
+
+    if (!json) return rb_ary_new();
+
+    VALUE json_string = make_utf8_string(json);
+    yerba_string_free(json);
+
+    VALUE resolved = rb_funcall(rb_path2class("JSON"), rb_intern("parse"), 1, json_string);
+    long length = RARRAY_LEN(resolved);
+    VALUE array = rb_ary_new_capa(length);
+
+    for (long i = 0; i < length; i++) {
+      VALUE concrete_path = rb_ary_entry(resolved, i);
+      YerbaGetResult result = yerba_document_get(document, StringValueCStr(concrete_path));
+      VALUE node = node_from_get_result(result, self, concrete_path);
+
+      if (!NIL_P(node)) rb_ary_push(array, node);
+    }
+
+    return array;
+  }
+
+  YerbaGetResult result = yerba_document_get(document, selector);
+
+  return node_from_get_result(result, self, path);
+}
+
 /* document.exists?(path) */
 static VALUE document_exists_p(VALUE self, VALUE path) {
   struct Document *document = get_document(self);
@@ -272,6 +257,13 @@ static VALUE document_exists_p(VALUE self, VALUE path) {
   return yerba_document_exists(document, StringValueCStr(path)) ? Qtrue : Qfalse;
 }
 
+/* document.valid_selector?(selector) → true/false */
+static VALUE document_valid_selector_p(VALUE self, VALUE path) {
+  struct Document *document = get_document(self);
+
+  return yerba_document_valid_selector(document, StringValueCStr(path)) ? Qtrue : Qfalse;
+}
+
 /* document.get_value(path) → parsed Ruby object (Hash/Array/String/Integer/etc) */
 static VALUE document_get_value(VALUE self, VALUE path) {
   struct Document *document = get_document(self);
@@ -285,10 +277,59 @@ static VALUE document_get_value(VALUE self, VALUE path) {
   return rb_funcall(rb_path2class("JSON"), rb_intern("parse"), 1, json_string);
 }
 
-/* document.get_values(path) → Array of parsed Ruby objects */
-static VALUE document_get_values(VALUE self, VALUE path) {
+/* document.selectors → ["database", "database.host", "tags", "tags[]", ...] */
+static VALUE document_selectors(VALUE self) {
   struct Document *document = get_document(self);
-  char *json = yerba_document_get_values(document, StringValueCStr(path));
+  char *json = yerba_document_selectors(document);
+
+  if (!json) return rb_ary_new();
+
+  VALUE json_string = make_utf8_string(json);
+  yerba_string_free(json);
+
+  return rb_funcall(rb_path2class("JSON"), rb_intern("parse"), 1, json_string);
+}
+
+/* document.locations(selector) → [Yerba::Location, ...] */
+static VALUE document_locations(VALUE self, VALUE path) {
+  struct Document *document = get_document(self);
+  char *json = yerba_document_resolve_selectors(document, StringValueCStr(path));
+
+  if (!json) return rb_ary_new();
+
+  VALUE json_string = make_utf8_string(json);
+  yerba_string_free(json);
+
+  VALUE resolved = rb_funcall(rb_path2class("JSON"), rb_intern("parse"), 1, json_string);
+  long length = RARRAY_LEN(resolved);
+  VALUE array = rb_ary_new_capa(length);
+
+  for (long i = 0; i < length; i++) {
+    VALUE concrete_path = rb_ary_entry(resolved, i);
+    YerbaGetResult result = yerba_document_get(document, StringValueCStr(concrete_path));
+
+    if (result.error) {
+      yerba_get_result_free(result);
+      continue;
+    }
+
+    if (result.location.start_line == 0 && result.location.end_line == 0) {
+      yerba_get_result_free(result);
+      continue;
+    }
+
+    VALUE location = location_to_ruby(result.location);
+    yerba_get_result_free(result);
+    rb_ary_push(array, location);
+  }
+
+  return array;
+}
+
+/* document.resolve_selectors(path) → ["[0].speakers[0]", "[0].speakers[1]", ...] */
+static VALUE document_resolve_selectors(VALUE self, VALUE path) {
+  struct Document *document = get_document(self);
+  char *json = yerba_document_resolve_selectors(document, StringValueCStr(path));
 
   if (!json) return rb_ary_new();
 
@@ -379,6 +420,41 @@ static VALUE document_find(int argc, VALUE *argv, VALUE self) {
   return rb_funcall(rb_path2class("JSON"), rb_intern("parse"), 1, json_string);
 }
 
+/* Convert a Ruby VALUE to a C string + YerbaValueType pair.
+   The caller must provide a number_buffer of at least 64 bytes. */
+struct TypedValue {
+  const char *text;
+  YerbaValueType type;
+};
+
+static struct TypedValue ruby_to_typed_value(VALUE value, char *number_buffer) {
+  struct TypedValue result;
+
+  if (value == Qnil) {
+    result.text = "null";
+    result.type = YERBA_VALUE_TYPE_NULL;
+  } else if (value == Qtrue) {
+    result.text = "true";
+    result.type = YERBA_VALUE_TYPE_BOOLEAN;
+  } else if (value == Qfalse) {
+    result.text = "false";
+    result.type = YERBA_VALUE_TYPE_BOOLEAN;
+  } else if (RB_INTEGER_TYPE_P(value)) {
+    snprintf(number_buffer, 64, "%ld", NUM2LONG(value));
+    result.text = number_buffer;
+    result.type = YERBA_VALUE_TYPE_INTEGER;
+  } else if (RB_FLOAT_TYPE_P(value)) {
+    snprintf(number_buffer, 64, "%g", NUM2DBL(value));
+    result.text = number_buffer;
+    result.type = YERBA_VALUE_TYPE_FLOAT;
+  } else {
+    result.text = StringValueCStr(value);
+    result.type = YERBA_VALUE_TYPE_STRING;
+  }
+
+  return result;
+}
+
 /* document.set(path, value, condition: nil, if_exists: false, if_missing: false) */
 static VALUE document_set(int argc, VALUE *argv, VALUE self) {
   VALUE path, value, opts;
@@ -396,40 +472,17 @@ static VALUE document_set(int argc, VALUE *argv, VALUE self) {
     if (RTEST(v_if_missing) && yerba_document_exists(document, StringValueCStr(path))) return self;
   }
 
-  const char *c_value;
-  YerbaValueType value_type;
   char number_buffer[64];
+  struct TypedValue typed_value = ruby_to_typed_value(value, number_buffer);
   bool all = false;
 
-  if (value == Qnil) {
-    c_value = "null";
-    value_type = YERBA_VALUE_TYPE_NULL;
-  } else if (value == Qtrue) {
-    c_value = "true";
-    value_type = YERBA_VALUE_TYPE_BOOLEAN;
-  } else if (value == Qfalse) {
-    c_value = "false";
-    value_type = YERBA_VALUE_TYPE_BOOLEAN;
-  } else if (RB_INTEGER_TYPE_P(value)) {
-    snprintf(number_buffer, sizeof(number_buffer), "%ld", NUM2LONG(value));
-    c_value = number_buffer;
-    value_type = YERBA_VALUE_TYPE_INTEGER;
-  } else if (RB_FLOAT_TYPE_P(value)) {
-    snprintf(number_buffer, sizeof(number_buffer), "%g", NUM2DBL(value));
-    c_value = number_buffer;
-    value_type = YERBA_VALUE_TYPE_FLOAT;
-  } else {
-    c_value = StringValueCStr(value);
-    value_type = YERBA_VALUE_TYPE_STRING;
-  }
-
   if (!NIL_P(opts)) {
     VALUE v_all = rb_hash_aref(opts, ID2SYM(rb_intern("all")));
 
     if (RTEST(v_all)) all = true;
   }
 
-  YerbaResult result = yerba_document_set(document, StringValueCStr(path), c_value, value_type, all);
+  YerbaResult result = yerba_document_set(document, StringValueCStr(path), typed_value.text, typed_value.type, all);
   check_result(result);
 
   return self;
@@ -454,8 +507,11 @@ static VALUE document_insert(int argc, VALUE *argv, VALUE self) {
     if (!NIL_P(v_at)) at = NUM2LL(v_at);
   }
 
+  char number_buffer[64];
+  struct TypedValue typed_value = ruby_to_typed_value(value, number_buffer);
+
   struct Document *document = get_document(self);
-  YerbaResult result = yerba_document_insert(document, StringValueCStr(path), StringValueCStr(value), before, after, at);
+  YerbaResult result = yerba_document_insert(document, StringValueCStr(path), typed_value.text, typed_value.type, before, after, at);
   check_result(result);
 
   return self;
@@ -699,6 +755,24 @@ static VALUE document_apply_yerbafile(int argc, VALUE *argv, VALUE self) {
   return self;
 }
 
+/* document.validate_schema(schema_json, selector = nil) */
+static VALUE document_validate_schema(int argc, VALUE *argv, VALUE self) {
+  VALUE schema_json, selector;
+  rb_scan_args(argc, argv, "11", &schema_json, &selector);
+
+  struct Document *document = get_document(self);
+  const char *selector_str = NIL_P(selector) ? NULL : StringValueCStr(selector);
+
+  char *result = yerba_document_validate_schema(document, StringValueCStr(schema_json), selector_str);
+
+  if (!result) return rb_ary_new();
+
+  VALUE json_string = make_utf8_string(result);
+  yerba_string_free(result);
+
+  return rb_funcall(rb_path2class("JSON"), rb_intern("parse"), 1, json_string);
+}
+
 /* document.to_s */
 static VALUE document_to_s(VALUE self) {
   struct Document *document = get_document(self);
@@ -736,14 +810,41 @@ static VALUE document_changed_p(VALUE self) {
   return rb_str_equal(current, original) ? Qfalse : Qtrue;
 }
 
+/* document.location(selector = nil) → Yerba::Location */
+static VALUE document_location(int argc, VALUE *argv, VALUE self) {
+  VALUE path;
+  rb_scan_args(argc, argv, "01", &path);
+
+  struct Document *document = get_document(self);
+  const char *selector = NIL_P(path) ? "" : StringValueCStr(path);
+
+  YerbaGetResult result = yerba_document_get(document, selector);
+
+  if (result.error) {
+    yerba_get_result_free(result);
+    return Qnil;
+  }
+
+  if (result.location.start_line == 0 && result.location.end_line == 0 && strlen(selector) > 0) {
+    yerba_get_result_free(result);
+    return Qnil;
+  }
+
+  VALUE location = location_to_ruby(result.location);
+  yerba_get_result_free(result);
+
+  return location;
+}
+
 /* document.path */
 static VALUE document_path(VALUE self) {
   return rb_iv_get(self, "@path");
 }
 
-/* Collection.get(glob, path) — get values across files */
+/* Collection.get(glob, selector) → [Yerba::Scalar|Map|Sequence, ...] */
 static VALUE collection_s_get(VALUE self, VALUE pattern, VALUE path) {
-  (void)self;
+  (void) self;
+
   YerbaTypedList result = yerba_glob_get(StringValueCStr(pattern), StringValueCStr(path));
 
   if (!result.json) return rb_ary_new();
@@ -755,20 +856,40 @@ static VALUE collection_s_get(VALUE self, VALUE pattern, VALUE path) {
   long length = RARRAY_LEN(items);
   VALUE array = rb_ary_new_capa(length);
 
+
   for (long i = 0; i < length; i++) {
     VALUE item = rb_ary_entry(items, i);
-    VALUE text = rb_hash_aref(item, rb_str_new_cstr("text"));
-    int type_value = NUM2INT(rb_hash_aref(item, rb_str_new_cstr("type")));
+    VALUE node_type = rb_hash_aref(item, rb_str_new_cstr("node_type"));
+    VALUE file_path = rb_hash_aref(item, rb_str_new_cstr("file_path"));
+    VALUE selector = rb_hash_aref(item, rb_str_new_cstr("selector"));
+    const char *type_str = NIL_P(node_type) ? "" : StringValueCStr(node_type);
 
-    if (NIL_P(text)) {
-      rb_ary_push(array, Qnil);
-      continue;
-    }
+    if (NIL_P(selector)) continue;
+
+    VALUE line = rb_hash_aref(item, rb_str_new_cstr("line"));
+    VALUE kwargs = rb_hash_new();
 
-    YerbaTypedValue typed_value;
-    typed_value.text = (char *)StringValueCStr(text);
-    typed_value.value_type = (YerbaValueType)type_value;
-    rb_ary_push(array, typed_value_to_ruby(typed_value));
+    rb_hash_aset(kwargs, ID2SYM(rb_intern("selector")), selector);
+    if (!NIL_P(file_path)) rb_hash_aset(kwargs, ID2SYM(rb_intern("file_path")), file_path);
+    if (!NIL_P(line)) rb_hash_aset(kwargs, ID2SYM(rb_intern("line")), line);
+
+    if (strcmp(type_str, "scalar") == 0) {
+      VALUE text = rb_hash_aref(item, rb_str_new_cstr("text"));
+      if (NIL_P(text)) continue;
+
+      int type_value = NUM2INT(rb_hash_aref(item, rb_str_new_cstr("type")));
+      YerbaTypedValue typed_value;
+      typed_value.text = (char *)StringValueCStr(text);
+      typed_value.value_type = (YerbaValueType)type_value;
+
+      rb_hash_aset(kwargs, ID2SYM(rb_intern("value")), typed_value_to_ruby(typed_value));
+      VALUE scalar_args[1] = { kwargs };
+      rb_ary_push(array, rb_funcallv_kw(rb_path2class("Yerba::Scalar"), rb_intern("from"), 1, scalar_args, RB_PASS_KEYWORDS));
+    } else {
+      const char *klass_name = strcmp(type_str, "sequence") == 0 ? "Yerba::Sequence" : "Yerba::Map";
+      VALUE node_args[1] = { kwargs };
+      rb_ary_push(array, rb_funcallv_kw(rb_path2class(klass_name), rb_intern("from"), 1, node_args, RB_PASS_KEYWORDS));
+    }
   }
 
   return array;
@@ -835,13 +956,17 @@ void Init_yerba(void) {
   rb_define_alloc_func(rb_cDocument, document_alloc);
   rb_define_method(rb_cDocument, "initialize", document_initialize, 1);
   rb_define_singleton_method(rb_cDocument, "parse", document_s_parse, 1);
-  rb_define_method(rb_cDocument, "get", document_get, 1);
   rb_define_method(rb_cDocument, "[]", document_bracket, 1);
-  rb_define_method(rb_cDocument, "get_value", document_get_value, 1);
-  rb_define_method(rb_cDocument, "get_values", document_get_values, 1);
+  rb_define_method(rb_cDocument, "node_at", document_bracket, 1);
+  rb_define_method(rb_cDocument, "value_at", document_get_value, 1);
+  rb_define_method(rb_cDocument, "location", document_location, -1);
+  rb_define_method(rb_cDocument, "locations", document_locations, 1);
+  rb_define_method(rb_cDocument, "selectors", document_selectors, 0);
+  rb_define_method(rb_cDocument, "resolve_selectors", document_resolve_selectors, 1);
   rb_define_method(rb_cDocument, "get_quote_style", document_get_quote_style, 1);
   rb_define_method(rb_cDocument, "set_quote_style", document_set_quote_style, 2);
   rb_define_method(rb_cDocument, "exists?", document_exists_p, 1);
+  rb_define_method(rb_cDocument, "valid_selector?", document_valid_selector_p, 1);
   rb_define_method(rb_cDocument, "condition?", document_condition_p, -1);
   rb_define_method(rb_cDocument, "find", document_find, -1);
   rb_define_method(rb_cDocument, "set", document_set, -1);
@@ -857,6 +982,7 @@ void Init_yerba(void) {
   rb_define_method(rb_cDocument, "quote_style", document_quote_style, -1);
   rb_define_method(rb_cDocument, "blank_lines", document_blank_lines, 2);
   rb_define_method(rb_cDocument, "apply_yerbafile", document_apply_yerbafile, -1);
+  rb_define_method(rb_cDocument, "validate_schema", document_validate_schema, -1);
   rb_define_method(rb_cDocument, "to_s", document_to_s, 0);
   rb_define_method(rb_cDocument, "write!", document_save, 0);
   rb_define_method(rb_cDocument, "changed?", document_changed_p, 0);

data/lib/yerba/document.rb

@@ -4,10 +4,26 @@ module Yerba
   class Document
     ROOT_SELECTOR = ""
 
+    def self.cache
+      @cache ||= Hash.new { |hash, path| hash[path] = new(path) }
+    end
+
+    def self.clear_cache!
+      @cache = nil
+    end
+
+    def selector
+      ROOT_SELECTOR
+    end
+
     def root
       self[ROOT_SELECTOR]
     end
 
+    def []=(key, value)
+      root[key] = value
+    end
+
     def map?
       root.is_a?(Map)
     end
@@ -17,11 +33,11 @@ module Yerba
     end
 
     def to_h
-      get_value(ROOT_SELECTOR)
+      value_at(ROOT_SELECTOR)
     end
 
     def to_a
-      get_value(ROOT_SELECTOR)
+      value_at(ROOT_SELECTOR)
     end
 
     def to_yaml
@@ -29,25 +45,13 @@ module Yerba
     end
 
     def dig(*keys)
-      result = keys.reduce(self) { |node, key| node.nil? ? nil : node[key] }
-
-      result&.value
+      keys.reduce(self) { |node, key| node.nil? ? nil : node[key] }
     end
 
-    def at_path(path)
-      if path.include?("[]")
-        values = get(path)
-        return [] unless values.is_a?(Array)
+    def fetch(selector)
+      validate_selector!(selector)
 
-        path.sub("[]", "")
-
-        values.each_with_index.map do |_value, index|
-          resolved_path = path.sub("[]", "[#{index}]")
-          self[resolved_path]
-        end
-      else
-        self[path]
-      end
+      self[selector]
     end
 
     def find_by(...)
@@ -90,6 +94,38 @@ module Yerba
       self
     end
 
+    def valid?(schema, selector: nil)
+      errors = validate(schema, selector: selector)
+
+      errors.empty?
+    end
+
+    def validate(schema, selector: nil)
+      schema_json = schema.is_a?(String) ? schema : JSON.generate(schema)
+
+      validate_schema(schema_json, selector)
+    end
+
+    def validate_selector!(selector)
+      return if valid_selector?(selector)
+
+      available = selectors
+      message = "selector \"#{selector}\" is not valid for this document"
+
+      if available.any?
+        suggestions = DidYouMean::SpellChecker.new(dictionary: available).correct(selector)
+
+        if suggestions.any?
+          message += ". Did you mean: #{suggestions.first(3).join(", ")}?"
+        else
+          message += ". Available selectors: #{available.first(5).join(", ")}"
+          message += ", ..." if available.length > 5
+        end
+      end
+
+      raise Yerba::SelectorNotFoundError, message
+    end
+
     def inspect
       if path
         "#<Yerba::Document path=#{path.inspect}>"