xlsxwriter 0.0.2

data/ext/xlsxwriter/libxlsxwriter/third_party/tmpfileplus/tmpfileplus.h

@@ -0,0 +1,53 @@
+/* $Id: tmpfileplus.h $ */
+/*
+ * $Date: 2016-06-01 03:31Z $
+ * $Revision: 2.0.0 $
+ * $Author: dai $
+ */
+
+/*
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * Copyright (c) 2012-16 David Ireland, DI Management Services Pty Ltd
+ * <http://www.di-mgt.com.au/contact/>.
+ */
+
+#if _MSC_VER > 1000
+#pragma once
+#endif
+
+#ifndef TMPFILEPLUS_H_
+#define TMPFILEPLUS_H_
+
+#include <stdio.h>
+
+/** Create a unique temporary file.
+@param dir (optional) directory to create file. If NULL use default TMP directory.
+@param prefix (optional) prefix for file name. If NULL use "tmp.".
+@param pathname (optional) pointer to a buffer to receive the temp filename. 
+	Allocated using `malloc()`; user to free. Ignored if NULL.
+@param keep If `keep` is nonzero and `pathname` is not NULL, then keep the file after closing. 
+	Otherwise file is automatically deleted when closed.
+@return Pointer to stream opened in binary read/write (w+b) mode, or a null pointer on error.
+@exception ENOMEM Not enough memory to allocate filename.
+*/
+FILE *tmpfileplus(const char *dir, const char *prefix, char **pathname, int keep);
+
+
+/** Create a unique temporary file with filename stored in a fixed-length buffer.
+@param dir (optional) directory to create file. If NULL use default directory.
+@param prefix (optional) prefix for file name. If NULL use "tmp.".
+@param pathnamebuf (optional) buffer to receive full pathname of temporary file. Ignored if NULL.
+@param pathsize Size of buffer to receive filename and its terminating null character.
+@param keep If `keep` is nonzero and `pathname` is not NULL, then keep the file after closing.
+	Otherwise file is automatically deleted when closed.
+@return Pointer to stream opened in binary read/write (w+b) mode, or a null pointer on error.
+@exception E2BIG Resulting filename is too big for the buffer `pathnamebuf`.
+*/
+FILE *tmpfileplus_f(const char *dir, const char *prefix, char *pathnamebuf, size_t pathsize, int keep);
+
+#define TMPFILE_KEEP 1
+
+#endif /* end TMPFILEPLUS_H_ */

data/ext/xlsxwriter/workbook.c

