xlsxwriter 0.2.0.pre → 0.2.0.pre.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 408b3a45c34215b79898280c419cf2adafbde2bf0a4037f11a0432972c7861cf
-  data.tar.gz: d162bd3b0043aa39114baa98a28665fe8931c22e8252f5a0e9040c2a10c62319
+  metadata.gz: 851dae6d52bb43129e9a28421a8f9bdffcce9fffe682106f53d6adbed52d2d81
+  data.tar.gz: a7587dbc467434582ad1a89dcaa31d6070d71703551f1b70f2b0ff94a830c152
 SHA512:
-  metadata.gz: 566117022982bb38edc6b2048567a10a5174fae628fa6b47c85324d721ea4e4448360d82c9b8656af85bd0b28639ef9efc3a0c1d625f8b4d1a1dc19c141ac306
-  data.tar.gz: 54c7504e4bcafd1f982a45dbf98ebec925c9880ae8797022920c24c00af5926e51d55ca70d822a1298aa4a3fa13390c4030d17fbe14b7754f3e6aee6a252448d
+  metadata.gz: 6a30288f6cdef1492a37cfdb8e0627b47e9be3bdcece23fb43713e098894979c0549fc05e22f796f5cc3913f9849b82dae1bc64417bfbcefe6936c47bbf3808b
+  data.tar.gz: eb3a75578949b0d1a2f606686886fd1718abf6791ce9853a04e41fb126d1326dc95517d4bfd23667ca09c1f990e23f6fd57ffd69a5f3168c154ea71d9bc41e74

data/Rakefile

@@ -7,7 +7,7 @@ spec = Gem::Specification.load('xlsxwriter.gemspec')
 Rake::ExtensionTask.new('xlsxwriter', spec) do |ext|
   ext.lib_dir = 'lib/xlsxwriter'
 end
-task compile: :patch_dep
+Rake::Task['compile'].prerequisites.unshift :patch_dep
 
 Gem::PackageTask.new(spec) do |pkg|
 end

data/ext/xlsxwriter/chart.h

@@ -1,5 +1,5 @@
 #include <ruby.h>
-#include "xlsxwriter.h"
+#include <xlsxwriter.h>
 
 #ifndef __CHART__
 #define __CHART__

data/ext/xlsxwriter/format.h

@@ -1,5 +1,5 @@
 #include <ruby.h>
-#include "xlsxwriter.h"
+#include <xlsxwriter.h>
 
 #ifndef __FORMAT__
 #define __FORMAT__

data/ext/xlsxwriter/rich_string.c

@@ -0,0 +1,85 @@
+#include <ruby/util.h>
+#include "rich_string.h"
+#include "workbook.h"
+#include "xlsxwriter_ext.h"
+
+VALUE cRichString;
+
+void rich_string_free(void *p);
+
+
+VALUE
+rich_string_alloc(VALUE klass) {
+  VALUE obj;
+  lxw_rich_string_tuple **ptr;
+
+  obj = Data_Make_Struct(klass, lxw_rich_string_tuple *, NULL, rich_string_free, ptr);
+  *ptr = NULL;
+
+  return obj;
+}
+
+void
+rich_string_free(void *p) {
+  lxw_rich_string_tuple **ptr = p;
+  if (*ptr) {
+    ruby_xfree(*ptr);
+    *ptr = NULL;
+  }
+}
+
+VALUE
+rich_string_cached_p(VALUE self) {
+  lxw_rich_string_tuple **ptr;
+  Data_Get_Struct(self, lxw_rich_string_tuple *, ptr);
+
+  if (*ptr) {
+    return Qtrue;
+  } else {
+    return Qfalse;
+  }
+}
+
+lxw_rich_string_tuple **
+serialize_rich_string(VALUE rs) {
+  VALUE arr = rb_funcall(rs, rb_intern("parts"), 0);
+  VALUE wb = rb_funcall(rs, rb_intern("workbook"), 0);
+
+  int len = RARRAY_LEN(arr);
+
+  lxw_rich_string_tuple **ptr;
+  Data_Get_Struct(rs, lxw_rich_string_tuple *, ptr);
+
+  if (*ptr) { // cached
+    return (lxw_rich_string_tuple **) *ptr;
+  }
+
+  rb_obj_freeze(arr);
+  *ptr = ruby_xmalloc(sizeof(lxw_rich_string_tuple) * len + sizeof(lxw_rich_string_tuple *) * (len + 1));
+  lxw_rich_string_tuple **res = *(lxw_rich_string_tuple ***)ptr;
+
+  lxw_rich_string_tuple *base_ptr = ((void *)*ptr + sizeof(lxw_rich_string_tuple *) * (len + 1));
+  for (int i = 0; i < len; ++i) {
+    VALUE part = rb_ary_entry(arr, i);
+    VALUE text = rb_ary_entry(part, 0);
+    VALUE format = rb_ary_entry(part, 1);
+
+    base_ptr[i].format = workbook_get_format(wb, format);
+    base_ptr[i].string = StringValueCStr(text);
+    res[i] = &base_ptr[i];
+  }
+  res[len] = NULL;
+
+  return res;
+}
+
+
+void init_xlsxwriter_rich_string() {
+#if 0
+  // Making RDoc happy.
+  mXlsxWriter = rb_define_module("XlsxWriter");
+#endif
+  cRichString = rb_define_class_under(mXlsxWriter, "RichString", rb_cObject);
+  rb_define_alloc_func(cRichString, rich_string_alloc);
+  rb_define_private_method(cRichString, "cached?", rich_string_cached_p, 0);
+}

data/ext/xlsxwriter/rich_string.h

@@ -0,0 +1,12 @@
+#include <ruby.h>
+#include <xlsxwriter.h>
+
+#ifndef __RICH_STRING__
+#define __RICH_STRING__
+
+void init_xlsxwriter_rich_string();
+lxw_rich_string_tuple **serialize_rich_string(VALUE rs);
+
+extern VALUE cRichString;
+
+#endif /* RICH_STRING_H */

