tomlib 0.2.0 → 0.5.0

data/ext/tomlib/toml.h

@@ -0,0 +1,175 @@
+/*
+  MIT License
+
+  Copyright (c) CK Tan
+  https://github.com/cktan/tomlc99
+
+  Permission is hereby granted, free of charge, to any person obtaining a copy
+  of this software and associated documentation files (the "Software"), to deal
+  in the Software without restriction, including without limitation the rights
+  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+  copies of the Software, and to permit persons to whom the Software is
+  furnished to do so, subject to the following conditions:
+
+  The above copyright notice and this permission notice shall be included in all
+  copies or substantial portions of the Software.
+
+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+  SOFTWARE.
+*/
+#ifndef TOML_H
+#define TOML_H
+
+#ifdef _MSC_VER
+#pragma warning(disable: 4996)
+#endif
+
+#include <stdint.h>
+#include <stdio.h>
+
+#ifdef __cplusplus
+#define TOML_EXTERN extern "C"
+#else
+#define TOML_EXTERN extern
+#endif
+
+typedef struct toml_timestamp_t toml_timestamp_t;
+typedef struct toml_table_t toml_table_t;
+typedef struct toml_array_t toml_array_t;
+typedef struct toml_datum_t toml_datum_t;
+
+/* Parse a file. Return a table on success, or 0 otherwise.
+ * Caller must toml_free(the-return-value) after use.
+ */
+TOML_EXTERN toml_table_t *toml_parse_file(FILE *fp, char *errbuf, int errbufsz);
+
+/* Parse a string containing the full config.
+ * Return a table on success, or 0 otherwise.
+ * Caller must toml_free(the-return-value) after use.
+ */
+TOML_EXTERN toml_table_t *toml_parse(char *conf, /* NUL terminated, please. */
+                                     char *errbuf, int errbufsz);
+
+/* Free the table returned by toml_parse() or toml_parse_file(). Once
+ * this function is called, any handles accessed through this tab
+ * directly or indirectly are no longer valid.
+ */
+TOML_EXTERN void toml_free(toml_table_t *tab);
+
+/* Timestamp types. The year, month, day, hour, minute, second, z
+ * fields may be NULL if they are not relevant. e.g. In a DATE
+ * type, the hour, minute, second and z fields will be NULLs.
+ */
+struct toml_timestamp_t {
+  struct { /* internal. do not use. */
+    int year, month, day;
+    int hour, minute, second, millisec;
+    char z[10];
+  } __buffer;
+  int *year, *month, *day;
+  int *hour, *minute, *second, *millisec;
+  char *z;
+};
+
+/*-----------------------------------------------------------------
+ *  Enhanced access methods
+ */
+struct toml_datum_t {
+  int ok;
+  union {
+    toml_timestamp_t *ts; /* ts must be freed after use */
+    char *s;              /* string value. s must be freed after use */
+    int b;                /* bool value */
+    int64_t i;            /* int value */
+    double d;             /* double value */
+  } u;
+};
+
+/* on arrays: */
+/* ... retrieve size of array. */
+TOML_EXTERN int toml_array_nelem(const toml_array_t *arr);
+/* ... retrieve values using index. */
+TOML_EXTERN toml_datum_t toml_string_at(const toml_array_t *arr, int idx);
+TOML_EXTERN toml_datum_t toml_bool_at(const toml_array_t *arr, int idx);
+TOML_EXTERN toml_datum_t toml_int_at(const toml_array_t *arr, int idx);
+TOML_EXTERN toml_datum_t toml_double_at(const toml_array_t *arr, int idx);
+TOML_EXTERN toml_datum_t toml_timestamp_at(const toml_array_t *arr, int idx);
+/* ... retrieve array or table using index. */
+TOML_EXTERN toml_array_t *toml_array_at(const toml_array_t *arr, int idx);
+TOML_EXTERN toml_table_t *toml_table_at(const toml_array_t *arr, int idx);
+
+/* on tables: */
+/* ... retrieve the key in table at keyidx. Return 0 if out of range. */
+TOML_EXTERN const char *toml_key_in(const toml_table_t *tab, int keyidx);
+/* ... returns 1 if key exists in tab, 0 otherwise */
+TOML_EXTERN int toml_key_exists(const toml_table_t *tab, const char *key);
+/* ... retrieve values using key. */
+TOML_EXTERN toml_datum_t toml_string_in(const toml_table_t *arr,
+                                        const char *key);
+TOML_EXTERN toml_datum_t toml_bool_in(const toml_table_t *arr, const char *key);
+TOML_EXTERN toml_datum_t toml_int_in(const toml_table_t *arr, const char *key);
+TOML_EXTERN toml_datum_t toml_double_in(const toml_table_t *arr,
+                                        const char *key);
+TOML_EXTERN toml_datum_t toml_timestamp_in(const toml_table_t *arr,
+                                           const char *key);
+/* .. retrieve array or table using key. */
+TOML_EXTERN toml_array_t *toml_array_in(const toml_table_t *tab,
+                                        const char *key);
+TOML_EXTERN toml_table_t *toml_table_in(const toml_table_t *tab,
+                                        const char *key);
+
+/*-----------------------------------------------------------------
+ * lesser used
+ */
+/* Return the array kind: 't'able, 'a'rray, 'v'alue, 'm'ixed */
+TOML_EXTERN char toml_array_kind(const toml_array_t *arr);
+
+/* For array kind 'v'alue, return the type of values
+   i:int, d:double, b:bool, s:string, t:time, D:date, T:timestamp, 'm'ixed
+   0 if unknown
+*/
+TOML_EXTERN char toml_array_type(const toml_array_t *arr);
+
+/* Return the key of an array */
+TOML_EXTERN const char *toml_array_key(const toml_array_t *arr);
+
+/* Return the number of key-values in a table */
+TOML_EXTERN int toml_table_nkval(const toml_table_t *tab);
+
+/* Return the number of arrays in a table */
+TOML_EXTERN int toml_table_narr(const toml_table_t *tab);
+
+/* Return the number of sub-tables in a table */
+TOML_EXTERN int toml_table_ntab(const toml_table_t *tab);
+
+/* Return the key of a table*/
+TOML_EXTERN const char *toml_table_key(const toml_table_t *tab);
+
+/*--------------------------------------------------------------
+ * misc
+ */
+TOML_EXTERN int toml_utf8_to_ucs(const char *orig, int len, int64_t *ret);
+TOML_EXTERN int toml_ucs_to_utf8(int64_t code, char buf[6]);
+TOML_EXTERN void toml_set_memutil(void *(*xxmalloc)(size_t),
+                                  void (*xxfree)(void *));
+
+/*--------------------------------------------------------------
+ *  deprecated
+ */
+/* A raw value, must be processed by toml_rto* before using. */
+typedef const char *toml_raw_t;
+TOML_EXTERN toml_raw_t toml_raw_in(const toml_table_t *tab, const char *key);
+TOML_EXTERN toml_raw_t toml_raw_at(const toml_array_t *arr, int idx);
+TOML_EXTERN int toml_rtos(toml_raw_t s, char **ret);
+TOML_EXTERN int toml_rtob(toml_raw_t s, int *ret);
+TOML_EXTERN int toml_rtoi(toml_raw_t s, int64_t *ret);
+TOML_EXTERN int toml_rtod(toml_raw_t s, double *ret);
+TOML_EXTERN int toml_rtod_ex(toml_raw_t s, double *ret, char *buf, int buflen);
+TOML_EXTERN int toml_rtots(toml_raw_t s, toml_timestamp_t *ret);
+
+#endif /* TOML_H */

