xlsxwriter 0.1.2.pre → 0.2.0.pre

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2fb20c025afb481308dc6787fa972d8e5675c20b6de467ade855dc051b1b48f2
-  data.tar.gz: 04535f83606938834b2eca512d68a38c4b3e056c4ee660a06e86f8a20ea1454e
+  metadata.gz: 408b3a45c34215b79898280c419cf2adafbde2bf0a4037f11a0432972c7861cf
+  data.tar.gz: d162bd3b0043aa39114baa98a28665fe8931c22e8252f5a0e9040c2a10c62319
 SHA512:
-  metadata.gz: a3e97984e91290594bf91c438de8ad68f271de79b0dd7bbdef36539f1fe47db589269a956e00b69e75a41ad7fbd627dd143e37abe7e8d6c1cdc1341fab42dbd2
-  data.tar.gz: 1a7d898c096afef2e230d04db7e0180c8dca48bfc72c7cbca6819a300fc8259ad70d6cf55a85368e9df37d717522760725c7d4e878732973ccaf410ce8ba3490
+  metadata.gz: 566117022982bb38edc6b2048567a10a5174fae628fa6b47c85324d721ea4e4448360d82c9b8656af85bd0b28639ef9efc3a0c1d625f8b4d1a1dc19c141ac306
+  data.tar.gz: 54c7504e4bcafd1f982a45dbf98ebec925c9880ae8797022920c24c00af5926e51d55ca70d822a1298aa4a3fa13390c4030d17fbe14b7754f3e6aee6a252448d

data/ext/xlsxwriter/chart.c

@@ -593,8 +593,15 @@ void init_xlsxwriter_chart() {
   MAP_CHART_CONST(LEGEND_LEFT);
   MAP_CHART_CONST(LEGEND_TOP);
   MAP_CHART_CONST(LEGEND_BOTTOM);
+  MAP_CHART_CONST(LEGEND_TOP_RIGHT);
   MAP_CHART_CONST(LEGEND_OVERLAY_RIGHT);
   MAP_CHART_CONST(LEGEND_OVERLAY_LEFT);
+  MAP_CHART_CONST(LEGEND_OVERLAY_TOP_RIGHT);
+
+  MAP_CHART_CONST(AXIS_LABEL_ALIGN_CENTER);
+  MAP_CHART_CONST(AXIS_LABEL_ALIGN_LEFT);
+  MAP_CHART_CONST(AXIS_LABEL_ALIGN_RIGHT);
+
 
 #undef MAP_CHART_CONST
 }

data/ext/xlsxwriter/libxlsxwriter/include/xlsxwriter/common.h