data/ext/xlsxwriter/workbook.c

@@ -1,7 +1,7 @@
 #include <string.h>
 #include <ruby.h>
 #include <ruby/thread.h>
-#include "xlsxwriter.h"
+#include <xlsxwriter.h>
 #include "chart.h"
 #include "format.h"
 #include "workbook.h"
@@ -353,25 +353,19 @@ value_to_lxw_datetime(VALUE val) {
     val = rb_funcall(val, i_to_time, 0);
   }
   VALUE time_a = rb_funcall(val, rb_intern("to_a"), 0);
-  static const VALUE idxs[6] = { INT2FIX(0), INT2FIX(1), INT2FIX(2), INT2FIX(3), INT2FIX(4), INT2FIX(5) };
   lxw_datetime res = {
-    .year  = NUM2INT(rb_ary_aref(1, idxs+5, time_a)),
-    .month = NUM2INT(rb_ary_aref(1, idxs+4, time_a)),
-    .day   = NUM2INT(rb_ary_aref(1, idxs+3, time_a)),
-    .hour  = NUM2INT(rb_ary_aref(1, idxs+2, time_a)),
-    .min   = NUM2INT(rb_ary_aref(1, idxs+1, time_a)),
-    .sec   = NUM2DBL(rb_ary_aref(1, idxs+0, time_a)) +
+    .year  = NUM2INT(rb_ary_entry(time_a, 5)),
+    .month = NUM2INT(rb_ary_entry(time_a, 4)),
+    .day   = NUM2INT(rb_ary_entry(time_a, 3)),
+    .hour  = NUM2INT(rb_ary_entry(time_a, 2)),
+    .min   = NUM2INT(rb_ary_entry(time_a, 1)),
+    .sec   = NUM2DBL(rb_ary_entry(time_a, 0)) +
              NUM2DBL(rb_funcall(val, rb_intern("subsec"), 0))
   };
 
   return res;
 }
 
-void
-handle_lxw_error(lxw_error err) {
-  return;
-}
-
 
 /*  Document-class: XlsxWriter::Workbook
  *

data/ext/xlsxwriter/workbook.h

@@ -12,7 +12,6 @@ struct workbook {
 
 lxw_format *workbook_get_format(VALUE self, VALUE key);
 lxw_datetime value_to_lxw_datetime(VALUE val);
-void handle_lxw_error(lxw_error err);
 
 void init_xlsxwriter_workbook();
 

data/ext/xlsxwriter/workbook_properties.c

@@ -1,6 +1,6 @@
 #include <string.h>
 #include <ruby/util.h>
-#include "xlsxwriter.h"
+#include <xlsxwriter.h>
 #include "workbook.h"
 #include "workbook_properties.h"
 

data/ext/xlsxwriter/worksheet.c

@@ -1,4 +1,5 @@
 #include "chart.h"
+#include "rich_string.h"
 #include "worksheet.h"
 #include "workbook.h"
 #include "xlsxwriter_ext.h"
@@ -69,7 +70,7 @@ worksheet_init(int argc, VALUE *argv, VALUE self) {
   Data_Get_Struct(argv[0], struct workbook, wb_ptr);
   ptr->worksheet = workbook_add_worksheet(wb_ptr->workbook, name);
   if (!ptr->worksheet)
-    rb_raise(rb_eRuntimeError, "worksheet was not created");
+    rb_raise(eXlsxWriterError, "worksheet was not created");
   return self;
 }
 
@@ -401,7 +402,8 @@ worksheet_write_blank_(int argc, VALUE *argv, VALUE self) {
  *
  *  Writes a +formula+ with +value+ into a +cell+ with +format+.
  */