data/ext/tomlib/tomlib.c

@@ -0,0 +1,367 @@
+#include <stdbool.h>
+#include <stdio.h>
+#include <ruby.h>
+
+#include "toml.h"
+
+static ID id_new;
+
+static VALUE mTomlib;
+static VALUE cDumper;
+static VALUE cParserError;
+
+static VALUE sym_simple;
+static VALUE sym_quoted;
+static VALUE sym_escape;
+
+static VALUE cDate;
+
+static VALUE toml_table_key_to_rb_value(const toml_table_t *table, const char *key);
+static VALUE toml_array_index_to_rb_value(const toml_array_t *array, int index);
+
+/**
+ * Convert TOML table (aka hash) to Ruby hash
+ */
+static VALUE toml_table_to_rb_hash(const toml_table_t *table) {
+  VALUE rb_hash = rb_hash_new();
+
+  for (int i = 0; ; i++) {
+    const char *key = toml_key_in(table, i);
+
+    if (!key) break;
+
+    VALUE rb_key = rb_utf8_str_new_cstr(key);
+    VALUE rb_value = toml_table_key_to_rb_value(table, key);
+
+    rb_hash_aset(rb_hash, rb_key, rb_value);
+  }
+
+  return rb_hash;
+}
+
+/**
+ * Convert TOML array to Ruby array
+ */
+static VALUE toml_array_to_rb_array(const toml_array_t *array) {
+  int length = toml_array_nelem(array);
+
+  VALUE rb_array = rb_ary_new2(length);
+
+  for (int i = 0; i < length; i++) {
+    VALUE rb_value = toml_array_index_to_rb_value(array, i);
+    rb_ary_push(rb_array, rb_value);
+  }
+
+  return rb_array;
+}
+
+/**
+ * Convert TOML timestamp to Ruby Date/Time/String depending on timestamp format
+ */
+static VALUE toml_timestamp_to_rb_value(const toml_timestamp_t *ts) {
+  if (ts->month && (*ts->month < 1 || *ts->month > 12)) {
+    rb_raise(cParserError, "invalid month: %d", *ts->month);
+  }
+
+  if (ts->day && (*ts->day < 1 || *ts->day > 31)) {
+    rb_raise(cParserError, "invalid day: %d", *ts->day);
+  }
+
+  if (ts->hour && (*ts->hour < 0 || *ts->hour > 23)) {
+    rb_raise(cParserError, "invalid hour: %d", *ts->hour);
+  }
+
+  if (ts->minute && (*ts->minute < 0 || *ts->minute > 59)) {
+    rb_raise(cParserError, "invalid minute: %d", *ts->minute);
+  }
+
+  if (ts->second && (*ts->second < 0 || *ts->second > 59)) {
+    rb_raise(cParserError, "invalid second: %d", *ts->second);
+  }
+
+  if (ts->year && ts->hour) {
+    double second = *ts->second * 1000;
+
+    if (ts->millisec) {
+      second += *ts->millisec;
+    }
+
+    VALUE rb_time;
+
+    VALUE rb_year = INT2FIX(*ts->year);
+    VALUE rb_month = INT2FIX(*ts->month);
+    VALUE rb_day = INT2FIX(*ts->day);
+    VALUE rb_hour = INT2FIX(*ts->hour);
+    VALUE rb_minute = INT2FIX(*ts->minute);
+    VALUE rb_second = rb_rational_raw(DBL2NUM(second), INT2FIX(1000));
+
+    if (ts->z) {
+      VALUE rb_tz;
+
+      // Ruby 2.6 doesn't accept "Z" as a timezone offset
+      if (*ts->z == 'Z' || *ts->z == 'z') {
+        rb_tz = rb_str_new2("+00:00");
+      } else {
+        rb_tz = rb_str_new2(ts->z);
+      }
+
+      rb_time = rb_funcall(
+        rb_cTime,
+        id_new,
+        7,
+        rb_year,
+        rb_month,
+        rb_day,
+        rb_hour,
+        rb_minute,
+        rb_second,
+        rb_tz
+      );
+    } else {
+      rb_time = rb_funcall(
+        rb_cTime,
+        id_new,
+        6,
+        rb_year,
+        rb_month,
+        rb_day,
+        rb_hour,
+        rb_minute,
+        rb_second
+      );
+    }
+
+    return rb_time;
+  }
+
+  if (ts->year && !ts->hour) {
+    VALUE rb_year = INT2FIX(*ts->year);
+    VALUE rb_month = INT2FIX(*ts->month);
+    VALUE rb_day = INT2FIX(*ts->day);
+
+    return rb_funcall(cDate, id_new, 3, rb_year, rb_month, rb_day);
+  }
+
+  if (!ts->year && ts->hour) {
+    const char *str;
+
+    int hour = *ts->hour;
+    int minute = *ts->minute;
+    int second = *ts->second;
+
+    if (ts->millisec) {
+      char buf[13];
+      sprintf(buf, "%02d:%02d:%02d.%03d", hour, minute, second, *ts->millisec);
+      str = buf;
+    } else {
+      char buf[9];
+      sprintf(buf, "%02d:%02d:%02d", hour, minute, second);
+      str = buf;
+    }
+
+    return rb_str_new2(str);
+  }
+
+  return Qnil;
+}
+
+/**
+ * Convert TOML table's value to Ruby object
+ */
+static VALUE toml_table_key_to_rb_value(const toml_table_t *table, const char *key) {
+  toml_datum_t datum;
+
+  datum = toml_string_in(table, key);
+
+  if (datum.ok) {
+    VALUE rb_value = rb_utf8_str_new_cstr(datum.u.s);
+    free(datum.u.s);
+    return rb_value;
+  }
+
+  datum = toml_int_in(table, key);
+
+  if (datum.ok) {
+    return LL2NUM(datum.u.i);
+  }
+
+  datum = toml_double_in(table, key);
+
+  if (datum.ok) {
+    return DBL2NUM(datum.u.d);
+  }
+
+  datum = toml_bool_in(table, key);
+
+  if (datum.ok) {
+    return datum.u.b ? Qtrue : Qfalse;
+  }
+
+  datum = toml_timestamp_in(table, key);
+
+  if (datum.ok) {
+    VALUE rb_value = toml_timestamp_to_rb_value(datum.u.ts);
+    free(datum.u.ts);
+    return rb_value;
+  }
+
+  toml_table_t *sub_table = toml_table_in(table, key);
+
+  if (sub_table) {
+    return toml_table_to_rb_hash(sub_table);
+  }
+
+  toml_array_t *array = toml_array_in(table, key);
+
+  if (array) {
+    return toml_array_to_rb_array(array);
+  }
+
+  rb_raise(cParserError, "invalid value");
+}
+
+/**
+ * Convert TOML array element to Ruby object
+ */
+static VALUE toml_array_index_to_rb_value(const toml_array_t *array, int index) {
+  toml_datum_t datum;
+
+  datum = toml_string_at(array, index);
+
+  if (datum.ok) {
+    VALUE rb_value = rb_utf8_str_new_cstr(datum.u.s);
+    free(datum.u.s);
+    return rb_value;
+  }
+
+  datum = toml_int_at(array, index);
+
+  if (datum.ok) {
+    return INT2FIX(datum.u.i);
+  }
+
+  datum = toml_double_at(array, index);
+
+  if (datum.ok) {
+    return DBL2NUM(datum.u.d);
+  }
+
+  datum = toml_bool_at(array, index);
+
+  if (datum.ok) {
+    return datum.u.b ? Qtrue : Qfalse;
+  }
+
+  datum = toml_timestamp_at(array, index);
+
+  if (datum.ok) {
+    VALUE rb_value = toml_timestamp_to_rb_value(datum.u.ts);
+    free(datum.u.ts);
+    return rb_value;
+  }
+
+  toml_table_t *table = toml_table_at(array, index);
+
+  if (table) {
+    return toml_table_to_rb_hash(table);
+  }
+
+  toml_array_t *sub_array = toml_array_at(array, index);
+
+  if (sub_array) {
+    return toml_array_to_rb_array(sub_array);
+  }
+
+  rb_raise(cParserError, "invalid value");
+}
+
+/**
+ * Parse TOML string and convert it into Ruby hash
+ */
+static VALUE tomlib_load_do(VALUE rb_str) {
+  char *str = StringValueCStr(rb_str);
+  char errbuf[200] = "";
+
+  toml_table_t *table = toml_parse(str, errbuf, sizeof(errbuf));
+
+  if (!table) {
+    rb_raise(cParserError, "%s", errbuf);
+  }
+
+  VALUE rb_value = toml_table_to_rb_hash(table);
+
+  toml_free(table);
+
+  return rb_value;
+}
+
+/**
+ * Rescue from argument errors
+ */
+static VALUE tomlib_load_rescue(VALUE rb_arg, VALUE rb_error) {
+  rb_set_errinfo(Qnil);
+  rb_raise(cParserError, "string contains null byte");
+  return Qnil;
+}
+
+/**
+ * Function exposed to Ruby's world as Tomlib.load(data)
+ */
+static VALUE tomlib_load(VALUE self, VALUE rb_str) {
+  return rb_rescue2(tomlib_load_do, rb_str, tomlib_load_rescue, Qnil, rb_eArgError, 0);
+}
+
+/**
+ * Function exposed to Ruby's world as Tomlib::Dumper#key_type(str)
+ */
+static VALUE tomlib_key_type(VALUE self, VALUE rb_key) {
+  const long str_len = RSTRING_LEN(rb_key);
+  const char *str = RSTRING_PTR(rb_key);
+
+  if (str_len == 0) return sym_escape;
+
+  for(long i = 0; i < str_len; i++) {
+    const char c = *(str + i);
+
+    if (c == '\n') {
+      return sym_escape;
+    }
+
+    const bool is_upper_alpha = c >= 'A' && c <= 'Z';
+    const bool is_lower_alpha = c >= 'a' && c <= 'z';
+    const bool is_number = c >= '0' && c <= '9';
+    const bool is_dash = c == '-';
+    const bool is_underscore = c == '_';
+
+    if (!(is_upper_alpha || is_lower_alpha || is_number || is_dash || is_underscore)) {
+      return sym_quoted;
+    }
+  }
+
+  return sym_simple;
+}
+
+/**
+ * Ruby's extension entry point
+ */
+void Init_tomlib(void) {
+  id_new = rb_intern("new");
+
+  sym_simple = ID2SYM(rb_intern("simple"));
+  rb_global_variable(&sym_simple);
+  sym_quoted = ID2SYM(rb_intern("quoted"));
+  rb_global_variable(&sym_quoted);
+  sym_escape = ID2SYM(rb_intern("escape"));
+  rb_global_variable(&sym_escape);
+
+  cDate = rb_const_get(rb_cObject, rb_intern("Date"));
+  rb_global_variable(&cDate);
+
+  mTomlib = rb_define_module("Tomlib");
+  rb_define_singleton_method(mTomlib, "load", tomlib_load, 1);
+
+  cDumper = rb_define_class_under(mTomlib, "Dumper", rb_cObject);
+  rb_define_private_method(cDumper, "key_type", tomlib_key_type, 1);
+
+  cParserError = rb_define_class_under(mTomlib, "ParseError", rb_eStandardError);
+}

