Class: Ox::Builder

Inherits:

Object

• Object
• Ox::Builder

Defined in:

ext/ox/builder.c,
ext/ox/builder.c

Overview

An XML builder.

Class Method Summary

• .file(*args) ⇒ Object
• .io(*args) ⇒ Object
• .new(*args) ⇒ Object

Instance Method Summary

• #cdata(data) ⇒ Object
• #close ⇒ Object
• #column ⇒ Object
• #comment(text) ⇒ Object
• #doctype(text) ⇒ Object
• #element(*args) ⇒ Object
• #indent ⇒ Object
• #indent=(indent) ⇒ Object
• #instruct(*args) ⇒ Object
• #line ⇒ Object
• #pop ⇒ Object
• #pos ⇒ Object
• #raw(text) ⇒ Object
• #text(*args) ⇒ Object
• #to_s ⇒ Object
• #void_element(*args) ⇒ Object

Class Method Details

.file(*args) ⇒ Object

# File 'ext/ox/builder.c', line 489

static VALUE builder_file(int argc, VALUE *argv, VALUE self) {
    Builder b        = ALLOC(struct _builder);
    int     indent   = ox_default_options.indent;
    long    buf_size = 0;
    FILE   *f;

    if (1 > argc) {
        rb_raise(ox_arg_error_class, "missing filename");
    }
    Check_Type(*argv, T_STRING);
    if (NULL == (f = fopen(StringValuePtr(*argv), "wb"))) {
        xfree(b);
        rb_raise(rb_eIOError, "%s\n", strerror(errno));
    }
    if (2 == argc) {
        volatile VALUE v;

        rb_check_type(argv[1], T_HASH);
        if (Qnil != (v = rb_hash_lookup(argv[1], ox_indent_sym))) {
            if (rb_cInteger != rb_obj_class(v)) {
                rb_raise(ox_parse_error_class, ":indent must be a fixnum.\n");
            }
            indent = NUM2INT(v);
        }
        if (Qnil != (v = rb_hash_lookup(argv[1], ox_size_sym))) {
            if (rb_cInteger != rb_obj_class(v)) {
                rb_raise(ox_parse_error_class, ":size must be a fixnum.\n");
            }
            buf_size = NUM2LONG(v);
        }
    }
    b->file = f;
    init(b, fileno(f), indent, buf_size);

    if (rb_block_given_p()) {
        volatile VALUE rb = TypedData_Wrap_Struct(builder_class, &ox_builder_type, b);
        rb_yield(rb);
        bclose(b);
        return Qnil;
    } else {
        return TypedData_Wrap_Struct(builder_class, &ox_builder_type, b);
    }
}

.io(*args) ⇒ Object

# File 'ext/ox/builder.c', line 542

static VALUE builder_io(int argc, VALUE *argv, VALUE self) {
    Builder        b        = ALLOC(struct _builder);
    int            indent   = ox_default_options.indent;
    long           buf_size = 0;
    int            fd;
    volatile VALUE v;

    if (1 > argc) {
        rb_raise(ox_arg_error_class, "missing IO object");
    }
    if (!rb_respond_to(*argv, ox_fileno_id) || Qnil == (v = rb_funcall(*argv, ox_fileno_id, 0)) ||
        0 == (fd = FIX2INT(v))) {
        rb_raise(rb_eIOError, "expected an IO that has a fileno.");
    }
    if (2 == argc) {
        volatile VALUE v;

        rb_check_type(argv[1], T_HASH);
        if (Qnil != (v = rb_hash_lookup(argv[1], ox_indent_sym))) {
            if (rb_cInteger != rb_obj_class(v)) {
                rb_raise(ox_parse_error_class, ":indent must be a fixnum.\n");
            }
            indent = NUM2INT(v);
        }
        if (Qnil != (v = rb_hash_lookup(argv[1], ox_size_sym))) {
            if (rb_cInteger != rb_obj_class(v)) {
                rb_raise(ox_parse_error_class, ":size must be a fixnum.\n");
            }
            buf_size = NUM2LONG(v);
        }
    }
    b->file = NULL;
    init(b, fd, indent, buf_size);

    if (rb_block_given_p()) {
        volatile VALUE rb = TypedData_Wrap_Struct(builder_class, &ox_builder_type, b);
        rb_yield(rb);
        bclose(b);
        return Qnil;
    } else {
        return TypedData_Wrap_Struct(builder_class, &ox_builder_type, b);
    }
}