-VALUE worksheet_write_formula_num_(int argc, VALUE *argv, VALUE self) {
+VALUE
+worksheet_write_formula_num_(int argc, VALUE *argv, VALUE self) {
   lxw_row_t row;
   lxw_col_t col;
   VALUE formula = Qnil;
@@ -435,6 +437,53 @@ VALUE worksheet_write_formula_num_(int argc, VALUE *argv, VALUE self) {
   return self;
 }
 
+/*  call-seq:
+ *     ws.write_rich_string(cell, value) -> self
+ *     ws.write_rich_string(row, col, value) -> self
+ *
+ *  Writes a +rich_string+ value into a +cell+.
+ */
+VALUE
+worksheet_write_rich_string_(int argc, VALUE *argv, VALUE self) {
+  lxw_row_t row;
+  lxw_col_t col;
+  VALUE value = Qnil;
+  VALUE format_key = Qnil;
+
+  rb_check_arity(argc, 2, 4);
+  int larg = extract_cell(argc, argv, &row, &col);
+  VALUE workbook = rb_iv_get(self, "@workbook");
+
+  if (larg < argc) {
+    value = argv[larg];
+    if (TYPE(value) == T_ARRAY)
+      value = rb_funcall(cRichString, rb_intern("new"), 2, workbook, value);
+    else if (rb_class_of(value) != cRichString) {
+      rb_raise(rb_eArgError, "Wrong type of value: %"PRIsVALUE, rb_class_of(value));
+    }
+    ++larg;
+  }
+
+  if (larg < argc) {
+    format_key = argv[larg];
+    ++larg;
+  }
+
+  if (NIL_P(value)) {
+    rb_raise(rb_eArgError, "No value specified");
+  }
+
+  struct worksheet *ptr;
+  lxw_format *format = workbook_get_format(workbook, format_key);
+  lxw_rich_string_tuple **rich_string = serialize_rich_string(value);
+  if (rich_string) {
+    Data_Get_Struct(self, struct worksheet, ptr);
+    lxw_error err = worksheet_write_rich_string(ptr->worksheet, row, col, rich_string, format);
+    handle_lxw_error(err);
+  }
+  return self;
+}
+
 /*  call-seq: ws.set_row(row, height: nil, format: nil, hide: false) -> self
  *
  *  Set properties of the row.
@@ -693,7 +742,8 @@ worksheet_autofilter_(int argc, VALUE *argv, VALUE self) {
  *
  *  Set the worksheet to be active on opening the workbook.
  */
-VALUE worksheet_activate_(VALUE self) {
+VALUE
+worksheet_activate_(VALUE self) {
   struct worksheet *ptr;
   Data_Get_Struct(self, struct worksheet, ptr);
   worksheet_activate(ptr->worksheet);
@@ -704,7 +754,8 @@ VALUE worksheet_activate_(VALUE self) {
  *
  *  Set the worksheet to be selected on openong the workbook.
  */
-VALUE worksheet_select_(VALUE self) {
+VALUE
+worksheet_select_(VALUE self) {
   struct worksheet *ptr;
   Data_Get_Struct(self, struct worksheet, ptr);
   worksheet_select(ptr->worksheet);
@@ -1426,7 +1477,7 @@ worksheet_data_validation_(int argc, VALUE *argv, VALUE self) {
     free(data_validation.value_list);
   }
 
-  handle_xlsxwriter_error(err);
+  handle_lxw_error(err);
 
   return self;
 }
@@ -1444,6 +1495,11 @@ value_to_col(VALUE value) {
   }
 }
 
+VALUE
+rb_extract_col(VALUE _self, VALUE col) {
+  return INT2FIX(value_to_col(col));
+}
+
 int
 extract_cell(int argc, VALUE *argv, lxw_row_t *row, lxw_col_t *col) {
   char *str;
@@ -1563,6 +1619,7 @@ init_xlsxwriter_worksheet() {
   rb_define_method(cWorksheet, "write_boolean", worksheet_write_boolean_, -1);
   rb_define_method(cWorksheet, "write_blank", worksheet_write_blank_, -1);
   rb_define_method(cWorksheet, "write_formula_num", worksheet_write_formula_num_, -1);
+  rb_define_method(cWorksheet, "write_rich_string", worksheet_write_rich_string_, -1);
   rb_define_method(cWorksheet, "set_row", worksheet_set_row_, 2);
   rb_define_method(cWorksheet, "set_column", worksheet_set_column_, 3);
   rb_define_method(cWorksheet, "insert_image", worksheet_insert_image_, -1);
@@ -1608,6 +1665,7 @@ init_xlsxwriter_worksheet() {
   rb_define_method(cWorksheet, "vertical_dpi=", worksheet_set_vertical_dpi_, 1);
 
   rb_define_method(cWorksheet, "add_data_validation", worksheet_data_validation_, -1);
+  rb_define_private_method(cWorksheet, "extract_column", rb_extract_col, 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)

data/ext/xlsxwriter/worksheet.h

@@ -1,5 +1,5 @@
 #include <ruby.h>
-#include "xlsxwriter.h"
+#include <xlsxwriter.h>
 
 #ifndef __WORKSHEET__
 #define __WORKSHEET__

data/ext/xlsxwriter/xlsxwriter.c

@@ -1,7 +1,8 @@
 #include <ruby.h>
-#include "xlsxwriter.h"
+#include <xlsxwriter.h>
 #include "chart.h"
 #include "format.h"
+#include "rich_string.h"
 #include "workbook.h"
 #include "workbook_properties.h"
 #include "worksheet.h"
@@ -33,11 +34,12 @@ 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);
+  eXlsxWriterError = rb_const_get(mXlsxWriter, rb_intern("Error"));
 
   init_xlsxwriter_workbook();
   init_xlsxwriter_workbook_properties();
   init_xlsxwriter_format();
   init_xlsxwriter_worksheet();
   init_xlsxwriter_chart();
+  init_xlsxwriter_rich_string();
 }

data/ext/xlsxwriter/xlsxwriter_ext.h

@@ -6,9 +6,9 @@
 extern VALUE mXlsxWriter;
 extern VALUE eXlsxWriterError;
 
-inline void handle_xlsxwriter_error(lxw_error err) {
+inline void handle_lxw_error(lxw_error err) {
   if (err) {
-    rb_raise(eXlsxWriterError, lxw_strerror(err));
+    rb_exc_raise(rb_funcall(eXlsxWriterError, rb_intern("new"), 2, rb_str_new_cstr(lxw_strerror(err)), INT2NUM(err)));
   }
 }
 

data/lib/xlsxwriter.rb

@@ -4,5 +4,7 @@ module XlsxWriter
 end
 
 require 'xlsxwriter/version'
-require 'xlsxwriter/xlsxwriter'
+require 'xlsxwriter/error'
+require 'xlsxwriter/rich_string'
 require 'xlsxwriter/worksheet'
+require 'xlsxwriter/xlsxwriter'

data/lib/xlsxwriter/error.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module XlsxWriter
+  ##
+  # An error returned from libxlsxwriter. Numeric code is accessible via #code
+  class Error < StandardError
+    # Error code
+    attr_reader :code
+
+    def initialize(msg, code = nil)
+      super(msg)
+      @code = code
+    end
+
+    def inspect
+      "#<#{self.class}: #{self}#{" (code: #{code})" if code}>"
+    end
+  end
+end

data/lib/xlsxwriter/rich_string.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module XlsxWriter
+  ##
+  # RichString is a multipart string consting of sub-strings with format
+  class RichString
+    attr_reader :workbook, :parts
+
+    ##
+    # call-seq:
+    #   RichString.new(workbook, parts)
+    #   RichString.new(workbook)
+    #
+    # Creates rich string that could be written to the +workbook+.
+    # +parts+ is an array of pairs string + format. If no format is needed
+    # for the part single string can be specified instead.
+    # For example: +['This is ', ['bold', :bold], [' and this is'], ['italic', :italic]]+
+    #
+    # If parts is not specified it could be populated later with #add_part.
+    #
+    # Please note that on writing additional validations are applied (e.g. string should not be empty).
+    # Please consult libxlsxwriter documentation for additional details.
+    def initialize(workbook, parts = [])
+      @workbook = workbook
+      @parts = parts.map! do |(str, format)|
+        make_part(str, format)
+      end
+    end
+
+    ##
+    # call-seq:
+    #   rs.add_part(str)
+    #   rs.add_part(str, format)
+    #
+    # Adds part (string +str+ formatted with +format+) to the RichString +rs+.
+    #
+    # Please note, that no parts can be added to a rich string that has already been written once.
+    def add_part(str, format = nil)
+      raise Error, 'Cannot modify as the RichString has already been written to a workbook.' if cached?
+
+      parts << make_part(str, format)
+
+      self
+    end
+
+    def <<(part)
+      add_part(*Array(part))
+    end
+
+    def inspect
+      "#<#{self.class}:#{to_s.inspect}, @cached=#{@cached}>"
+    end
+
+    def to_s
+      parts.map(&:first)
+    end
+
+
+    private
+
+
+    def make_part(str, format)
+      [
+        str.frozen? ? str.to_str : str.to_str.clone.freeze,
+        (format.to_sym if format)
+      ].freeze
+    end
+  end
+end

data/lib/xlsxwriter/version.rb

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

data/lib/xlsxwriter/worksheet.rb

@@ -1,96 +1,107 @@
 # frozen_string_literal: true
 
-class XlsxWriter::Worksheet
-  # Last row number written with #add_row
-  attr_reader :current_row
+module XlsxWriter
 
-  # Thiner characters list used for column width logic mimicking axlsx behaviour
-  THIN_CHARS = '^.acfijklrstxzFIJL()-'.freeze
+  class Worksheet
+    # Last row number written with #add_row
+    attr_reader :current_row, :col_auto_widths
 
-  # Write a +row+. If no +types+ passed XlsxWriter tries to deduce them automatically.
-  #
-  # Both +types+ and +style+ may be an array as well as a symbol.
-  # In the latter case they are applied to all cells in the +row+.
-  #
-  # +height+ is a Numeric that specifies the row height.
-  #
-  # If +skip_empty+ is set to +true+ empty cells are not added to the sheet.
-  # Otherwise they are added with type +:blank+.
-  def add_row(row, style: nil, height: nil, types: nil, skip_empty: false)
-    row_idx = @current_row ||= 0
-    @current_row += 1
+    # Thiner characters list used for column width logic mimicking axlsx behaviour
+    THIN_CHARS = '^.acfijklrstxzFIJL()-'.freeze
 
-    style_ary = style if style.is_a?(Array)
-    types_ary = types if types.is_a?(Array)
+    # Write a +row+. If no +types+ passed XlsxWriter tries to deduce them automatically.
+    #
+    # Both +types+ and +style+ may be an array as well as a symbol.
+    # In the latter case they are applied to all cells in the +row+.
+    #
+    # +height+ is a Numeric that specifies the row height.
+    #
+    # If +skip_empty+ is set to +true+ empty cells are not added to the sheet.
+    # Otherwise they are added with type +:blank+.
+    def add_row(row, style: nil, height: nil, types: nil, skip_empty: false)
+      row_idx = @current_row ||= 0
+      @current_row += 1
 
-    row.each_with_index do |value, idx|
-      cell_style = style_ary ? style_ary[idx] : style
-      cell_type  = types_ary ? types_ary[idx] : types
+      style_ary = style if style.is_a?(Array)
+      types_ary = types if types.is_a?(Array)
 
-      case cell_type && cell_type.to_sym
-      when :string
-        value = value.to_s
-        write_string(row_idx, idx, value, cell_style)
-        update_col_auto_width(idx, value, cell_style)
-      when :number
-        write_number(row_idx, idx, value.to_f, cell_style)
-      when :formula
-        write_formula(row_idx, idx, value, cell_style)
-      when :datetime, :date, :time
-        write_datetime(row_idx, idx, value.to_time, cell_style)
-      when :url
-        write_url(row_idx, idx, value, cell_style)
-        update_col_auto_width(idx, value.to_s, cell_style)
-      when :boolean
-        write_boolean(row_idx, idx, value, cell_style)
-      when :blank
-        write_blank(row_idx, idx, cell_style)
-      when :skip, :empty
-        # write nothing
-      when nil
-        case value
-        when Numeric
-          write_number(row_idx, idx, value, cell_style)
-        when TrueClass, FalseClass
-          write_boolean(row_idx, idx, value, cell_style)
-        when Time, (defined?(Date) ? Date : Time)
-          write_datetime(row_idx, idx, value, cell_style)
-        when '', nil
-          write_blank(row_idx, idx, cell_style) unless skip_empty
-        when /\A=/
-          write_formula(row_idx, idx, value, cell_style)
-        when String
-          write_string(row_idx, idx, value, cell_style)
-          update_col_auto_width(idx, value, cell_style)
-        else # assume string
+      row.each_with_index do |value, idx|
+        cell_style = style_ary ? style_ary[idx] : style
+        cell_type  = types_ary ? types_ary[idx] : types
+
+        case cell_type && cell_type.to_sym
+        when :string
           value = value.to_s
           write_string(row_idx, idx, value, cell_style)
           update_col_auto_width(idx, value, cell_style)
+        when :rich_string
+          write_rich_string(row_idx, idx, value, cell_style)
+        when :number
+          write_number(row_idx, idx, value.to_f, cell_style)
+        when :formula
+          write_formula(row_idx, idx, value, cell_style)
+        when :datetime, :date, :time
+          write_datetime(row_idx, idx, value.to_time, cell_style)
+        when :url
+          write_url(row_idx, idx, value, cell_style)
+          update_col_auto_width(idx, value.to_s, cell_style)
+        when :boolean
+          write_boolean(row_idx, idx, value, cell_style)
+        when :blank
+          write_blank(row_idx, idx, cell_style)
+        when :skip, :empty
+          # write nothing
+        when nil
+          case value
+          when Numeric
+            write_number(row_idx, idx, value, cell_style)
+          when TrueClass, FalseClass
+            write_boolean(row_idx, idx, value, cell_style)
+          when Time, (defined?(Date) ? Date : Time)
+            write_datetime(row_idx, idx, value, cell_style)
+          when '', nil
+            write_blank(row_idx, idx, cell_style) unless skip_empty
+          when /\A=/
+            write_formula(row_idx, idx, value, cell_style)
+          when String
+            write_string(row_idx, idx, value, cell_style)
+            update_col_auto_width(idx, value, cell_style)
+          when RichString
+            write_rich_string(row_idx, idx, value, cell_style)
+          else # assume string
+            value = value.to_s
+            write_string(row_idx, idx, value, cell_style)
+            update_col_auto_width(idx, value, cell_style)
+          end
+        else
+          raise ArgumentError, "Unknown cell type #{cell_type}."
         end
-      else
-        raise ArgumentError, "Unknown cell type #{cell_type}."
       end
-    end
 
-    set_row(row_idx, height: height) if height
+      set_row(row_idx, height: height) if height
 
-    nil
-  end
+      nil
+    end
 
-  # Apply cols automatic widths calculated by #add_row.
-  def apply_auto_widths
-    @col_auto_widths.each_with_index do |width, idx|
-      set_column(idx, idx, width: width) if width
+    # Apply cols automatic widths calculated by #add_row.
+    def apply_auto_widths
+      @col_auto_widths.each_with_index do |width, idx|
+        set_column(idx, idx, width: width) if width
+      end
     end
-  end
 
-  private
+    def get_column_auto_width(col)
+      @col_auto_widths[extract_column(col)]
+    end
+
+    private
 
-  # Updates the col auto width value to fit the string.
-  def update_col_auto_width(idx, val, format)
-    font_scale = (@workbook.font_sizes[format] || 11) / 10.0
-    width = (val.count(THIN_CHARS) + 3) * font_scale
-    width = 255 if width > 255 # Max xlsx column width is 255 characters
-    @col_auto_widths[idx] = [@col_auto_widths[idx] || 0, width].max
+    # Updates the col auto width value to fit the string.
+    def update_col_auto_width(idx, val, format)
+      font_scale = (@workbook.font_sizes[format] || 11) / 10.0
+      width = (val.count(THIN_CHARS) + 3) * font_scale
+      width = 255 if width > 255 # Max xlsx column width is 255 characters
+      @col_auto_widths[idx] = [@col_auto_widths[idx] || 0, width].max
+    end
   end
 end

data/test/support/with_xlsx_file.rb

@@ -0,0 +1,13 @@
+require 'xlsxwriter'
+
+module WithXlsxFile
+  def with_xlsx_file(file_path = 'tmp/test.xlsx', **opts)
+    after = opts.delete :after
+    XlsxWriter::Workbook.open(file_path, opts) do |wb|
+      yield wb
+    end
+    after.call if after
+  ensure
+    File.delete file_path if File.exist? file_path
+  end
+end

data/test/support/xlsx_comparable.rb

@@ -4,15 +4,16 @@ require 'test/unit'
 require 'zip'
 
 module XlsxComparable
-  def assert_xlsx_equal(got_path, exp_path, ignore_files=[], ignore_elements={})
+  def assert_xlsx_equal(got_path, exp_path, ignore_files = [], ignore_elements = {})
     Zip::File.open(exp_path) do |exp_zip|
       Zip::File.open(got_path) do |got_zip|
-        exp_files = exp_zip.glob('**/*').select { |e| !ignore_files.include?(e.name) }
-        got_files = got_zip.glob('**/*').select { |e| !ignore_files.include?(e.name) }
+        exp_files = exp_zip.glob('**/*').reject { |e| ignore_files.include?(e.name) }
+        got_files = got_zip.glob('**/*').reject { |e| ignore_files.include?(e.name) }
         assert_equal(got_files.map(&:name).sort, exp_files.map(&:name).sort)
 
         exp_files.each do |exp_entry|
           next unless exp_entry.file?
+
           exp_xml_str = exp_zip.read(exp_entry.name)
           got_xml_str = got_zip.read(exp_entry.name)
 
@@ -32,20 +33,20 @@ module XlsxComparable
             exp_xml_str.gsub!(/<calcPr[^>]*>/, '<calcPr/>')
             got_xml_str.gsub!(/<workbookView[^>]*>/, '<workbookView/>')
             got_xml_str.gsub!(/<calcPr[^>]*>/, '<calcPr/>')
-          when /xl\/worksheets\/sheet\d+.xml/
+          when %r{xl/worksheets/sheet\d+.xml}
             exp_xml_str.gsub!(/horizontalDpi="200" /, '')
             exp_xml_str.gsub!(/verticalDpi="200" /, '')
             exp_xml_str.gsub!(/(<pageSetup[^>]*) r:id="rId1"/, '\1')
-          when /xl\/charts\/chart\d+.xml/
+          when %r{xl/charts/chart\d+.xml}
             exp_xml_str.gsub!(/<c:pageMargins[^>]*>/, '<c:pageMargins/>')
             got_xml_str.gsub!(/<c:pageMargins[^>]*>/, '<c:pageMargins/>')
           end
 
+          got_xml = _xml_to_list(got_xml_str)
+
           if exp_entry.name =~ /.vml\z/
-            got_xml = _xml_to_list(got_xml_str)
             exp_xml = _vml_to_list(exp_xml_str)
           else
-            got_xml = _xml_to_list(got_xml_str)
             exp_xml = _xml_to_list(exp_xml_str)
           end
 
@@ -70,29 +71,27 @@ module XlsxComparable
 
   def _xml_to_list(xml_str)
     xml_str.strip.split(/>\s*</).each do |el|
-      el.gsub!("\r", '')
+      el.delete!("\r")
       el.insert 0, '<' unless el[0]  == '<'
       el <<        '>' unless el[-1] == '>'
     end
   end
 
   def _vml_to_list(vml_str)
-    vml_str.gsub!("\r", '')
+    vml_str.delete!("\r")
 
     vml = vml_str.split("\n")
-    vml_str = String.new.tap do |vml_str|
-      vml.each do |line|
-        line.strip!
-        next if line == ''
-        line.gsub!(?', ?")
-        line << ' ' if line =~ '"$'
-        line << "\n" if line =~ '>$'
-        line.gsub!('><', ">\n<")
-        if line == "<x:Anchor>\n"
-          line.strip!
-        end
-        wml_str << line
-      end
+    vml_str = String.new
+    vml.each do |line|
+      line.strip!
+      next if line == ''
+
+      line.tr!(?', ?")
+      line << ' ' if line =~ /"$/
+      line << "\n" if line =~ />$/
+      line.gsub!('><', ">\n<")
+      line.strip! if line == "<x:Anchor>\n"
+      wml_str << line
     end
     vml_str.rstrip.split("\n")
   end

data/test/test-data-validation.rb

@@ -1,4 +1,4 @@
-# -*- coding: utf-8 -*-
+# coding: utf-8
 # frozen_string_literal: true
 
 require_relative './xlsx-func-testcase'

data/test/test-errors.rb

@@ -1,21 +1,33 @@
 # frozen_string_literal: true
 
 require 'test/unit'
+require 'support/with_xlsx_file'
 
 class TestErrors < Test::Unit::TestCase
+  include WithXlsxFile
+
   def test_long_sheet_name
-    file_path = 'tmp/error_long_sheet_name.xlsx'
-    was_in_block = false
-    XlsxWriter::Workbook.open(file_path) do |wb|
-      assert_raise(RuntimeError.new('worksheet was not created')) do
+    with_xlsx_file('tmp/error_long_sheet_name.xlsx') do |wb|
+      was_in_block = false
+      assert_raise(XlsxWriter::Error.new('worksheet was not created')) do
         wb.add_worksheet('a' * 32) do |ws|
           was_in_block = true
           ws.add_row(['test'])
         end
       end
+      assert_equal(was_in_block, false)
+    end
+  end
+
+  def test_written_rich_string
+    with_xlsx_file('tmp/error_written_rich_string.xlsx') do |wb|
+      ws = wb.add_worksheet
+      rs = XlsxWriter::RichString.new(wb, ['1'])
+      rs << ' 2'
+      ws.add_row([rs])
+      assert_raise(XlsxWriter::Error.new('Cannot modify as the RichString has already been written to a workbook.')) do
+        rs << ' 3'
+      end
     end
-    assert_equal(was_in_block, false)
-  ensure
-    File.delete file_path if file_path && File.exist?(file_path)
   end
 end

data/test/test-escapes.rb

@@ -3,6 +3,17 @@
 require_relative './xlsx-func-testcase'
 
 class TestEscapes < XlsxWriterTestCase
+  test 'escapes03' do |wb|
+    wb
+      .add_format(:bold, bold: true)
+      .add_format(:italic, italic: true)
+      .add_worksheet
+      .write_string('A1', 'Foo', :bold)
+      .write_string('A2', 'Bar', :italic)
+      .write_rich_string('A3', [['a'], ["b\"<>'c", :bold], ['defg']])
+
+  end
+
   test 'escapes04' do |wb|
     wb.add_worksheet
       .write_url(0, 'A', 'http://www.perl.com/?a=1&b=2')

data/test/test-optimize.rb

@@ -1,3 +1,4 @@
+# coding: utf-8
 # frozen_string_literal: true
 
 require_relative './xlsx-func-testcase'
@@ -18,12 +19,54 @@ class TestOptimize < XlsxWriterTestCase
     # G1 should be ignored since a later row has already been written.
   end
 
+  test('optimize04', constant_memory: true) do |wb|
+    wb
+      .add_format(:bold, bold: true)
+      .add_format(:italic, italic: true)
+      .add_worksheet
+      .write_string('A1', 'Foo', :bold)
+      .write_string('A2', 'Bar', :italic)
+      .write_rich_string('A3', ['a', ['bc', :bold], 'defg'])
+  end
+
+  test('optimize05', constant_memory: true) do |wb|
+    t1, t2, t3, t4 = [
+      ['a', ['bc', :bold], 'defg'],
+      ['a', ['bcdef', :bold], 'g'],
+      ['abc', ['de', :italic], 'fg'],
+      [['abcd', :italic], ['efg', nil]],
+    ].map { |parts| XlsxWriter::RichString.new(wb, parts) }
+    wb
+      .add_format(:bold, bold: true)
+      .add_format(:italic, italic: true)
+      .add_worksheet
+      .write_string('A1', 'Foo', :bold)
+      .write_string('A2', 'Bar', :italic)
+      .write_rich_string('A3', t1)
+      .write_rich_string('B4', t3)
+      .write_rich_string('C5', t1)
+      .write_rich_string('D6', t3)
+      .write_rich_string('E7', t2)
+      .write_rich_string('F8', t4)
+  end
+
   test('optimize06', constant_memory: true) do |wb|
     ws = wb.add_worksheet
     ws.write_string(0, 0, '_x0000_', nil)
     (1..127).each { |i| ws.write_string(i, 0, i.chr, nil) unless i == 34 }
   end
 
+
+  test('optimize08', constant_memory: true) do |wb|
+    wb
+      .add_format(:bold, bold: true)
+      .add_format(:italic, italic: true)
+      .add_worksheet
+      .write_string('A1', 'Foo', :bold)
+      .write_string('A2', 'Bar', :italic)
+      .write_rich_string('A3', [' a', ['bc', :bold], 'defg '])
+  end
+
   test('optimize21', constant_memory: true) do |wb|
     wb.add_worksheet
       .write_string(0, 'A', 'Foo', nil)

data/test/test-rich-string.rb

@@ -0,0 +1,159 @@
+# coding: utf-8
+# frozen_string_literal: true
+
+require_relative './xlsx-func-testcase'
+
+class TestRichString < XlsxWriterTestCase
+  test('rich_string01') do |wb|
+    wb
+      .add_format(:bold, bold: true)
+      .add_format(:italic, italic: true)
+      .add_worksheet
+      .write_string('A1', 'Foo', :bold)
+      .write_string('A2', 'Bar', :italic)
+      .write_rich_string('A3', ['a', ['bc', :bold], 'defg'])
+  end
+
+  test('rich_string02') do |wb|
+    wb
+      .add_format(:bold, bold: true)
+      .add_format(:italic, italic: true)
+      .add_worksheet
+      .write_string('A1', 'Foo', :bold)
+      .write_string('A2', 'Bar', :italic)
+      .write_rich_string('A3', ['abcd', ['ef', :italic], 'g'])
+  end
+
+  test('rich_string03') do |wb|
+    wb
+      .add_format(:bold, bold: true)
+      .add_format(:italic, italic: true)
+      .add_worksheet
+      .write_string('A1', 'Foo', :bold)
+      .write_string('A2', 'Bar', :italic)
+      .write_rich_string('A3', [['abc', :bold], 'defg'])
+  end
+
+  test('rich_string04') do |wb|
+    wb
+      .add_format(:bold, bold: true)
+      .add_format(:italic, italic: true)
+      .add_worksheet
+      .write_string('A1', 'Foo', :bold)
+      .write_string('A2', 'Bar', :italic)
+      .write_rich_string('A3', [['abc', :bold], ['defg', :italic]])
+  end
+
+  test('rich_string05') do |wb|
+    wb
+      .add_format(:bold, bold: true)
+      .add_format(:italic, italic: true)
+      .add_worksheet
+      .set_column('A', 'A', width: 30)
+      .write_string('A1', 'Foo', :bold)
+      .write_string('A2', 'Bar', :italic)
+      .write_rich_string('A3',
+        XlsxWriter::RichString.new(wb) <<
+          'This is ' << ['bold', :bold] << ' and this is ' << ['italic', :italic]
+      )
+  end
+
+
+  test('rich_string06') do |wb|
+    wb
+      .add_format(:red, font_color: XlsxWriter::Format::COLOR_RED)
+      .add_worksheet
+      .write_string('A1', 'Foo', :red)
+      .write_string('A2', 'Bar')
+      .write_rich_string('A3', ['ab', ['cde', :red], 'fg'])
+  end
+
+  test('rich_string07') do |wb|
+    t1, t2, t3, t4 = [
+      ['a', ['bc', :bold], 'defg'],
+      ['a', ['bcdef', :bold], 'g'],
+      ['abc', ['de', :italic], 'fg'],
+      [['abcd', :italic], ['efg', nil]],
+    ].map { |parts| XlsxWriter::RichString.new(wb, parts) }
+    wb
+      .add_format(:bold, bold: true)
+      .add_format(:italic, italic: true)
+      .add_worksheet
+      .write_string('A1', 'Foo', :bold)
+      .write_string('A2', 'Bar', :italic)
+      .write_rich_string('A3', t1)
+      .write_rich_string('B4', t3)
+      .write_rich_string('C5', t1)
+      .write_rich_string('D6', t3)
+      .write_rich_string('E7', t2)
+      .write_rich_string('F8', t4)
+  end
+
+  test('rich_string08') do |wb|
+    wb
+      .add_format(:bold, bold: true)
+      .add_format(:italic, italic: true)
+      .add_format(:centered, align: XlsxWriter::Format::ALIGN_CENTER)
+      .add_worksheet
+      .write_string('A1', 'Foo', :bold)
+      .write_string('A2', 'Bar', :italic)
+      .write_rich_string('A3', ['ab', ['cd', :bold], 'efg'], :centered)
+  end
+
+  test('rich_string09') do |wb|
+    wb
+      .add_format(:bold, bold: true)
+      .add_format(:italic, italic: true)
+    ws = wb.add_worksheet
+    ws
+      .write_string('A1', 'Foo', :bold)
+      .write_string('A2', 'Bar', :italic)
+      .write_rich_string('A3', ['a', ['bc', :bold], 'defg'])
+
+    assert_raise(XlsxWriter::Error, 'Function parameter validation error.') do
+      ws.write_rich_string('A3', ['', ['bc', :bold], 'defg'])
+    end
+    assert_raise(XlsxWriter::Error, 'Function parameter validation error.') do
+      ws.write_rich_string('A3', [])
+    end
+    assert_raise(XlsxWriter::Error, 'Function parameter validation error.') do
+      ws.write_rich_string('A3', [['foo', :bold]])
+    end
+  end
+
+  test('rich_string10') do |wb|
+    wb
+      .add_format(:bold, bold: true)
+      .add_format(:italic, italic: true)
+      .add_worksheet
+      .write_string('A1', 'Foo', :bold)
+      .write_string('A2', 'Bar', :italic)
+      .write_rich_string('A3', [' a', ['bc', :bold], 'defg '])
+  end
+
+  test('rich_string11') do |wb|
+    wb
+      .add_format(:bold, bold: true)
+      .add_format(:italic, italic: true)
+      .add_worksheet
+      .write_string('A1', 'Foo', :bold)
+      .write_string('A2', 'Bar', :italic)
+      .write_rich_string('A3', ['a', ['☺', :bold], 'defg'])
+  end
+
+  test('rich_string12') do |wb|
+    wb
+      .add_format(:bold, bold: true)
+      .add_format(:italic, italic: true)
+      .add_format(:wrap, text_wrap: true)
+      .add_worksheet
+      .set_column('A', 'A', width: 30)
+      .set_row(2, height: 60)
+      .write_string('A1', 'Foo', :bold)
+      .write_string('A2', 'Bar', :italic)
+      .write_rich_string('A3', XlsxWriter::RichString.new(wb) <<
+          "This is\n" << ["bold\n", :bold] << "and this is\n" << ['italic', :italic],
+        :wrap
+      )
+  end
+end

data/test/test-ruby-worksheet.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require_relative './support/with_xlsx_file'
+
+class TestRubyWorksheet < Test::Unit::TestCase
+  include WithXlsxFile
+
+  def test_auto_width
+    with_xlsx_file do |wb|
+      ws = wb.add_worksheet
+
+      ws.add_row ['asd', 'asdf', 'asdfg', 'asdfgh', 'asdfghj', 'd'*250]
+      assert_in_epsilon(4.4, ws.get_column_auto_width('A'))
+      assert_in_epsilon(4.4, ws.get_column_auto_width('B'))
+      assert_in_epsilon(5.5, ws.get_column_auto_width('C'))
+      assert_in_epsilon(6.6, ws.get_column_auto_width('D'))
+      assert_in_epsilon(6.6, ws.get_column_auto_width('E'))
+      assert_in_epsilon(255, ws.get_column_auto_width('F'))
+
+      wb.add_format :f, font_size: 14
+      ws.add_row ['asd', 'asdf', 'asdfg', 'asdfgh', 'asdfghj'], style: :f
+      assert_in_epsilon(5.6, ws.get_column_auto_width('A'))
+      assert_in_epsilon(5.6, ws.get_column_auto_width('B'))
+      assert_in_epsilon(7.0, ws.get_column_auto_width('C'))
+      assert_in_epsilon(8.4, ws.get_column_auto_width('D'))
+      assert_in_epsilon(8.4, ws.get_column_auto_width('E'))
+
+      assert_raise(XlsxWriter::Error.new('Function parameter validation error.')) do
+        ws.write_rich_string('A2', [])
+      end
+    end
+  end
+end

data/test/xlsx-func-testcase.rb

@@ -2,6 +2,7 @@
 
 require 'xlsxwriter'
 require_relative './support/xlsx_comparable'
+require_relative './support/with_xlsx_file'
 
 class XlsxWriterTestCaseConfig
   attr_accessor :ignore_elements, :ignore_files
@@ -12,23 +13,22 @@ class XlsxWriterTestCaseConfig
 end
 
 class XlsxWriterTestCase < Test::Unit::TestCase
+  include WithXlsxFile
   include XlsxComparable
 
-  def self.test(name, opts=nil, &block)
+  def self.test(name, **opts, &block)
     define_method(:"test_#{name}") do
       file_path = "tmp/#{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|
-          instance_exec(wb, tc, &block)
-        end
+      tc = XlsxWriterTestCaseConfig.new
 
+      compare_files = proc {
         assert_xlsx_equal file_path, ref_file_path, tc.ignore_files, tc.ignore_elements
-      ensure
-        File.delete file_path if File.exist? file_path
+      }
+
+      with_xlsx_file(file_path, **opts, after: compare_files) do |wb|
+        instance_exec(wb, tc, &block)
       end
     end
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: xlsxwriter
 version: !ruby/object:Gem::Version
-  version: 0.2.0.pre
+  version: 0.2.0.pre.2
 platform: ruby
 authors:
 - Nick H
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-04-16 00:00:00.000000000 Z
+date: 2019-04-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake-compiler
@@ -25,33 +25,33 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '1.0'
 - !ruby/object:Gem::Dependency
-  name: test-unit
+  name: rubyzip
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.2'
+        version: '1.2'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.2'
+        version: '1.2'
 - !ruby/object:Gem::Dependency
-  name: rubyzip
+  name: test-unit
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.2'
+        version: '3.2'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.2'
+        version: '3.2'
 description: 
 email: 
 executables: []
@@ -129,6 +129,8 @@ files:
 - ext/xlsxwriter/libxlsxwriter/third_party/tmpfileplus/Makefile
 - ext/xlsxwriter/libxlsxwriter/third_party/tmpfileplus/tmpfileplus.c
 - ext/xlsxwriter/libxlsxwriter/third_party/tmpfileplus/tmpfileplus.h
+- ext/xlsxwriter/rich_string.c
+- ext/xlsxwriter/rich_string.h
 - ext/xlsxwriter/workbook.c
 - ext/xlsxwriter/workbook.h
 - ext/xlsxwriter/workbook_properties.c
@@ -138,9 +140,12 @@ files:
 - ext/xlsxwriter/xlsxwriter.c
 - ext/xlsxwriter/xlsxwriter_ext.h
 - lib/xlsxwriter.rb
+- lib/xlsxwriter/error.rb
+- lib/xlsxwriter/rich_string.rb
 - lib/xlsxwriter/version.rb
 - lib/xlsxwriter/worksheet.rb
 - test/run-test.rb
+- test/support/with_xlsx_file.rb
 - test/support/xlsx_comparable.rb
 - test/test-array-formula.rb
 - test/test-autofilter.rb
@@ -177,7 +182,9 @@ files:
 - test/test-properties.rb
 - test/test-protect.rb
 - test/test-repeat.rb
+- test/test-rich-string.rb
 - test/test-row-col-format.rb
+- test/test-ruby-worksheet.rb
 - test/test-set-selection.rb
 - test/test-set-start-page.rb
 - test/test-simple.rb
@@ -212,6 +219,7 @@ test_files:
 - test/test-page-setup.rb
 - test/test-page-breaks.rb
 - test/test-protect.rb
+- test/test-ruby-worksheet.rb
 - test/test-chart-axis.rb
 - test/test-print-area.rb
 - test/test-default-row.rb
@@ -228,6 +236,7 @@ test_files:
 - test/test-row-col-format.rb
 - test/test-escapes.rb
 - test/test-formatting.rb
+- test/support/with_xlsx_file.rb
 - test/support/xlsx_comparable.rb
 - test/test-image.rb
 - test/test-gridlines.rb
@@ -241,6 +250,7 @@ test_files:
 - test/test-print-options.rb
 - test/test-optimize.rb
 - test/test-print-scale.rb
+- test/test-rich-string.rb
 - test/test-chart-scatter.rb
 - test/test-misc.rb
 - test/test-autofilter.rb