@@ -0,0 +1,257 @@
+#include <string.h>
+#include "xlsxwriter.h"
+#include "format.h"
+#include "workbook.h"
+
+VALUE
+workbook_alloc(VALUE klass)
+{
+  VALUE obj;
+  struct workbook *ptr;
+
+  obj = Data_Make_Struct(klass, struct workbook, NULL, workbook_free, ptr);
+
+  ptr->path = NULL;
+  ptr->workbook = NULL;
+  ptr->formats = NULL;
+  ptr->properties = NULL;
+
+  return obj;
+}
+
+VALUE
+workbook_new_(int argc, VALUE *argv, VALUE self) {
+  VALUE workbook = rb_call_super(argc, argv);
+  if (rb_block_given_p()) {
+    rb_yield(workbook);
+    workbook_release(workbook);
+    return Qnil;
+  }
+  return workbook;
+}
+
+VALUE
+workbook_init(int argc, VALUE *argv, VALUE self) {
+  struct workbook *ptr;
+  lxw_workbook_options options = {
+    .constant_memory = 0,
+    .tmpdir = NULL
+  };
+
+  if (argc < 1 || argc > 2) {
+    rb_raise(rb_eArgError, "wrong number of arguments");
+    return self;
+  } else if (argc == 2) {
+    VALUE const_mem = rb_hash_aref(argv[1], ID2SYM(rb_intern("constant_memory")));
+    if (!NIL_P(const_mem) && const_mem) {
+      options.constant_memory = 1;
+      VALUE tmpdir = rb_hash_aref(argv[1], ID2SYM(rb_intern("tmpdir")));
+      if (!NIL_P(tmpdir))
+        options.tmpdir = RSTRING_PTR(tmpdir);
+    }
+  }
+
+  Data_Get_Struct(self, struct workbook, ptr);
+
+  size_t len = RSTRING_LEN(argv[0]);
+  ptr->path = malloc(len + 1);
+  strncpy(ptr->path, RSTRING_PTR(argv[0]), len + 1);
+  if (options.constant_memory) {
+    ptr->workbook = workbook_new_opt(ptr->path, &options);
+  } else {
+    ptr->workbook = workbook_new(ptr->path);
+  }
+  ptr->properties = NULL;
+  rb_iv_set(self, "@font_sizes", rb_hash_new());
+
+  return self;
+}
+
+VALUE
+workbook_release(VALUE self) {
+  struct workbook *ptr;
+  Data_Get_Struct(self, struct workbook, ptr);
+
+  workbook_free(ptr);
+  return self;
+}
+
+void
+workbook_free(void *p) {
+  struct workbook *ptr = p;
+
+  if (ptr->workbook) {
+    if (ptr->properties) {
+      workbook_set_properties(ptr->workbook, ptr->properties);
+    }
+    workbook_close(ptr->workbook);
+    ptr->workbook = NULL;
+  }
+  if (ptr->path) {
+    free(ptr->path);
+    ptr->path = NULL;
+  }
+  if (ptr->formats) {
+    st_free_table(ptr->formats);
+    ptr->formats = NULL;
+  };
+
+  if (ptr->properties) {
+#define FREE_PROP(prop) {              \
+      if (ptr->properties->prop) {     \
+        xfree(ptr->properties->prop);  \
+        ptr->properties->prop = NULL;  \
+      }                                \
+    }
+    FREE_PROP(title);
+    FREE_PROP(subject);
+    FREE_PROP(author);
+    FREE_PROP(manager);
+    FREE_PROP(company);
+    FREE_PROP(category);
+    FREE_PROP(keywords);
+    FREE_PROP(comments);
+    FREE_PROP(status);
+    FREE_PROP(hyperlink_base);
+#undef FREE_PROP
+    free(ptr->properties);
+    ptr->properties = NULL;
+  }
+}
+
+VALUE
+workbook_add_worksheet_(int argc, VALUE *argv, VALUE self) {
+  VALUE worksheet = Qnil;
+
+  if (argc > 1) {
+    rb_raise(rb_eArgError, "wrong number of arguments");
+    return Qnil;
+  }
+
+  struct workbook *ptr;
+  Data_Get_Struct(self, struct workbook, ptr);
+  if (ptr->workbook) {
+    VALUE mXlsxWriter = rb_const_get(rb_cObject, rb_intern("XlsxWriter"));
+    VALUE cWorksheet = rb_const_get(mXlsxWriter, rb_intern("Worksheet"));
+    worksheet = rb_funcall(cWorksheet, rb_intern("new"), argc + 1, self, argv[0]);
+  }
+
+  if (rb_block_given_p()) {
+    VALUE res = rb_yield(worksheet);
+    return res;
+  }
+
+  return worksheet;
+}
+
+VALUE
+workbook_add_format_(VALUE self, VALUE key, VALUE opts) {
+  struct workbook *ptr;
+  lxw_format *format;
+  Data_Get_Struct(self, struct workbook, ptr);
+
+  if (!ptr->formats) {
+    ptr->formats = st_init_numtable();
+  }
+
+  format = workbook_add_format(ptr->workbook);
+  st_insert(ptr->formats, rb_to_id(key), (st_data_t)format);
+  format_apply_opts(format, opts);
+
+  VALUE font_size = rb_hash_aref(opts, ID2SYM(rb_intern("font_size")));
+  if (!NIL_P(font_size)) {
+    VALUE bold = rb_hash_aref(opts, ID2SYM(rb_intern("bold")));
+    if (!NIL_P(bold) && bold) {
+      rb_hash_aset(rb_iv_get(self, "@font_sizes"), key, rb_float_new(NUM2DBL(font_size) * 1.5));
+    } else {
+      rb_hash_aset(rb_iv_get(self, "@font_sizes"), key, font_size);
+    }
+  }
+
+  return self;
+}
+
+VALUE
+workbook_add_chart_(VALUE self, VALUE type) {
+  VALUE chart = rb_funcall(cChart, rb_intern("new"), 2, self, type);
+  if (rb_block_given_p()) {
+    VALUE res = rb_yield(chart);
+    return res;
+  }
+  return chart;
+}
+
+VALUE
+workbook_set_default_xf_indices_(VALUE self) {
+  struct workbook *ptr;
+  Data_Get_Struct(self, struct workbook, ptr);
+  lxw_workbook_set_default_xf_indices(ptr->workbook);
+  return self;
+}
+
+VALUE
+workbook_properties_(VALUE self) {
+  VALUE props = rb_obj_alloc(cWorkbookProperties);
+  rb_obj_call_init(props, 1, &self);
+  return props;
+}
+
+VALUE
+workbook_define_name_(VALUE self, VALUE name, VALUE formula) {
+  struct workbook *ptr;
+  Data_Get_Struct(self, struct workbook, ptr);
+  workbook_define_name(ptr->workbook, StringValueCStr(name), StringValueCStr(formula));
+  return self;
+}
+
+VALUE
+workbook_validate_worksheet_name_(VALUE self, VALUE name) {
+  struct workbook *ptr;
+  lxw_error err;
+  Data_Get_Struct(self, struct workbook, ptr);
+  err = workbook_validate_worksheet_name(ptr->workbook, StringValueCStr(name));
+  handle_lxw_error(err);
+  return Qtrue;
+}
+
+
+lxw_format *
+workbook_get_format(VALUE self, VALUE key) {
+  struct workbook *ptr;
+  lxw_format *format = NULL;
+
+  if (NIL_P(key))
+    return NULL;
+
+  Data_Get_Struct(self, struct workbook, ptr);
+
+  if (!ptr->formats)
+    return NULL;
+
+  st_lookup(ptr->formats, rb_to_id(key), (st_data_t *) &format);
+
+  return format;
+}
+
+lxw_datetime
+value_to_lxw_datetime(VALUE val) {
+  const ID i_to_time = rb_intern("to_time");
+  if (rb_respond_to(val, i_to_time)) {
+    val = rb_funcall(val, i_to_time, 0);
+  }
+  lxw_datetime res = {
+    .year  = NUM2INT(rb_funcall(val, rb_intern("year"), 0)),
+    .month = NUM2INT(rb_funcall(val, rb_intern("month"), 0)),
+    .day   = NUM2INT(rb_funcall(val, rb_intern("day"), 0)),
+    .hour  = NUM2INT(rb_funcall(val, rb_intern("hour"), 0)),
+    .min   = NUM2INT(rb_funcall(val, rb_intern("min"), 0)),
+    .sec   = NUM2DBL(rb_funcall(val, rb_intern("sec"), 0)) +
+    NUM2DBL(rb_funcall(val, rb_intern("subsec"), 0))
+  };
+  return res;
+}
+
+void
+handle_lxw_error(lxw_error err) {
+  return;
+}