.new(*args) ⇒ Object

# File 'ext/ox/builder.c', line 443

static VALUE builder_new(int argc, VALUE *argv, VALUE self) {
    Builder b        = ALLOC(struct _builder);
    int     indent   = ox_default_options.indent;
    long    buf_size = 0;

    if (1 == argc) {
        volatile VALUE v;

        rb_check_type(*argv, T_HASH);
        if (Qnil != (v = rb_hash_lookup(*argv, ox_indent_sym))) {
            if (rb_cInteger != rb_obj_class(v)) {
                rb_raise(ox_parse_error_class, ":indent must be a fixnum.\n");
            }
            indent = NUM2INT(v);
        }
        if (Qnil != (v = rb_hash_lookup(*argv, ox_size_sym))) {
            if (rb_cInteger != rb_obj_class(v)) {
                rb_raise(ox_parse_error_class, ":size must be a fixnum.\n");
            }
            buf_size = NUM2LONG(v);
        }
    }
    b->file = NULL;
    init(b, 0, indent, buf_size);

    if (rb_block_given_p()) {
        volatile VALUE rb = TypedData_Wrap_Struct(builder_class, &ox_builder_type, b);

        rb_yield(rb);
        bclose(b);

        return to_s(b);
    } else {
        return TypedData_Wrap_Struct(builder_class, &ox_builder_type, b);
    }
}

Instance Method Details

#cdata(data) ⇒ Object

# File 'ext/ox/builder.c', line 863

static VALUE builder_cdata(VALUE self, VALUE data) {
    Builder        b;
    volatile VALUE v = data;
    const char    *str;
    const char    *s;
    const char    *end;
    const char    *from;
    const char    *split;
    size_t         extra = 0;
    int            len;

    TypedData_Get_Struct(self, struct _builder, &ox_builder_type, b);

    v    = rb_String(v);
    str  = StringValuePtr(v);
    len  = (int)RSTRING_LEN(v);
    s    = str;
    end  = str + len;
    from = str;
    check_unescaped(str, (size_t)len);
    i_am_a_child(b, false);
    append_indent(b);
    buf_append_string(&b->buf, "<![CDATA[", 9);
    b->col += 9;
    b->pos += 9;
    // See xml_cdata_end(). The ']]' stays in this section and the '>' opens the
    // next one, so from lands on the '>' each time round.
    while (NULL != (split = xml_cdata_end(from, end))) {
        buf_append_string(&b->buf, from, (split + 2) - from);
        buf_append_string(&b->buf, "]]><![CDATA[", CDATA_SPLIT_EXTRA);
        extra += CDATA_SPLIT_EXTRA;
        from = split + 2;
    }
    buf_append_string(&b->buf, from, end - from);
    b->col += len + extra;
    s = strchr(s, '\n');
    while (NULL != s) {
        b->line++;
        b->col = end - s;
        s      = strchr(s + 1, '\n');
    }
    b->pos += len + extra;
    buf_append_string(&b->buf, "]]>", 3);
    b->col += 3;
    b->pos += 3;

    return Qnil;
}

#close ⇒ Object

# File 'ext/ox/builder.c', line 1037

static VALUE builder_close(VALUE self) {
    Builder b;

    TypedData_Get_Struct(self, struct _builder, &ox_builder_type, b);
    bclose(b);

    return Qnil;
}

#column ⇒ Object

# File 'ext/ox/builder.c', line 973