@@ -219,6 +219,8 @@ enum lxw_custom_property_types {
     if (error)                                  \
         return error;
 
+#if 0
+
 #define LXW_WARN(message)                       \
     fprintf(stderr, "[WARNING]: " message "\n")
 
@@ -268,6 +270,20 @@ enum lxw_custom_property_types {
        return;                                                             \
     }
 
+#else
+
+#define LXW_WARN(message) {}
+#define LXW_WARN_FORMAT(message) {}
+#define LXW_WARN_FORMAT1(message, var) {}
+#define LXW_WARN_FORMAT2(message, var1, var2) {}
+#define LXW_WARN_CAT_AXIS_ONLY(function) {}
+#define LXW_WARN_VALUE_AXIS_ONLY(function) {}
+#define LXW_WARN_DATE_AXIS_ONLY(function) {}
+#define LXW_WARN_CAT_AND_DATE_AXIS_ONLY(function) {}
+#define LXW_WARN_VALUE_AND_DATE_AXIS_ONLY(function) {}
+
+#endif
+
 #ifndef LXW_BIG_ENDIAN
 #define LXW_UINT32_NETWORK(n) ((((n) & 0xFF)       << 24) | \
                                (((n) & 0xFF00)     <<  8) | \

data/ext/xlsxwriter/worksheet.c

@@ -1,6 +1,7 @@
 #include "chart.h"
 #include "worksheet.h"
 #include "workbook.h"
+#include "xlsxwriter_ext.h"
 
 VALUE cWorksheet;
 
@@ -461,9 +462,17 @@ worksheet_set_row_(VALUE self, VALUE row, VALUE opts) {
   if (val != Qnil && val)
     options.hidden = 1;
 
+  val = rb_hash_aref(opts, ID2SYM(rb_intern("collapse")));
+  if (val != Qnil && val)
+    options.collapsed = 1;
+
+  val = rb_hash_aref(opts, ID2SYM(rb_intern("level")));
+  if (val != Qnil)
+    options.level = NUM2INT(val);
+
   struct worksheet *ptr;
   Data_Get_Struct(self, struct worksheet, ptr);
-  if (options.hidden) {
+  if (options.hidden || options.collapsed || options.level) {
     worksheet_set_row_opt(ptr->worksheet, NUM2INT(row), height, format, &options);
   } else {
     worksheet_set_row(ptr->worksheet, NUM2INT(row), height, format);
@@ -500,9 +509,17 @@ worksheet_set_column_(VALUE self, VALUE col_from, VALUE col_to, VALUE opts) {
   if (val != Qnil && val)
     options.hidden = 1;
 
+  val = rb_hash_aref(opts, ID2SYM(rb_intern("collapse")));
+  if (val != Qnil && val)
+    options.collapsed = 1;
+
+  val = rb_hash_aref(opts, ID2SYM(rb_intern("level")));
+  if (val != Qnil)
+    options.level = NUM2INT(val);
+
   struct worksheet *ptr;
   Data_Get_Struct(self, struct worksheet, ptr);
-  if (options.hidden) {
+  if (options.hidden || options.collapsed || options.level) {
     worksheet_set_column_opt(ptr->worksheet, col1, col2, width, format, &options);
   } else {
     worksheet_set_column(ptr->worksheet, col1, col2, width, format);
@@ -1195,6 +1212,27 @@ worksheet_protect_(int argc, VALUE *argv, VALUE self) {
   return self;
 }
 
+/*  call-seq: ws.outline_settings = { visible: true, symbols_below: true, symbols_right: true, auto_style: false }
+ *
+ *  Sets the Outline and Grouping display properties.
+ */
+VALUE
+worksheet_outline_settings_(VALUE self, VALUE opts) {
+  struct worksheet *ptr;
+  Data_Get_Struct(self, struct worksheet, ptr);
+  VALUE value;
+#define parse_param(name, default)                                      \
+  value = rb_hash_aref(opts, ID2SYM(rb_intern(#name)));                 \
+  uint8_t name = NIL_P(value) ? default : (value ? LXW_TRUE : LXW_FALSE)
+  parse_param(visible, LXW_TRUE);
+  parse_param(symbols_below, LXW_TRUE);
+  parse_param(symbols_right, LXW_TRUE);
+  parse_param(auto_style, LXW_FALSE);
+#undef parse_param
+  worksheet_outline_settings(ptr->worksheet, visible, symbols_below, symbols_right, auto_style);
+  return self;
+}
+
 /*  call-seq: ws.set_default_row(height, hide_unuser_rows) -> self
  *
  *  Sets the default row properties for the worksheet.
@@ -1231,6 +1269,167 @@ worksheet_set_vertical_dpi_(VALUE self, VALUE val) {
   return val;
 }
 
+/*  call-seq:
+ *     ws.add_data_validation(cell, options) -> self
+ *     ws.add_data_validation(range, options) -> self
+ *     ws.add_data_validation(row, col, options) -> self
+ *     ws.add_data_validation(row_from, col_from, row_to, col_to, options) -> self
+ *
+ *  Adds data validation or limits user input to a list of values.
+ */
+VALUE
+worksheet_data_validation_(int argc, VALUE *argv, VALUE self) {
+  lxw_data_validation data_validation = {0};
+  rb_check_arity(argc, 2, 5);
+  char range = 0;
+  if (argc > 3) {
+    range = 1;
+  } else if (TYPE(argv[0]) == T_STRING) {
+    char *str = RSTRING_PTR(argv[0]);
+    if (strstr(str, ":")) {
+      range = 1;
+    } else if ((str[0] >= 'A' && str[0] <= 'Z') ||
+               (str[0] >= 'a' && str[0] <= 'z'))
+      range = argc > 2;
+  }
+
+  lxw_row_t row, row2;
+  lxw_col_t col, col2;
+  int larg;
+  if (range) {
+    larg = extract_range(argc, argv, &row, &col, &row2, &col2);
+  } else {
+    larg = extract_cell(argc, argv, &row, &col);
+  }
+
+  if (larg != argc - 1) {
+    rb_raise(rb_eArgError, "Wrong number of arguments");
+  }
+  VALUE opts = argv[larg];
+  if (TYPE(opts) != T_HASH) {
+    rb_raise(rb_eTypeError, "Wrong type for options %"PRIsVALUE", Hash expected", rb_obj_class(opts));
+  }
+
+  VALUE val;
+  val = rb_hash_aref(opts, ID2SYM(rb_intern("validate")));
+  if (!NIL_P(val)) {
+    data_validation.validate = NUM2INT(val);
+  }
+
+  val = rb_hash_aref(opts, ID2SYM(rb_intern("criteria")));
+  if (!NIL_P(val)) {
+    data_validation.criteria = NUM2INT(val);
+  }
+
+  val = rb_hash_aref(opts, ID2SYM(rb_intern("ignore_blank")));
+  if (!NIL_P(val) && val) {
+    data_validation.ignore_blank = LXW_VALIDATION_ON;
+  }
+
+  val = rb_hash_aref(opts, ID2SYM(rb_intern("show_input")));
+  if (!NIL_P(val) && val) {
+    data_validation.show_input = LXW_VALIDATION_ON;
+  }
+
+  val = rb_hash_aref(opts, ID2SYM(rb_intern("show_error")));
+  if (!NIL_P(val) && val) {
+    data_validation.show_error = LXW_VALIDATION_ON;
+  }
+
+  val = rb_hash_aref(opts, ID2SYM(rb_intern("error_type")));
+  if (!NIL_P(val)) {
+    data_validation.error_type = NUM2INT(val);
+  }
+
+  val = rb_hash_aref(opts, ID2SYM(rb_intern("dropdown")));
+  if (!NIL_P(val) && val) {
+    data_validation.dropdown = LXW_VALIDATION_ON;
+  }
+
+  val = rb_hash_aref(opts, ID2SYM(rb_intern("input_title")));
+  if (!NIL_P(val)) {
+    data_validation.input_title = RSTRING_PTR(val);
+  }
+
+  val = rb_hash_aref(opts, ID2SYM(rb_intern("input_message")));
+  if (!NIL_P(val)) {
+    data_validation.input_message = RSTRING_PTR(val);
+  }
+
+  val = rb_hash_aref(opts, ID2SYM(rb_intern("error_title")));
+  if (!NIL_P(val)) {
+    data_validation.error_title = RSTRING_PTR(val);
+  }
+
+  val = rb_hash_aref(opts, ID2SYM(rb_intern("error_message")));
+  if (!NIL_P(val)) {
+    data_validation.error_message = RSTRING_PTR(val);
+  }
+
+  VALUE is_datetime;
+#define parse_array_0(x)
+#define parse_array_1(prefix)                                           \
+    if (TYPE(val) == T_ARRAY) {                                         \
+      int len = RARRAY_LEN(val);                                        \
+      data_validation.prefix##_list = malloc(sizeof(char *) * (len + 1)); \
+      data_validation.prefix##_list[len] = NULL;                        \
+      for (int i = 0; i < len; ++i) {                                   \
+        data_validation.prefix##_list[i] = RSTRING_PTR(rb_ary_entry(val, i)); \
+      }                                                                 \
+    } else
+
+#define parse_value(prefix, key, handle_array)                          \
+  val = rb_hash_aref(opts, ID2SYM(rb_intern(key)));                     \
+  if (!NIL_P(val)) {                                                    \
+    switch(TYPE(val)) {                                                 \
+    case T_FLOAT: case T_FIXNUM: case T_BIGNUM:                         \
+      data_validation.prefix##_number = NUM2DBL(val);                   \
+      break;                                                            \
+    case T_STRING:                                                      \
+      data_validation.prefix##_formula = RSTRING_PTR(val);              \
+      if (data_validation.prefix##_formula[0] != '=') {                 \
+        data_validation.prefix##_formula = 0;                           \
+        rb_raise(rb_eArgError, "Is not a formula: %"PRIsVALUE, val);    \
+      }                                                                 \
+      break;                                                            \
+    default:                                                            \
+      is_datetime = rb_funcall(val, rb_intern("is_a?"), 1, rb_cTime);   \
+      parse_array_##handle_array(prefix)                                \
+      if (is_datetime || rb_respond_to(val, rb_intern("to_time"))) {    \
+        if (!is_datetime)                                               \
+          val = rb_funcall(val, rb_intern("to_time"), 0);               \
+        data_validation.prefix##_datetime = value_to_lxw_datetime(val); \
+      } else {                                                          \
+        rb_raise(rb_eTypeError, "Cannot handle " key " type %"PRIsVALUE, rb_class_of(val)); \
+      }                                                                 \
+    }                                                                   \
+  }
+
+  parse_value(minimum, "min", 0);
+  parse_value(maximum, "max", 0);
+  parse_value(value, "value", 1);
+
+#undef parse_array_0
+#undef parse_array_1
+#undef parse_value
+
+  struct worksheet *ptr;
+  Data_Get_Struct(self, struct worksheet, ptr);
+  lxw_error err;
+  if (range) {
+    err = worksheet_data_validation_range(ptr->worksheet, row, col, row2, col2, &data_validation);
+  } else {
+    err = worksheet_data_validation_cell(ptr->worksheet, row, col, &data_validation);
+  }
+
+  if (data_validation.value_list) {
+    free(data_validation.value_list);
+  }
+
+  handle_xlsxwriter_error(err);
+
+  return self;
+}
 
 lxw_col_t
 value_to_col(VALUE value) {
@@ -1402,12 +1601,16 @@ init_xlsxwriter_worksheet() {
   rb_define_method(cWorksheet, "hide_zero", worksheet_hide_zero_, 0);
   rb_define_method(cWorksheet, "tab_color=", worksheet_set_tab_color_, 1);
   rb_define_method(cWorksheet, "protect", worksheet_protect_, -1);
+  rb_define_method(cWorksheet, "outline_settings=", worksheet_outline_settings_, 1);
   rb_define_method(cWorksheet, "set_default_row", worksheet_set_default_row_, 2);
 
   rb_define_method(cWorksheet, "vertical_dpi", worksheet_get_vertical_dpi_, 0);
   rb_define_method(cWorksheet, "vertical_dpi=", worksheet_set_vertical_dpi_, 1);
 
+  rb_define_method(cWorksheet, "add_data_validation", worksheet_data_validation_, -1);
+
 #define MAP_LXW_WH_CONST(name, val_name) rb_define_const(cWorksheet, #name, INT2NUM(LXW_##val_name))
+#define MAP_LXW_WH_CONST1(name) MAP_LXW_WH_CONST(name, name)
   MAP_LXW_WH_CONST(DEF_COL_WIDTH, DEF_COL_WIDTH);
   MAP_LXW_WH_CONST(DEF_ROW_HEIGHT, DEF_ROW_HEIGHT);
 
@@ -1415,5 +1618,30 @@ init_xlsxwriter_worksheet() {
   MAP_LXW_WH_CONST(GRIDLINES_SHOW_SCREEN, SHOW_SCREEN_GRIDLINES);
   MAP_LXW_WH_CONST(GRIDLINES_SHOW_PRINT, SHOW_PRINT_GRIDLINES);
   MAP_LXW_WH_CONST(GRIDLINES_SHOW_ALL, SHOW_ALL_GRIDLINES);
+
+  MAP_LXW_WH_CONST1(VALIDATION_TYPE_INTEGER);
+  MAP_LXW_WH_CONST1(VALIDATION_TYPE_INTEGER_FORMULA);
+  MAP_LXW_WH_CONST1(VALIDATION_TYPE_DECIMAL);
+  MAP_LXW_WH_CONST1(VALIDATION_TYPE_DECIMAL_FORMULA);
+  MAP_LXW_WH_CONST1(VALIDATION_TYPE_LIST);
+  MAP_LXW_WH_CONST1(VALIDATION_TYPE_LIST_FORMULA);
+  MAP_LXW_WH_CONST1(VALIDATION_TYPE_DATE);
+  MAP_LXW_WH_CONST1(VALIDATION_TYPE_DATE_FORMULA);
+  MAP_LXW_WH_CONST1(VALIDATION_TYPE_TIME);
+  MAP_LXW_WH_CONST1(VALIDATION_TYPE_TIME_FORMULA);
+  MAP_LXW_WH_CONST1(VALIDATION_TYPE_LENGTH);
+  MAP_LXW_WH_CONST1(VALIDATION_TYPE_LENGTH_FORMULA);
+  MAP_LXW_WH_CONST1(VALIDATION_TYPE_CUSTOM_FORMULA);
+  MAP_LXW_WH_CONST1(VALIDATION_TYPE_ANY);
+
+  MAP_LXW_WH_CONST1(VALIDATION_CRITERIA_BETWEEN);
+  MAP_LXW_WH_CONST1(VALIDATION_CRITERIA_NOT_BETWEEN);
+  MAP_LXW_WH_CONST1(VALIDATION_CRITERIA_EQUAL_TO);
+  MAP_LXW_WH_CONST1(VALIDATION_CRITERIA_NOT_EQUAL_TO);
+  MAP_LXW_WH_CONST1(VALIDATION_CRITERIA_GREATER_THAN);
+  MAP_LXW_WH_CONST1(VALIDATION_CRITERIA_LESS_THAN);
+  MAP_LXW_WH_CONST1(VALIDATION_CRITERIA_GREATER_THAN_OR_EQUAL_TO);
+  MAP_LXW_WH_CONST1(VALIDATION_CRITERIA_LESS_THAN_OR_EQUAL_TO);
+#undef MAP_LXW_WH_CONST1
 #undef MAP_LXW_WH_CONST
 }

data/ext/xlsxwriter/xlsxwriter.c

@@ -8,6 +8,7 @@
 
 VALUE mXlsxWriter;
 VALUE rbLibVersion;
+VALUE eXlsxWriterError;
 
 /*  Document-module: XlsxWriter
  *
@@ -32,6 +33,7 @@ void Init_xlsxwriter() {
   mXlsxWriter = rb_define_module("XlsxWriter");
   rbLibVersion = rb_str_new_cstr(lxw_version());
   rb_define_const(mXlsxWriter, "LIBRARY_VERSION", rbLibVersion);
+  eXlsxWriterError = rb_define_class_id_under(mXlsxWriter, rb_intern("Error"), rb_eStandardError);
 
   init_xlsxwriter_workbook();
   init_xlsxwriter_workbook_properties();

data/ext/xlsxwriter/xlsxwriter_ext.h

@@ -0,0 +1,15 @@
+#include <ruby.h>
+
+#ifndef XLSXWRITER_H
+#define XLSXWRITER_H
+
+extern VALUE mXlsxWriter;
+extern VALUE eXlsxWriterError;
+
+inline void handle_xlsxwriter_error(lxw_error err) {
+  if (err) {
+    rb_raise(eXlsxWriterError, lxw_strerror(err));
+  }
+}
+
+#endif /* XLSXWRITER_H */

data/lib/xlsxwriter/version.rb

@@ -2,5 +2,5 @@
 
 module XlsxWriter
   # :nodoc:
-  VERSION='0.1.2.pre'.freeze
+  VERSION='0.2.0.pre'.freeze
 end

data/test/support/xlsx_comparable.rb

@@ -18,7 +18,7 @@ module XlsxComparable
 
           if %w(.png .jpeg .bmp .bin).include?(File.extname(exp_entry.name))
             exp_xml_str.force_encoding('BINARY')
-            assert_equal(got_xml_str, exp_xml_str)
+            assert_equal(exp_xml_str, got_xml_str)
             next
           end
 
@@ -60,7 +60,7 @@ module XlsxComparable
             exp_xml = _sort_rel_file_data(exp_xml)
           end
 
-          assert_equal got_xml, exp_xml
+          assert_equal exp_xml, got_xml
         end
       end
     end

data/test/test-data-validation.rb

@@ -0,0 +1,107 @@
+# -*- coding: utf-8 -*-
+# frozen_string_literal: true
+
+require_relative './xlsx-func-testcase'
+
+class TestDataValidation < XlsxWriterTestCase
+  test 'data_validation01' do |wb|
+    wb.add_worksheet
+      .add_data_validation 'C2', validate: XlsxWriter::Worksheet::VALIDATION_TYPE_LIST,
+                                 value: %w(Foo Bar Baz)
+  end
+
+  test 'data_validation02' do |wb|
+    wb.add_worksheet
+      .add_data_validation 1, 2, validate: XlsxWriter::Worksheet::VALIDATION_TYPE_LIST,
+                                 value: %w(Foo Bar Baz),
+                                 input_title: 'This is the input title',
+                                 input_message: 'This is the input message'
+  end
+
+  test 'data_validation03' do |wb|
+    wb.add_worksheet
+      .add_data_validation('C2', validate: XlsxWriter::Worksheet::VALIDATION_TYPE_LIST,
+                                 value: %w(Foo Bar Baz),
+                                 input_title: 'This is the input title',
+                                 input_message: 'This is the input message')
+      .add_data_validation('D6', validate: XlsxWriter::Worksheet::VALIDATION_TYPE_LIST,
+                                 value: %w(Foobar Foobas Foobat Foobau Foobav Foobaw Foobax
+                                           Foobay Foobaz Foobba Foobbb Foobbc Foobbd Foobbe
+                                           Foobbf Foobbg Foobbh Foobbi Foobbj Foobbk Foobbl
+                                           Foobbm Foobbn Foobbo Foobbp Foobbq Foobbr Foobbs
+                                           Foobbt Foobbu Foobbv Foobbw Foobbx Foobby Foobbz
+                                           Foobca End),
+                                 input_title: 'This is the longest input title1',
+                                 input_message: 'This is the longest input message ' + 'a' * 221)
+  end
+
+  test 'data_validation04', ref_file_name: 'data_validation02' do |wb|
+    ws = wb.add_worksheet
+      .add_data_validation('C2', validate: XlsxWriter::Worksheet::VALIDATION_TYPE_LIST,
+                                 value: %w(Foo Bar Baz),
+                                 input_title: 'This is the input title',
+                                 input_message: 'This is the input message')
+    assert_raise(XlsxWriter::Error.new('Parameter exceeds Excel\'s limit of 32 characters.')) do
+      ws.add_data_validation('D6', validate: XlsxWriter::Worksheet::VALIDATION_TYPE_LIST,
+                                   value: %w(Foobar Foobas Foobat Foobau Foobav Foobaw Foobax
+                                             Foobay Foobaz Foobba Foobbb Foobbc Foobbd Foobbe
+                                             Foobbf Foobbg Foobbh Foobbi Foobbj Foobbk Foobbl
+                                             Foobbm Foobbn Foobbo Foobbp Foobbq Foobbr Foobbs
+                                             Foobbt Foobbu Foobbv Foobbw Foobbx Foobby Foobbz
+                                             Foobca End),
+                                   input_title: 'This is the longest input title12',
+                                   input_message: 'This is the longest input message ' + 'a' * 221)
+    end
+  end
+
+  test 'data_validation05', ref_file_name: 'data_validation02' do |wb|
+    ws = wb.add_worksheet
+      .add_data_validation('C2', validate: XlsxWriter::Worksheet::VALIDATION_TYPE_LIST,
+                                 value: %w(Foo Bar Baz),
+                                 input_title: 'This is the input title',
+                                 input_message: 'This is the input message')
+    assert_raise(XlsxWriter::Error.new('Parameter exceeds Excel\'s limit of 255 characters.')) do
+      ws.add_data_validation('D6', validate: XlsxWriter::Worksheet::VALIDATION_TYPE_LIST,
+                                   value: %w(Foobar Foobas Foobat Foobau Foobav Foobaw Foobax
+                                             Foobay Foobaz Foobba Foobbb Foobbc Foobbd Foobbe
+                                             Foobbf Foobbg Foobbh Foobbi Foobbj Foobbk Foobbl
+                                             Foobbm Foobbn Foobbo Foobbp Foobbq Foobbr Foobbs
+                                             Foobbt Foobbu Foobbv Foobbw Foobbx Foobby Foobbz
+                                             Foobca End),
+                                   input_title: 'This is the longest input title1',
+                                   input_message: 'This is the longest input message ' + 'a' * 222)
+    end
+  end
+
+  test 'data_validation06', ref_file_name: 'data_validation02' do |wb|
+    ws = wb.add_worksheet
+      .add_data_validation('C2', validate: XlsxWriter::Worksheet::VALIDATION_TYPE_LIST,
+                                 value: %w(Foo Bar Baz),
+                                 input_title: 'This is the input title',
+                                 input_message: 'This is the input message')
+    assert_raise(XlsxWriter::Error.new('Parameter exceeds Excel\'s limit of 255 characters.')) do
+      ws.add_data_validation('D6', validate: XlsxWriter::Worksheet::VALIDATION_TYPE_LIST,
+                                   value: %w(Foobar Foobas Foobat Foobau Foobav Foobaw Foobax
+                                             Foobay Foobaz Foobba Foobbb Foobbc Foobbd Foobbe
+                                             Foobbf Foobbg Foobbh Foobbi Foobbj Foobbk Foobbl
+                                             Foobbm Foobbn Foobbo Foobbp Foobbq Foobbr Foobbs
+                                             Foobbt Foobbu Foobbv Foobbw Foobbx Foobby Foobbz
+                                             Foobca End1),
+                                   input_title: 'This is the longest input title1',
+                                   input_message: 'This is the longest input message ' + 'a' * 221)
+    end
+  end
+
+  test 'data_validation07' do |wb|
+    wb.add_worksheet
+      .add_data_validation 'C2', validate: XlsxWriter::Worksheet::VALIDATION_TYPE_LIST,
+                                 value: %w(coffee café)
+  end
+
+  test 'data_validation08' do |wb|
+    wb.add_worksheet
+      .add_data_validation 'C2:C2', validate: XlsxWriter::Worksheet::VALIDATION_TYPE_ANY,
+                                    input_title: 'This is the input title',
+                                    input_message: 'This is the input message'
+  end
+end

data/test/test-default-row.rb

@@ -12,6 +12,28 @@ class TestDefaultRow < XlsxWriterTestCase
     ws.write_string(9, 'A', 'Bar', nil)
   end
 
+  test 'default_row02' do |wb|
+    ws = wb.add_worksheet
+
+    ws.set_default_row(15, true)
+
+    ws.write_string('A1', 'Foo', nil)
+    ws.write_string('A10', 'Bar', nil)
+
+    (1..8).each { |i| ws.set_row i, height: 15 }
+  end
+
+  test 'default_row03' do |wb|
+    ws = wb.add_worksheet
+
+    ws.set_default_row(24, true)
+
+    ws.write_string('A1', 'Foo', nil)
+    ws.write_string('A10', 'Bar', nil)
+
+    (1..8).each { |i| ws.set_row i, height: 24 }
+  end
+
   test 'default_row05' do |wb|
     ws = wb.add_worksheet
 

data/test/test-defined-name.rb

@@ -29,6 +29,11 @@ class TestDefinedName < XlsxWriterTestCase
     wb.define_name "_Fog",          "=Sheet1!$A$1"
   end
 
+  test 'defined_name02' do |wb|
+    wb.add_worksheet 'sheet One'
+    wb.define_name "Sales", "='sheet One'!$G$1:$H$10"
+  end
+
   test 'defined_name03' do |wb, t|
     t.ignore_elements = { 'xl/worksheets/sheet1.xml' => [ '<pageMargins' ] }
     wb.add_worksheet('sheet One')

data/test/test-fit-to-pages.rb

@@ -3,21 +3,53 @@
 require_relative './xlsx-func-testcase'
 
 class TestFitToPages < XlsxWriterTestCase
+  test 'fit_to_pages01' do |wb, t|
+    t.ignore_elements = { 'xl/worksheets/sheet1.xml' => [ '<pageMargins' ] }
+
+    ws = wb.add_worksheet
+    ws.fit_to_pages 1, 1
+    ws.paper = 9
+    ws.vertical_dpi = 200
+    ws.write_string 'A1', 'Foo'
+  end
+
+  test 'fit_to_pages02' do |wb, t|
+    t.ignore_elements = { 'xl/worksheets/sheet1.xml' => [ '<pageMargins' ] }
+
+    ws = wb.add_worksheet
+    ws.fit_to_pages 2, 1
+    ws.paper = 9
+    ws.vertical_dpi = 200
+    ws.write_string 'A1', 'Foo'
+  end
+
+  test 'fit_to_pages03' do |wb, t|
+    t.ignore_elements = { 'xl/worksheets/sheet1.xml' => [ '<pageMargins' ] }
+
+    ws = wb.add_worksheet
+    ws.fit_to_pages 1, 2
+    ws.paper = 9
+    ws.vertical_dpi = 200
+    ws.write_string 'A1', 'Foo'
+  end
+
   test 'fit_to_pages04' do |wb, t|
     t.ignore_elements = { 'xl/worksheets/sheet1.xml' => [ '<pageMargins' ] }
+
     ws = wb.add_worksheet
     ws.fit_to_pages(3, 2)
     ws.paper = 9
     ws.vertical_dpi = 200
-    ws.write_string 0, 'A', 'Foo', nil
+    ws.write_string 0, 'A', 'Foo'
   end
 
   test 'fit_to_pages05' do |wb, t|
     t.ignore_elements = { 'xl/worksheets/sheet1.xml' => [ '<pageMargins' ] }
+
     ws = wb.add_worksheet
     ws.fit_to_pages(1, 0)
     ws.paper = 9
     ws.vertical_dpi = 200
-    ws.write_string 0, 'A', 'Foo', nil
+    ws.write_string 0, 'A', 'Foo'
   end
 end

data/test/test-formatting.rb

@@ -136,4 +136,57 @@ class TestFormatting < XlsxWriterTestCase
     ws.write_string(1, 'D', 'test', :top_left)
     ws.write_string(1, 'F', 'test', :top_bottom)
   end
+
+  test 'format15' do |wb|
+    wb
+      .add_format(:format1, bold: true)
+      .add_format(:format2, bold: true, num_format_index: 1)
+      .add_worksheet
+      .write_number('A1', 1, :format1)
+      .write_number('A2', 2, :format2)
+  end
+
+  test 'format50' do |wb|
+    wb
+      .add_format(:format1, num_format: '#,##0.00000')
+      .add_format(:format2, num_format: '#,##0.0')
+      .add_worksheet
+      .set_column('A', 'A', width: 12)
+      .write_number('A1', 1234.5, :format1)
+      .write_number('A2', 1234.5, :format2)
+  end
+
+  test 'format51' do |wb|
+    wb.add_format(:numf1, num_format: '0.0')
+      .add_format(:numf3, num_format: '0.000')
+      .add_format(:numf4, num_format: '0.0000')
+      .add_format(:numf5, num_format: '0.00000')
+      .add_worksheet
+      .set_column(0, 0, width: 12)
+      .write_number(0, 0, 123.456, :numf1)
+      .write_number(1, 0, 123.456, :numf3)
+      .write_number(2, 0, 123.456, :numf4)
+      .write_number(3, 0, 123.456, :numf5)
+  end
+
+  test 'format52' do |wb|
+    wb.add_format(:numf1, num_format: '0.0')
+      .add_format(:numf3, num_format: '0.000')
+      .add_format(:numf4, num_format: '0.0000')
+      .add_format(:numf5, num_format: '0.00000')
+      .add_format(:numf1_bold, num_format: '0.0', bold: true)
+      .add_format(:numf3_bold, num_format: '0.000', bold: true)
+      .add_format(:numf4_bold, num_format: '0.0000', bold: true)
+      .add_format(:numf5_bold, num_format: '0.00000', bold: true)
+      .add_worksheet
+      .set_column(0, 0, width: 12)
+      .write_number(0, 0, 123.456, :numf1)
+      .write_number(1, 0, 123.456, :numf3)
+      .write_number(2, 0, 123.456, :numf4)
+      .write_number(3, 0, 123.456, :numf5)
+      .write_number(4, 0, 123.456, :numf1_bold)
+      .write_number(5, 0, 123.456, :numf3_bold)
+      .write_number(6, 0, 123.456, :numf4_bold)
+      .write_number(7, 0, 123.456, :numf5_bold)
+  end
 end

data/test/test-image.rb

@@ -83,4 +83,32 @@ class TestImage < XlsxWriterTestCase
   test 'image29' do |wb|
     wb.add_worksheet.insert_image(0, 10, image_path('red_208.png'), x_offset: -210, y_offset: 1)
   end
+
+  test 'image36' do |wb|
+    wb.add_worksheet.insert_image('E9', image_path('happy.jpg'))
+  end
+
+  test 'image44' do |wb|
+    wb.add_worksheet
+      .insert_image('E9', image_path('red.png'))
+      .set_row(8, height: 30)
+  end
+
+  test 'image45' do |wb|
+    wb.add_worksheet
+      .insert_image('E9', image_path('red.png'))
+      .set_row(8, height: 30, hide: true)
+  end
+
+  test 'image46' do |wb|
+    wb.add_worksheet
+      .insert_image('E9', image_path('red.png'), x_offset: 0, y_offset: 4)
+      .set_row(8, height: 30, hide: true)
+  end
+
+  test 'image47' do |wb|
+    wb.add_worksheet
+      .insert_image('E9', image_path('red.png'))
+      .set_row(9, hide: true)
+  end
 end

data/test/test-misc.rb

@@ -21,6 +21,15 @@ class TestMisc < XlsxWriterTestCase
     wb.add_worksheet
   end
 
+  test 'shared_strings01' do |wb|
+    ws = wb.add_worksheet
+    ws.write_string(0, 0, '_x0000_')
+    (1...127).each_with_object(String.new("")) do |i, s|
+      s[0] = i.chr
+      ws.write_string(i, 0, s) unless i == 34
+    end
+  end
+
   test 'gh42_01' do |wb|
     wb.add_worksheet.write_string(0, 0, "\xe5\x9b\xbe\x14\xe5\x9b\xbe", nil)
   end

data/test/test-optimize.rb

@@ -31,4 +31,38 @@ class TestOptimize < XlsxWriterTestCase
       .write_string(4, 'E', 'Foo ', nil)
       .write_string(6, 'A', "\tFoo\t", nil)
   end
+
+  test('optimize22', constant_memory: true) do |wb|
+    wb
+      .add_format(:bold, bold: true)
+      .add_worksheet
+      .set_column(0, 0, width: 36, format: :bold)
+  end
+
+  test('optimize23', constant_memory: true) do |wb|
+    wb
+      .add_format(:bold, bold: true)
+      .add_worksheet
+      .set_row(0, height: 20, format: :bold)
+  end
+
+  test('optimize24', constant_memory: true) do |wb|
+    wb
+      .add_format(:bold, bold: true)
+      .add_worksheet
+      .set_row(0, height: 20, format: :bold)
+      .write_string(0, 0, 'Foo')
+  end
+
+  test('optimize25', constant_memory: true) do |wb|
+    wb
+      .add_format(:bold, bold: true)
+      .add_worksheet
+      .set_row(0, height: 20, format: :bold)
+      .write_string(2, 0, 'Foo')
+  end
+
+  test('optimize26', constant_memory: true) do |wb|
+    wb.add_worksheet.write_string(2, 2, 'café')
+  end
 end

data/test/test-outline.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+require_relative './xlsx-func-testcase'
+
+class TestOutline < XlsxWriterTestCase
+  test 'outline01' do |wb, t|
+    t.ignore_files << 'xl/calcChain.xml' << '[Content_Types].xml' << 'xl/_rels/workbook.xml.rels'
+
+    wb.add_format(:bold, bold: true)
+    ws = wb.add_worksheet 'Outlined Rows'
+    ws.set_column('A', 'A', width: 20)
+    (1..10).each do |i|
+      ws.set_row i, level: (i % 5 == 0 ? 1 : 2)
+    end
+
+    write_common_data(ws)
+  end
+
+  test 'outline02' do |wb, t|
+    t.ignore_files << 'xl/calcChain.xml' << '[Content_Types].xml' << 'xl/_rels/workbook.xml.rels'
+
+    wb.add_format(:bold, bold: true)
+    ws = wb.add_worksheet 'Collapsed Rows'
+    (1..10).each do |i|
+      ws.set_row i, level: (i % 5 == 0 ? 1 : 2), hide: true
+    end
+    ws.set_row 11, collapse: true
+
+    ws.set_column('A', 'A', width: 20)
+    ws.set_selection('A14:A14')
+
+    write_common_data(ws)
+  end
+
+  test 'outline03' do |wb, t|
+    t.ignore_files << 'xl/calcChain.xml' << '[Content_Types].xml' << 'xl/_rels/workbook.xml.rels'
+
+    wb.add_format(:bold, bold: true)
+    ws = wb.add_worksheet 'Outline Columns'
+
+    %w(Month Jan Feb Mar Apr May Jun Total).each_with_index { |s, i| ws.write_string 0, i, s }
+    [
+      ['North', [50, 20, 15, 25, 65, 80]],
+      ['South', [10, 20, 30, 50, 50, 50]],
+      ['East',  [45, 75, 50, 15, 75, 100]],
+      ['West',  [15, 15, 55, 35, 20, 50]],
+    ].each_with_index do |(d, vals), i|
+      ws.write_string(i+1, 0, d)
+      vals.each_with_index { |v, j| ws.write_number(i+1, j+1, v) }
+      ws.write_formula_num(i+1, vals.size + 1, "=SUM(B#{i+2}:G#{i+2})", vals.reduce(:+))
+    end
+    ws.write_formula_num('H6', "=SUM(H2:H5)", 1015, :bold)
+    ws.set_row 0, format: :bold
+    ws.set_column 'A', 'A', width: 10, format: :bold
+    ws.set_column 'H', 'H', width: 10
+    ws.set_column 'B', 'G', width: 6, level: 1
+  end
+
+  test 'outline04' do |wb, t|
+    t.ignore_files << 'xl/calcChain.xml' << '[Content_Types].xml' << 'xl/_rels/workbook.xml.rels'
+
+    ws = wb.add_worksheet 'Outline levels'
+    13.times { |i| ws.write_string i, 0, "Level #{(i > 6 ? 13 - i : i + 1)}" }
+    13.times { |i| ws.set_row i, level: (i > 6 ? 13 - i : i + 1) }
+  end
+
+  test 'outline05' do |wb, t|
+    t.ignore_files << 'xl/calcChain.xml' << '[Content_Types].xml' << 'xl/_rels/workbook.xml.rels'
+
+    wb.add_format(:bold, bold: true)
+    ws = wb.add_worksheet 'Collapsed Rows'
+    ws.set_column('A', 'A', width: 20)
+    ws.set_selection 'A14:A14'
+    (1..10).each do |i|
+      ws.set_row i, level: (i % 5 == 0 ? 1 : 2), hide: true, collapse: (i % 5 == 0)
+    end
+    ws.set_row 11, collapse: true
+
+    write_common_data(ws)
+  end
+
+  test 'outline06' do |wb, t|
+    t.ignore_files << 'xl/calcChain.xml' << '[Content_Types].xml' << 'xl/_rels/workbook.xml.rels'
+
+    wb.add_format(:bold, bold: true)
+    ws = wb.add_worksheet 'Outlined Rows'
+    ws.outline_settings = { visible: false, symbols_below: false, symbols_right: false, auto_style: true }
+    ws.set_column('A', 'A', width: 20)
+    (1..10).each do |i|
+      ws.set_row i, level: (i % 5 == 0 ? 1 : 2)
+    end
+
+    write_common_data(ws)
+  end
+
+  private
+
+  def write_common_data(ws)
+    ws
+      .write_string('A1', 'Region', :bold)
+      .write_string('A2', 'North')
+      .write_string('A3', 'North')
+      .write_string('A4', 'North')
+      .write_string('A5', 'North')
+      .write_string('A6', 'North Total', :bold)
+      .write_string('B1', 'Sales', :bold)
+      .write_number('B2', 1000)
+      .write_number('B3', 1200)
+      .write_number('B4', 900)
+      .write_number('B5', 1200)
+      .write_formula_num('B6', '=SUBTOTAL(9,B2:B5)', 4300, :bold)
+      .write_string('A7', 'South')
+      .write_string('A8', 'South')
+      .write_string('A9', 'South')
+      .write_string('A10', 'South')
+      .write_string('A11', 'South Total', :bold)
+      .write_number('B7', 400)
+      .write_number('B8', 600)
+      .write_number('B9', 500)
+      .write_number('B10', 600)
+      .write_formula_num('B11', '=SUBTOTAL(9,B7:B10)', 2100, :bold)
+      .write_string('A12', 'Grand Total', :bold)
+      .write_formula_num('B12', '=SUBTOTAL(9,B2:B10)', 6400, :bold)
+  end
+end

data/test/xlsx-func-testcase.rb

@@ -17,12 +17,13 @@ class XlsxWriterTestCase < Test::Unit::TestCase
   def self.test(name, opts=nil, &block)
     define_method(:"test_#{name}") do
       file_path = "tmp/#{name}.xlsx"
-      ref_file_path = "ext/xlsxwriter/libxlsxwriter/test/functional/xlsx_files/#{name}.xlsx"
+      ref_name = opts && opts.delete(:ref_file_name) || name
+      ref_file_path = "ext/xlsxwriter/libxlsxwriter/test/functional/xlsx_files/#{ref_name}.xlsx"
       begin
         tc = XlsxWriterTestCaseConfig.new
         args = [file_path, opts].compact
         XlsxWriter::Workbook.open(*args) do |wb|
-          yield wb, tc
+          instance_exec(wb, tc, &block)
         end
 
         assert_xlsx_equal file_path, ref_file_path, tc.ignore_files, tc.ignore_elements
@@ -32,7 +33,7 @@ class XlsxWriterTestCase < Test::Unit::TestCase
     end
   end
 
-  def self.image_path(path)
+  def image_path(path)
     File.expand_path(File.join('../../ext/xlsxwriter/libxlsxwriter/test/functional/src/images', path), __FILE__)
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: xlsxwriter
 version: !ruby/object:Gem::Version
-  version: 0.1.2.pre
+  version: 0.2.0.pre
 platform: ruby
 authors:
 - Nick H
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-04-15 00:00:00.000000000 Z
+date: 2019-04-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake-compiler
@@ -136,6 +136,7 @@ files:
 - ext/xlsxwriter/worksheet.c
 - ext/xlsxwriter/worksheet.h
 - ext/xlsxwriter/xlsxwriter.c
+- ext/xlsxwriter/xlsxwriter_ext.h
 - lib/xlsxwriter.rb
 - lib/xlsxwriter/version.rb
 - lib/xlsxwriter/worksheet.rb
@@ -152,6 +153,7 @@ files:
 - test/test-chart-scatter.rb
 - test/test-chart-size.rb
 - test/test-chart-title.rb
+- test/test-data-validation.rb
 - test/test-data.rb
 - test/test-default-row.rb
 - test/test-defined-name.rb
@@ -165,6 +167,7 @@ files:
 - test/test-merge-range.rb
 - test/test-misc.rb
 - test/test-optimize.rb
+- test/test-outline.rb
 - test/test-page-breaks.rb
 - test/test-page-setup.rb
 - test/test-panes.rb
@@ -234,6 +237,7 @@ test_files:
 - test/test-chart-size.rb
 - test/test-hyperlink.rb
 - test/test-array-formula.rb
+- test/test-outline.rb
 - test/test-print-options.rb
 - test/test-optimize.rb
 - test/test-print-scale.rb
@@ -244,4 +248,5 @@ test_files:
 - test/test-chart-title.rb
 - test/test-fit-to-pages.rb
 - test/test-properties.rb
+- test/test-data-validation.rb
 - test/test-data.rb