data/ext/xlsxwriter/workbook.h

@@ -0,0 +1,42 @@
+#include <ruby.h>
+
+#ifndef __WORKBOOK__
+#define __WORKBOOK__
+
+struct workbook {
+  char *path;
+  lxw_workbook *workbook;
+  lxw_doc_properties *properties;
+  st_table *formats;
+};
+
+
+VALUE workbook_alloc(VALUE klass);
+VALUE workbook_new_(int argc, VALUE *argv, VALUE self);
+VALUE workbook_init(int argc, VALUE *argv, VALUE self);
+VALUE workbook_release(VALUE self);
+void workbook_free(void *);
+
+VALUE workbook_add_worksheet_(int argc, VALUE *argv, VALUE self);
+VALUE workbook_add_format_(VALUE self, VALUE key, VALUE opts);
+VALUE workbook_add_chart_(VALUE self, VALUE type);
+VALUE workbook_set_default_xf_indices_(VALUE self);
+VALUE workbook_properties_(VALUE self);
+VALUE workbook_define_name_(VALUE self, VALUE name, VALUE formula);
+VALUE workbook_validate_worksheet_name_(VALUE self, VALUE name);
+
+
+lxw_format *workbook_get_format(VALUE self, VALUE key);
+lxw_datetime value_to_lxw_datetime(VALUE val);
+void handle_lxw_error(lxw_error err);
+
+extern VALUE mXlsxWriter;
+extern VALUE cWorkbook;
+extern VALUE cWorksheet;
+extern VALUE mXlsxFormat;
+extern VALUE cWorkbookProperties;
+extern VALUE cChart;
+extern VALUE cChartSeries;
+extern VALUE cChartAxis;
+
+#endif // __WORKBOOK__