static VALUE builder_column(VALUE self) {
    Builder b;

    TypedData_Get_Struct(self, struct _builder, &ox_builder_type, b);
    return LONG2NUM(b->col);
}

#comment(text) ⇒ Object

# File 'ext/ox/builder.c', line 772

static VALUE builder_comment(VALUE self, VALUE text) {
    Builder b;
    size_t  size;
    size_t  xsize;

    TypedData_Get_Struct(self, struct _builder, &ox_builder_type, b);
    rb_check_type(text, T_STRING);
    size  = (size_t)RSTRING_LEN(text);
    xsize = check_string(StringValuePtr(text), size, xml_element_chars);
    i_am_a_child(b, false);
    append_indent(b);
    buf_append_string(&b->buf, "<!--", 4);
    b->col += 4;
    b->pos += 4;
    append_string(b, StringValuePtr(text), size, xml_element_chars, xsize, false);
    buf_append_string(&b->buf, "-->", 3);
    b->col += 3;
    b->pos += 3;

    return Qnil;
}

#doctype(text) ⇒ Object

# File 'ext/ox/builder.c', line 799

static VALUE builder_doctype(VALUE self, VALUE text) {
    Builder b;
    size_t  size;
    size_t  xsize;

    TypedData_Get_Struct(self, struct _builder, &ox_builder_type, b);
    rb_check_type(text, T_STRING);
    size  = (size_t)RSTRING_LEN(text);
    xsize = check_string(StringValuePtr(text), size, xml_element_chars);
    i_am_a_child(b, false);
    append_indent(b);
    buf_append_string(&b->buf, "<!DOCTYPE ", 10);
    b->col += 10;
    b->pos += 10;
    append_string(b, StringValuePtr(text), size, xml_element_chars, xsize, false);
    buf_append(&b->buf, '>');
    b->col++;
    b->pos++;

    return Qnil;
}

#element(*args) ⇒ Object

# File 'ext/ox/builder.c', line 678

static VALUE builder_element(int argc, VALUE *argv, VALUE self) {
    Builder        b;
    Element        e;
    volatile VALUE sym   = Qnil;
    size_t         xsize = 0;
    const char    *name;
    long           len;

    TypedData_Get_Struct(self, struct _builder, &ox_builder_type, b);

    if (1 > argc) {
        rb_raise(ox_arg_error_class, "missing element name");
    }
    // Everything that can raise has to run before the first write, or the raise
    // leaves an element started that no later call can finish or take back. It
    // also has to run before b->depth++, or the stack slot is never filled in.
    len = check_name(*argv, &sym, &name, &xsize, "expected a Symbol or String for an element name");
    check_name_chars(name, (size_t)len, false);
    if (MAX_DEPTH <= b->depth + 1) {
        rb_raise(ox_arg_error_class, "XML too deeply nested");
    }
    i_am_a_child(b, false);
    append_indent(b);
    b->depth++;
    e = &b->stack[b->depth];
    if (sizeof(e->buf) <= (size_t)len) {
        e->name = strdup(name);
        *e->buf = '\0';
    } else {
        strcpy(e->buf, name);
        e->name = e->buf;
    }
    e->len            = len;
    e->has_child      = false;
    e->non_text_child = false;

    buf_append(&b->buf, '<');
    b->col++;
    b->pos++;
    append_string(b, e->name, len, xml_element_chars, xsize, false);
    if (1 < argc && T_HASH == rb_type(argv[1])) {
        rb_hash_foreach(argv[1], append_attr, (VALUE)b);
    }
    // Do not close with > or /> yet. That is done with i_am_a_child() or pop().
    if (rb_block_given_p()) {
        rb_yield(self);
        pop(b);
    }
    return Qnil;
}

#indent ⇒ Object

# File 'ext/ox/builder.c', line 984

static VALUE builder_get_indent(VALUE self) {
    Builder b;

    TypedData_Get_Struct(self, struct _builder, &ox_builder_type, b);
    return INT2NUM(b->indent);
}

#indent=(indent) ⇒ Object

