[macruby-changes] [2166] MacRuby/branches/experimental
source_changes at macosforge.org
source_changes at macosforge.org
Mon Aug 3 10:45:38 PDT 2009
Revision: 2166
http://trac.macosforge.org/projects/ruby/changeset/2166
Author: pthomson at apple.com
Date: 2009-08-03 10:45:38 -0700 (Mon, 03 Aug 2009)
Log Message:
-----------
Okay, laid down a more cohesive API for this library.
Modified Paths:
--------------
MacRuby/branches/experimental/ext/libyaml/rubyext.c
MacRuby/branches/experimental/lib/yaml.rb
Modified: MacRuby/branches/experimental/ext/libyaml/rubyext.c
===================================================================
--- MacRuby/branches/experimental/ext/libyaml/rubyext.c 2009-08-03 17:45:36 UTC (rev 2165)
+++ MacRuby/branches/experimental/ext/libyaml/rubyext.c 2009-08-03 17:45:38 UTC (rev 2166)
@@ -19,100 +19,49 @@
VALUE rb_mLibYAML;
VALUE rb_cParser;
VALUE rb_cEmitter;
+VALUE rb_cResolver;
+VALUE rb_cNode;
+VALUE rb_cScalar;
+VALUE rb_cSeq;
+VALUE rb_cMap;
-typedef struct {
- yaml_emitter_t *emitter;
- VALUE bytestring;
-} rb_yaml_emitter_t;
+VALUE rb_DefaultResolver;
+static ID id_resolver;
+
static VALUE
rb_yaml_parser_alloc(VALUE klass, SEL sel)
{
- yaml_parser_t *parser = ALLOC(yaml_parser_t);
- yaml_parser_initialize(parser);
- return Data_Wrap_Struct(klass, NULL, NULL, parser);
+ yaml_parser_t *yparser = ALLOC(yaml_parser_t);
+ yaml_parser_initialize(yparser);
+ return Data_Wrap_Struct(klass, NULL, NULL, yparser);
}
static VALUE
-rb_yaml_object_from_event(yaml_event_t *event)
+rb_yaml_parser_initialize(VALUE self, SEL sel, int argc, VALUE *argv)
{
- VALUE str = rb_str_new2((const char*)event->data.scalar.value);
- return str;
+ VALUE resolver = Qnil;
+ rb_scan_args(argc, argv, "01", &resolver);
+ if (NIL_P(resolver))
+ {
+ resolver = rb_oDefaultResolver;
+ }
+ rb_ivar_set(self, id_resolver, resolver);
+ return self;
}
-static VALUE
-rb_yaml_parse(yaml_parser_t *parser)
+static IMP rb_yaml_parser_finalize_super = NULL;
+
+static void
+rb_yaml_parser_finalize(void *rcv, SEL sel)
{
- yaml_event_t event;
- int done = 0;
- VALUE obj, temp;
- VALUE stack = rb_ary_new();
- while(!done) {
- if(!yaml_parser_parse(parser, &event)) {
- rb_raise(rb_eRuntimeError, "internal yaml parsing error");
- }
- done = (event.type == YAML_STREAM_END_EVENT);
- switch(event.type) {
- case YAML_SCALAR_EVENT:
- obj = rb_yaml_object_from_event(&event);
- temp = rb_ary_last(stack, 0, 0, 0);
- if (TYPE(temp) == T_ARRAY)
- {
- rb_ary_push(temp, obj);
- }
- else if (TYPE(temp) == T_HASH)
- {
- rb_ary_push(stack, obj);
- }
- else
- {
- rb_objc_retain((void*)temp);
- rb_ary_pop(stack);
- rb_hash_aset(rb_ary_last(stack, 0, 0, 0), temp, obj);
- }
- break;
- case YAML_SEQUENCE_START_EVENT:
- rb_ary_push(stack, rb_ary_new());
- break;
- case YAML_MAPPING_START_EVENT:
- rb_ary_push(stack, rb_hash_new());
- break;
- case YAML_SEQUENCE_END_EVENT:
- case YAML_MAPPING_END_EVENT:
- // TODO: Check for retain count errors.
- temp = rb_ary_pop(stack);
- VALUE last = rb_ary_last(stack, 0, 0, 0);
- if (NIL_P(last))
- {
- rb_ary_push(stack, temp);
- }
- else if (TYPE(last) == T_ARRAY)
- {
- rb_ary_push(last, temp);
- }
- else if (TYPE(last) == T_HASH)
- {
- rb_ary_push(stack, temp);
- }
- else
- {
- obj = rb_ary_last(stack, 0, 0, 0);
- rb_objc_retain((void*)obj);
- rb_hash_aset(rb_ary_last(stack, 0, 0, 0), obj, temp);
- }
- break;
- case YAML_NO_EVENT:
- break;
- default:
- break;
- }
- yaml_event_delete(&event);
- }
- if (RARRAY_LEN(stack) == 1)
+ yaml_parser_t *parser;
+ Data_Get_Struct(rcv, yaml_parser_t, parser);
+ yaml_parser_delete(parser);
+ if (rb_yaml_parser_finalize_super != NULL)
{
- return RARRAY_AT(stack, 0);
+ ((void(*)(void *, SEL))rb_yaml_parser_finalize_super)(rcv, sel);
}
- return stack;
}
static int
@@ -132,117 +81,68 @@
}
static VALUE
-rb_yaml_parser_load(VALUE self, SEL sel, VALUE io)
+rb_yaml_parser_load(VALUE self, SEL sel, int argc, VALUE *argv)
{
- yaml_parser_t *parser;
- Data_Get_Struct(self, yaml_parser_t, parser);
- if (TYPE(io) == T_STRING)
- {
- yaml_parser_set_input_string(parser, (const unsigned char*)RSTRING_PTR(io), (size_t)RSTRING_LEN(io));
- } else {
- yaml_parser_set_input(parser, (yaml_read_handler_t*)rb_yaml_parser_io_handler, (void*)io);
- }
- return rb_yaml_parse(parser);
+ rb_notimplement();
}
-static IMP rb_yaml_parser_finalize_super = NULL;
-
-static void
-rb_yaml_parser_finalize(void *rcv, SEL sel)
+static VALUE
+rb_yaml_parser_load_documents(VALUE self, SEL sel, int argc, VALUE *argv)
{
- yaml_parser_t *parser;
- Data_Get_Struct(rcv, yaml_parser_t, parser);
- yaml_parser_delete(parser);
- if (rb_yaml_parser_finalize_super != NULL)
- {
- ((void(*)(void *, SEL))rb_yaml_parser_finalize_super)(rcv, sel);
- }
+ rb_notimplement();
}
-static int
-rb_yaml_write_item_to_document(VALUE item, yaml_document_t *document)
+static VALUE
+rb_yaml_emitter_alloc(VALUE klass, SEL sel)
{
- int nodeID = 0;
- if (TYPE(item) == T_ARRAY)
- {
- nodeID = yaml_document_add_sequence(document, (yaml_char_t *)YAML_DEFAULT_SEQUENCE_TAG, YAML_ANY_SEQUENCE_STYLE);
- long len = RARRAY_LEN(item);
- int ii;
- for(ii=0; ii<len; ii++)
- {
- int newItem = rb_yaml_write_item_to_document(RARRAY_AT(item, ii), document);
- yaml_document_append_sequence_item(document, nodeID, newItem);
- }
- }
- else if (TYPE(item) == T_HASH)
- {
- nodeID = yaml_document_add_mapping(document, (yaml_char_t *)YAML_DEFAULT_MAPPING_TAG, YAML_ANY_MAPPING_STYLE);
- VALUE keys = rb_hash_keys(item); // this is probably really inefficient.
- long len = RARRAY_LEN(item);
- int ii;
- for(ii=0; ii<len; ii++)
- {
- int keyID = rb_yaml_write_item_to_document(RARRAY_AT(keys, ii), document);
- int valID = rb_yaml_write_item_to_document(rb_hash_aref(item, RARRAY_AT(keys, ii)), document);
- yaml_document_append_mapping_pair(document, nodeID, keyID, valID);
- }
- }
- else
- {
- VALUE to_dump = rb_obj_as_string(item);
- nodeID = yaml_document_add_scalar(document, (yaml_char_t *)YAML_DEFAULT_SCALAR_TAG,
- (yaml_char_t*)(RSTRING_PTR(to_dump)), RSTRING_LEN(to_dump), YAML_ANY_SCALAR_STYLE);
- }
- return nodeID;
+ yaml_emitter_t *yemitter = ALLOC(yaml_emitter_t);
+ yaml_emitter_initialize(yemitter);
+ return Data_Wrap_Struct(klass, NULL, NULL, yemitter);
}
-static int
-rb_yaml_emitter_write_handler(void *bytestring, unsigned char* buffer, size_t size)
+static VALUE
+rb_yaml_emitter_initialize(VALUE self, SEL sel)
{
- VALUE bstr = (VALUE)bytestring;
- CFMutableDataRef data = rb_bytestring_wrapped_data(bstr);
- CFDataAppendBytes(data, (const UInt8*)buffer, (CFIndex)size);
- return 1;
+ return self;
}
static VALUE
-rb_yaml_emitter_alloc(VALUE klass, SEL sel)
+rb_yaml_emitter_emit(VALUE self, SEL sel, int argc, VALUE *argv)
{
- rb_yaml_emitter_t *emitter = ALLOC(rb_yaml_emitter_t);
- GC_WB(&emitter->emitter, ALLOC(yaml_emitter_t));
- emitter->bytestring = rb_bytestring_new();
- yaml_emitter_initialize(emitter->emitter);
- yaml_emitter_set_output(emitter->emitter, rb_yaml_emitter_write_handler, (void*)emitter->bytestring);
- return Data_Wrap_Struct(klass, NULL, NULL, emitter);
+ VALUE object, output;
+ rb_scan_args(argc, argv, "11", &object, &output);
+ if (NIL_P(output))
+ {
+ output = rb_bytestring_new();
+ }
+ rb_register_emitter_output(self, output);
+ rb_emitter_emit(self, object);
+ return output;
}
static VALUE
-rb_yaml_emitter_emit(VALUE self, SEL sel, VALUE obj)
+rb_register_emitter_output(VALUE self, VALUE output)
{
- rb_yaml_emitter_t *emitter;
- Data_Get_Struct(self, rb_yaml_emitter_t, emitter);
- yaml_document_t document;
- memset(&document, 0, sizeof(yaml_document_t));
- yaml_document_initialize(&document, NULL, NULL, NULL, 0, 0);
- rb_yaml_write_item_to_document(obj, &document);
- yaml_emitter_dump(emitter->emitter, &document);
- yaml_document_delete(&document);
- return emitter->bytestring;
+ yaml_emitter_t *emitter;
+ Data_Get_Struct(self, yaml_emitter_t, emitter);
+ if (TYPE(output) = T_BYTESTRING)
+ {
+
+ }
}
-static VALUE
-yaml_load(VALUE module, SEL sel, VALUE input)
+static IMP rb_yaml_emitter_finalize_super = NULL;
+
+static void
+rb_yaml_emitter_finalize(void *rcv, SEL sel)
{
- VALUE parser = rb_yaml_parser_alloc(rb_cParser, 0);
- VALUE ary = rb_yaml_parser_load(parser, 0, input);
- return ary;
+ rb_notimplement();
}
static VALUE
-yaml_dump(VALUE module, SEL sel, VALUE obj)
+rb_libyaml_compile(VALUE self, SEL sel, VALUE obj)
{
- VALUE rb_em = rb_yaml_emitter_alloc(rb_cEmitter, 0);
- return rb_yaml_emitter_emit(rb_em, 0, obj);
+ rb_notimplement();
}
@@ -251,18 +151,45 @@
{
rb_mYAML = rb_define_module("YAML");
- rb_objc_define_method(*(VALUE *)rb_mYAML, "load", yaml_load, 1);
- rb_objc_define_method(*(VALUE *)rb_mYAML, "dump", yaml_dump, 1);
-
rb_mLibYAML = rb_define_module_under(rb_mYAML, "LibYAML");
+ rb_objc_define_method(*(VALUE *)rb_mLibYAML, "load", rb_libyaml_compile, 1);
rb_define_const(rb_mLibYAML, "VERSION", rb_str_new2(yaml_get_version_string()));
rb_cParser = rb_define_class_under(rb_mLibYAML, "Parser", rb_cObject);
rb_objc_define_method(*(VALUE *)rb_cParser, "alloc", rb_yaml_parser_alloc, 0);
- rb_objc_define_method(rb_cParser, "load", rb_yaml_parser_load, 1);
+ rb_define_attr(rb_cParser, "resolver", 1, 1);
+ rb_define_attr(rb_cParser, "input", 1, 1);
+ rb_objc_define_method(rb_cParser, "initialize", rb_yaml_parser_initialize, -1);
+ rb_objc_define_method(rb_cParser, "load", rb_yaml_parser_load, -1);
+ rb_objc_define_method(rb_cParser, "load_documents", rb_yaml_parser_load_documents, -1);
+ rb_yaml_parser_finalize_super = rb_objc_install_method2((Class)rb_cParser, "finalize", (IMP)rb_yaml_parser_finalize);
- rb_yaml_parser_finalize_super = rb_objc_install_method((Class)rb_cParser, sel_registerName("finalize"), (IMP)rb_yaml_parser_finalize);
-
rb_cEmitter = rb_define_class_under(rb_mLibYAML, "Emitter", rb_cObject);
+ rb_objc_define_method(*(VALUE *)rb_cEmitter, "alloc", rb_yaml_emitter_alloc, 0);
+ rb_objc_define_method(rb_cEmitter, "initialize", rb_yaml_emitter_initialize, -1);
rb_objc_define_method(rb_cEmitter, "emit", rb_yaml_emitter_emit, -1);
+ rb_yaml_emitter_finalize_super = rb_objc_install_method2((Class)rb_cEmitter, "finalize", (IMP)rb_yaml_emitter_finalize);
+
+ rb_cResolver = rb_define_class_under(rb_mLibYAML, "Resolver", rb_cObject);
+ rb_define_attr(rb_cResolver, "tags", 1, 1);
+ rb_objc_define_method(rb_cResolver, "initialize", rb_yaml_resolver_initialize, 0);
+
+ rb_cDocument = rb_define_class_under(rb_mLibYAML, "Document", rb_cObject);
+ rb_objc_define_method(rb_cDocument, "<<", rb_yaml_document_add_node, 1);
+ rb_objc_define_method(rb_cDocument, "root", rb_yaml_document_root_node, 0);
+ rb_objc_define_method(rb_cDocument, "[]", rb_yaml_document_aref, 1);
+
+ rb_cNode = rb_define_class_under(rb_mLibYAML, "Node", rb_cObject);
+ rb_objc_define_method(rb_cNode, "initialize_copy", rb_yaml_node_init_copy, 1);
+ rb_define_attr(rb_cNode, "emitter", 1, 1);
+ rb_define_attr(rb_cNode, "kind", 1, 0);
+ rb_define_attr(rb_cNode, "type_id", 1, 0);
+ rb_define_attr(rb_cNode, "resolver", 1, 1);
+ rb_define_attr(rb_cNode, "value", 1, 0);
+
+ rb_cScalar = rb_define_class_under(rb_mLibYAML, "Scalar", rb_cNode);
+
+ rb_cSeq = rb_define_class_under(rb_mLibYAML, "Seq", rb_cNode);
+
+ rb_cMap = rb_define_class_under(rb_mLibYAML, "Map", rb_cNode);
}
\ No newline at end of file
Modified: MacRuby/branches/experimental/lib/yaml.rb
===================================================================
--- MacRuby/branches/experimental/lib/yaml.rb 2009-08-03 17:45:36 UTC (rev 2165)
+++ MacRuby/branches/experimental/lib/yaml.rb 2009-08-03 17:45:38 UTC (rev 2166)
@@ -8,6 +8,42 @@
require 'libyaml'
+module YAML
+
+ def YAML.parser
+ Parser.new
+ end
+
+ def YAML.emitter
+ Emitter.new
+ end
+
+ def YAML.dump(obj, io=nil)
+ obj.to_yaml(io)
+ end
+
+ def YAML.load(io)
+ parser.load(io)
+ end
+
+ def YAML.load_file(path)
+ File.open(path) { |i| load(i) }
+ end
+
+ def YAML.parse(io)
+ parser.parse(io)
+ end
+
+ def YAML.parse_file(path)
+ File.open(path) { |i| parse(i) }
+ end
+
+ def YAML.quick_emit(obj, opts={}, &block)
+ emitter.emit(obj)
+ end
+
+end
+
=begin
require 'stringio'
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://lists.macosforge.org/pipermail/macruby-changes/attachments/20090803/0f59885f/attachment-0001.html>
More information about the macruby-changes
mailing list