data/lib/tomlib/dumper.rb

@@ -74,7 +74,7 @@ module Tomlib
           end
 
           footer << dump_hash(value, compound_key, skip ? indent_level : indent_level + 1)
-        elsif value.is_a?(Array) && value.all? { |e| e.is_a?(Hash) }
+        elsif value.is_a?(Array) && !value.empty? && value.all? { |e| e.is_a?(Hash) }
           compound_key = to_toml_compound_key(base_key, toml_key)
           indent = @use_indent ? INDENT * indent_level : ''.freeze
 
@@ -148,7 +148,7 @@ module Tomlib
       when Hash
         "{ #{value.map { |k, v| "#{to_toml_key(k)} = #{to_toml_value(v)}" }.join(', ')} }"
       when Array
-        "[ #{value.map { |e| to_toml_value(e) }.join(', ')} ]"
+        value.empty? ? '[]' : "[ #{value.map { |e| to_toml_value(e) }.join(', ')} ]"
       when nil
         '""'.freeze
       else

data/lib/tomlib/version.rb

@@ -2,5 +2,5 @@
 
 module Tomlib
   # @api private
-  VERSION = '0.2.0'
+  VERSION = '0.5.0'
 end

data/tomlib.gemspec

@@ -20,10 +20,17 @@ Gem::Specification.new do |spec|
   spec.metadata['changelog_uri'] = 'https://github.com/kgiszczak/tomlib/blob/master/CHANGELOG.md'
   spec.metadata['bug_tracker_uri'] = 'https://github.com/kgiszczak/tomlib/issues'
 