# File 'ext/ox/builder.c', line 997

static VALUE builder_set_indent(VALUE self, VALUE indent) {
    Builder b;

    TypedData_Get_Struct(self, struct _builder, &ox_builder_type, b);

    if (rb_cInteger != rb_obj_class(indent)) {
        rb_raise(ox_parse_error_class, "indent must be a fixnum.\n");
    }

    b->indent = NUM2INT(indent);
    return Qnil;
}

#instruct(*args) ⇒ Object

# File 'ext/ox/builder.c', line 593

static VALUE builder_instruct(int argc, VALUE *argv, VALUE self) {
    Builder b;

    TypedData_Get_Struct(self, struct _builder, &ox_builder_type, b);
    if (0 < argc) {
        volatile VALUE nsym = Qnil;
        const char    *nstr;
        size_t         nx;

        check_name(*argv, &nsym, &nstr, &nx, "expected a Symbol or String");
        if (1 < argc && rb_cHash == rb_obj_class(argv[1])) {
            // The "<?" and the target are out by the time the values are
            // written, so a raise down there would leave them in the buffer.
            check_instruct_value(argv[1], ox_version_sym);
            check_instruct_value(argv[1], ox_encoding_sym);
            check_instruct_value(argv[1], ox_standalone_sym);
        }
    }
    i_am_a_child(b, false);
    append_indent(b);
    if (0 == argc) {
        buf_append_string(&b->buf, "<?xml?>", 7);
        b->col += 7;
        b->pos += 7;
    } else {
        volatile VALUE v;

        buf_append_string(&b->buf, "<?", 2);
        b->col += 2;
        b->pos += 2;
        append_sym_str(b, *argv);
        if (1 < argc && rb_cHash == rb_obj_class(argv[1])) {
            int len;

            if (Qnil != (v = rb_hash_lookup(argv[1], ox_version_sym))) {
                if (rb_cString != rb_obj_class(v)) {
                    rb_raise(ox_parse_error_class, ":version must be a Symbol.\n");
                }
                len = (int)RSTRING_LEN(v);
                buf_append_string(&b->buf, " version=\"", 10);
                buf_append_string(&b->buf, StringValuePtr(v), len);
                buf_append(&b->buf, '"');
                b->col += len + 11;
                b->pos += len + 11;
            }
            if (Qnil != (v = rb_hash_lookup(argv[1], ox_encoding_sym))) {
                if (rb_cString != rb_obj_class(v)) {
                    rb_raise(ox_parse_error_class, ":encoding must be a Symbol.\n");
                }
                len = (int)RSTRING_LEN(v);
                buf_append_string(&b->buf, " encoding=\"", 11);
                buf_append_string(&b->buf, StringValuePtr(v), len);
                buf_append(&b->buf, '"');
                b->col += len + 12;
                b->pos += len + 12;
                strncpy(b->encoding, StringValuePtr(v), sizeof(b->encoding));
                b->encoding[sizeof(b->encoding) - 1] = '\0';
            }
            if (Qnil != (v = rb_hash_lookup(argv[1], ox_standalone_sym))) {
                if (rb_cString != rb_obj_class(v)) {
                    rb_raise(ox_parse_error_class, ":standalone must be a Symbol.\n");
                }
                len = (int)RSTRING_LEN(v);
                buf_append_string(&b->buf, " standalone=\"", 13);
                buf_append_string(&b->buf, StringValuePtr(v), len);
                buf_append(&b->buf, '"');
                b->col += len + 14;
                b->pos += len + 14;
            }
        }
        buf_append_string(&b->buf, "?>", 2);
        b->col += 2;
        b->pos += 2;
    }
    return Qnil;
}

#line ⇒ Object

# File 'ext/ox/builder.c', line 961

static VALUE builder_line(VALUE self) {
    Builder b;

    TypedData_Get_Struct(self, struct _builder, &ox_builder_type, b);
    return LONG2NUM(b->line);
}

#pop ⇒ Object