data/ext/xlsxwriter/workbook_properties.c

@@ -0,0 +1,103 @@
+#include <string.h>
+#include <ruby/util.h>
+#include "xlsxwriter.h"
+#include "workbook.h"
+#include "workbook_properties.h"
+
+VALUE
+workbook_properties_init_(VALUE self, VALUE workbook) {
+  struct workbook *wb_ptr;
+  rb_iv_set(self, "@workbook", workbook);
+  Data_Get_Struct(workbook, struct workbook, wb_ptr);
+  if (!wb_ptr->properties) {
+    wb_ptr->properties = calloc(1, sizeof(lxw_doc_properties));
+  }
+  if (rb_block_given_p()) {
+    rb_yield(self);
+  }
+  return self;
+}
+
+VALUE
+workbook_properties_set_dir_(VALUE self, VALUE value) {
+  VALUE key = rb_id2str(rb_frame_callee());
+  char *key_str = ruby_strdup(RSTRING_PTR(key));
+  size_t last_pos = RSTRING_LEN(key) - 1;
+  if (last_pos > 0 && key_str[last_pos] == '=') {
+    key_str[last_pos] = '\0';
+  }
+  key = rb_str_new_cstr(key_str);
+  workbook_properties_set_(self, key, value);
+  xfree(key_str);
+  return value;
+}
+
+VALUE
+workbook_properties_set_(VALUE self, VALUE key, VALUE value) {
+  char *key_cstr = NULL;
+  switch (TYPE(key)) {
+  case T_STRING:
+    key_cstr = StringValueCStr(key);
+    break;
+  case T_SYMBOL:
+    key = rb_sym2str(key);
+    key_cstr = StringValueCStr(key);
+    break;
+  default:
+    rb_raise(rb_eArgError, "Wrong type of key: %"PRIsVALUE, rb_obj_class(key));
+  }
+
+  struct workbook *wb_ptr;
+  Data_Get_Struct(rb_iv_get(self, "@workbook"), struct workbook, wb_ptr);
+  lxw_doc_properties *props = wb_ptr->properties;
+  if (!props) {
+    rb_raise(rb_eRuntimeError, "Workbook properties are already freed.");
+  }
+
+#define HANDLE_PROP(prop) {                              \
+    if (!strcmp(#prop, key_cstr)) {                      \
+      props->prop = ruby_strdup(StringValueCStr(value)); \
+      return value;                                      \
+    }                                                    \
+  }
+  HANDLE_PROP(title);
+  HANDLE_PROP(subject);
+  HANDLE_PROP(author);
+  HANDLE_PROP(manager);
+  HANDLE_PROP(company);
+  HANDLE_PROP(category);
+  HANDLE_PROP(keywords);
+  HANDLE_PROP(comments);
+  HANDLE_PROP(status);
+  HANDLE_PROP(hyperlink_base);
+#undef HANDLE_PROP
+
+  // Not a standard property.
+  switch (TYPE(value)) {
+  case T_NIL:
+    break;
+  case T_STRING:
+    workbook_set_custom_property_string(wb_ptr->workbook, key_cstr, StringValueCStr(value));
+    break;
+  case T_FLOAT: case T_RATIONAL:
+    workbook_set_custom_property_number(wb_ptr->workbook, key_cstr, NUM2DBL(value));
+    break;
+  case T_FIXNUM: case T_BIGNUM:
+    workbook_set_custom_property_integer(wb_ptr->workbook, key_cstr, NUM2INT(value));
+    break;
+  case T_TRUE: case T_FALSE:
+    workbook_set_custom_property_boolean(wb_ptr->workbook, key_cstr, value != Qfalse);
+    break;
+  case T_DATA:
+    if (rb_obj_class(value) == rb_cTime) {
+      lxw_datetime datetime = value_to_lxw_datetime(value);
+      workbook_set_custom_property_datetime(wb_ptr->workbook, key_cstr, &datetime);
+    } else {
+      rb_raise(rb_eTypeError, "wrong argument type %"PRIsVALUE
+               " (must be string, numeric, true, false, nil or time)",
+               rb_obj_class(value));
+    }
+    break;
+  }
+  return value;
+}