-  spec.files = Dir['CHANGELOG.md', 'LICENSE.txt', 'README.md', 'tomlib.gemspec', 'lib/**/*']
+  spec.files = Dir[
+    'CHANGELOG.md',
+    'LICENSE.txt',
+    'README.md',
+    'tomlib.gemspec',
+    'ext/**/*',
+    'lib/**/*.rb',
+  ]
   spec.require_paths = ['lib']
 
   spec.extensions = ['ext/tomlib/extconf.rb']
 
-  spec.required_ruby_version = '>= 2.7.0'
+  spec.required_ruby_version = '>= 2.6.0'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: tomlib
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.5.0
 platform: ruby
 authors:
 - Kamil Giszczak
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-08-04 00:00:00.000000000 Z
+date: 2022-08-16 00:00:00.000000000 Z
 dependencies: []
 description: Fast TOML parser and generator with native extension.
 email:
@@ -22,10 +22,12 @@ files:
 - LICENSE.txt
 - README.md
 - ext/tomlib/extconf.rb
+- ext/tomlib/toml.c
+- ext/tomlib/toml.h
+- ext/tomlib/tomlib.c
 - lib/tomlib.rb
 - lib/tomlib/dumper.rb
 - lib/tomlib/error.rb
-- lib/tomlib/tomlib.bundle
 - lib/tomlib/version.rb
 - tomlib.gemspec
 homepage: https://github.com/kgiszczak/tomlib
@@ -45,7 +47,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.7.0
+      version: 2.6.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="