# File 'ext/ox/builder.c', line 1025

static VALUE builder_pop(VALUE self) {
    Builder b;
    TypedData_Get_Struct(self, struct _builder, &ox_builder_type, b);
    pop(b);

    return Qnil;
}

#pos ⇒ Object

# File 'ext/ox/builder.c', line 1014

static VALUE builder_pos(VALUE self) {
    Builder b;

    TypedData_Get_Struct(self, struct _builder, &ox_builder_type, b);
    return LONG2NUM(b->pos);
}

#raw(text) ⇒ Object

# File 'ext/ox/builder.c', line 918

static VALUE builder_raw(VALUE self, VALUE text) {
    Builder        b;
    volatile VALUE v = text;
    const char    *str;
    const char    *s;
    const char    *end;
    int            len;

    TypedData_Get_Struct(self, struct _builder, &ox_builder_type, b);
    v   = rb_String(v);
    str = StringValuePtr(v);
    len = (int)RSTRING_LEN(v);
    s   = str;
    end = str + len;
    i_am_a_child(b, true);
    buf_append_string(&b->buf, str, len);
    b->col += len;
    s = strchr(s, '\n');
    while (NULL != s) {
        b->line++;
        b->col = end - s;
        s      = strchr(s + 1, '\n');
    }
    b->pos += len;

    return Qnil;
}

#text(*args) ⇒ Object

# File 'ext/ox/builder.c', line 827

static VALUE builder_text(int argc, VALUE *argv, VALUE self) {
    Builder        b;
    volatile VALUE v;
    volatile VALUE strip_invalid_chars;
    size_t         size;
    size_t         xsize;

    TypedData_Get_Struct(self, struct _builder, &ox_builder_type, b);

    if ((0 == argc) || (argc > 2)) {
        rb_raise(rb_eArgError, "wrong number of arguments (given %d, expected 1..2)", argc);
    }
    v = argv[0];
    if (2 == argc) {
        strip_invalid_chars = argv[1];
    } else {
        strip_invalid_chars = Qfalse;
    }

    v    = rb_String(v);
    size = (size_t)RSTRING_LEN(v);
    // Stripping is allowed to drop the byte, so it is the one writer that does
    // not have to refuse the value up front.
    xsize = RTEST(strip_invalid_chars) ? xml_str_len((const unsigned char *)StringValuePtr(v), size, xml_element_chars)
                                       : check_string(StringValuePtr(v), size, xml_element_chars);
    i_am_a_child(b, true);
    append_string(b, StringValuePtr(v), size, xml_element_chars, xsize, RTEST(strip_invalid_chars));

    return Qnil;
}

#to_s ⇒ Object

# File 'ext/ox/builder.c', line 950

static VALUE builder_to_s(VALUE self) {
    Builder b;

    TypedData_Get_Struct(self, struct _builder, &ox_builder_type, b);
    return to_s(b);
}

#void_element(*args) ⇒ Object

# File 'ext/ox/builder.c', line 736

static VALUE builder_void_element(int argc, VALUE *argv, VALUE self) {
    Builder        b;
    volatile VALUE sym   = Qnil;
    size_t         xsize = 0;
    const char    *name;
    long           len;

    TypedData_Get_Struct(self, struct _builder, &ox_builder_type, b);

    if (1 > argc) {
        rb_raise(ox_arg_error_class, "missing element name");
    }
    len = check_name(*argv, &sym, &name, &xsize, "expected a Symbol or String for an element name");
    check_name_chars(name, (size_t)len, false);
    i_am_a_child(b, false);
    append_indent(b);
    buf_append(&b->buf, '<');
    b->col++;
    b->pos++;
    append_string(b, name, len, xml_element_chars, xsize, false);
    if (1 < argc && T_HASH == rb_type(argv[1])) {
        rb_hash_foreach(argv[1], append_attr, (VALUE)b);
    }
    buf_append_string(&b->buf, ">", 1);
    b->col++;
    ;
    b->pos++;

    return Qnil;
}