fast_excel 0.4.1 → 0.6.0

data/libxlsxwriter/third_party/minizip/zip.h

@@ -37,7 +37,7 @@
 
 */
 
-/* Pragma added by libxlsxwriter project to avoid warnings with -pedantic -ansi. */
+/* Pragma added by libxlsxwriter to avoid warnings with -pedantic -ansi. */
 #ifndef _WIN32
 #pragma GCC system_header
 #endif
@@ -49,7 +49,7 @@
 extern "C" {
 #endif
 
-/* #define HAVE_BZIP2 */
+//#define HAVE_BZIP2
 
 #ifndef _ZLIB_H
 #include "zlib.h"
@@ -59,6 +59,14 @@ extern "C" {
 #include "ioapi.h"
 #endif
 
+/* Encryption not required by libxlsxwriter. */
+#ifndef NOCRYPT
+#define NOCRYPT
+#endif
+#ifndef NOUNCRYPT
+#define NOUNCRYPT
+#endif
+
 #ifdef HAVE_BZIP2
 #include "bzlib.h"
 #endif
@@ -93,12 +101,12 @@ typedef voidp zipFile;
 /* tm_zip contain date/time info */
 typedef struct tm_zip_s
 {
-    uInt tm_sec;            /* seconds after the minute - [0,59] */
-    uInt tm_min;            /* minutes after the hour - [0,59] */
-    uInt tm_hour;           /* hours since midnight - [0,23] */
-    uInt tm_mday;           /* day of the month - [1,31] */
-    uInt tm_mon;            /* months since January - [0,11] */
-    uInt tm_year;           /* years - [1980..2044] */
+    int tm_sec;             /* seconds after the minute - [0,59] */
+    int tm_min;             /* minutes after the hour - [0,59] */
+    int tm_hour;            /* hours since midnight - [0,23] */
+    int tm_mday;            /* day of the month - [1,31] */
+    int tm_mon;             /* months since January - [0,11] */
+    int tm_year;            /* years - [1980..2044] */
 } tm_zip;
 
 typedef struct
@@ -118,8 +126,8 @@ typedef const char* zipcharpc;
 #define APPEND_STATUS_CREATEAFTER   (1)
 #define APPEND_STATUS_ADDINZIP      (2)
 
-extern zipFile ZEXPORT zipOpen OF((const char *pathname, int append));
-extern zipFile ZEXPORT zipOpen64 OF((const void *pathname, int append));
+extern zipFile ZEXPORT zipOpen(const char *pathname, int append);
+extern zipFile ZEXPORT zipOpen64(const void *pathname, int append);
 /*
   Create a zipfile.
      pathname contain on Windows XP a filename like "c:\\zlib\\zlib113.zip" or on
@@ -136,41 +144,46 @@ extern zipFile ZEXPORT zipOpen64 OF((const void *pathname, int append));
 
 /* Note : there is no delete function into a zipfile.
    If you want delete file into a zipfile, you must open a zipfile, and create another
-   Of couse, you can use RAW reading and writing to copy the file you did not want delte
+   Of course, you can use RAW reading and writing to copy the file you did not want delete
 */
 
-extern zipFile ZEXPORT zipOpen2 OF((const char *pathname,
-                                   int append,
-                                   zipcharpc* globalcomment,
-                                   zlib_filefunc_def* pzlib_filefunc_def));
+extern zipFile ZEXPORT zipOpen2(const char *pathname,
+                                int append,
+                                zipcharpc* globalcomment,
+                                zlib_filefunc_def* pzlib_filefunc_def);
 
-extern zipFile ZEXPORT zipOpen2_64 OF((const void *pathname,
+extern zipFile ZEXPORT zipOpen2_64(const void *pathname,
                                    int append,
                                    zipcharpc* globalcomment,
-                                   zlib_filefunc64_def* pzlib_filefunc_def));
-
-extern int ZEXPORT zipOpenNewFileInZip OF((zipFile file,
-                       const char* filename,
-                       const zip_fileinfo* zipfi,
-                       const void* extrafield_local,
-                       uInt size_extrafield_local,
-                       const void* extrafield_global,
-                       uInt size_extrafield_global,
-                       const char* comment,
-                       int method,
-                       int level));
-
-extern int ZEXPORT zipOpenNewFileInZip64 OF((zipFile file,
-                       const char* filename,
-                       const zip_fileinfo* zipfi,
-                       const void* extrafield_local,
-                       uInt size_extrafield_local,
-                       const void* extrafield_global,
-                       uInt size_extrafield_global,
-                       const char* comment,
-                       int method,
-                       int level,
-                       int zip64));
+                                   zlib_filefunc64_def* pzlib_filefunc_def);
+
+extern zipFile ZEXPORT zipOpen3(const void *pathname,
+                                int append,
+                                zipcharpc* globalcomment,
+                                zlib_filefunc64_32_def* pzlib_filefunc64_32_def);
+
+extern int ZEXPORT zipOpenNewFileInZip(zipFile file,
+                                       const char* filename,
+                                       const zip_fileinfo* zipfi,
+                                       const void* extrafield_local,
+                                       uInt size_extrafield_local,
+                                       const void* extrafield_global,
+                                       uInt size_extrafield_global,
+                                       const char* comment,
+                                       int method,
+                                       int level);
+
+extern int ZEXPORT zipOpenNewFileInZip64(zipFile file,
+                                         const char* filename,
+                                         const zip_fileinfo* zipfi,
+                                         const void* extrafield_local,
+                                         uInt size_extrafield_local,
+                                         const void* extrafield_global,
+                                         uInt size_extrafield_global,
+                                         const char* comment,
+                                         int method,
+                                         int level,
+                                         int zip64);
 
 /*
   Open a file in the ZIP for writing.
@@ -189,70 +202,69 @@ extern int ZEXPORT zipOpenNewFileInZip64 OF((zipFile file,
 */
 
 
-extern int ZEXPORT zipOpenNewFileInZip2 OF((zipFile file,
-                                            const char* filename,
-                                            const zip_fileinfo* zipfi,
-                                            const void* extrafield_local,
-                                            uInt size_extrafield_local,
-                                            const void* extrafield_global,
-                                            uInt size_extrafield_global,
-                                            const char* comment,
-                                            int method,
-                                            int level,
-                                            int raw));
-
-
-extern int ZEXPORT zipOpenNewFileInZip2_64 OF((zipFile file,
-                                            const char* filename,
-                                            const zip_fileinfo* zipfi,
-                                            const void* extrafield_local,
-                                            uInt size_extrafield_local,
-                                            const void* extrafield_global,
-                                            uInt size_extrafield_global,
-                                            const char* comment,
-                                            int method,
-                                            int level,
-                                            int raw,
-                                            int zip64));
+extern int ZEXPORT zipOpenNewFileInZip2(zipFile file,
+                                        const char* filename,
+                                        const zip_fileinfo* zipfi,
+                                        const void* extrafield_local,
+                                        uInt size_extrafield_local,
+                                        const void* extrafield_global,
+                                        uInt size_extrafield_global,
+                                        const char* comment,
+                                        int method,
+                                        int level,
+                                        int raw);
+
+
+extern int ZEXPORT zipOpenNewFileInZip2_64(zipFile file,
+                                           const char* filename,
+                                           const zip_fileinfo* zipfi,
+                                           const void* extrafield_local,
+                                           uInt size_extrafield_local,
+                                           const void* extrafield_global,
+                                           uInt size_extrafield_global,
+                                           const char* comment,
+                                           int method,
+                                           int level,
+                                           int raw,
+                                           int zip64);
 /*
   Same than zipOpenNewFileInZip, except if raw=1, we write raw file
  */
 
-extern int ZEXPORT zipOpenNewFileInZip3 OF((zipFile file,
-                                            const char* filename,
-                                            const zip_fileinfo* zipfi,
-                                            const void* extrafield_local,
-                                            uInt size_extrafield_local,
-                                            const void* extrafield_global,
-                                            uInt size_extrafield_global,
-                                            const char* comment,
-                                            int method,
-                                            int level,
-                                            int raw,
-                                            int windowBits,
-                                            int memLevel,
-                                            int strategy,
-                                            const char* password,
-                                            uLong crcForCrypting));
-
-extern int ZEXPORT zipOpenNewFileInZip3_64 OF((zipFile file,
-                                            const char* filename,
-                                            const zip_fileinfo* zipfi,
-                                            const void* extrafield_local,
-                                            uInt size_extrafield_local,
-                                            const void* extrafield_global,
-                                            uInt size_extrafield_global,
-                                            const char* comment,
-                                            int method,
-                                            int level,
-                                            int raw,
-                                            int windowBits,
-                                            int memLevel,
-                                            int strategy,
-                                            const char* password,
-                                            uLong crcForCrypting,
-                                            int zip64
-                                            ));
+extern int ZEXPORT zipOpenNewFileInZip3(zipFile file,
+                                        const char* filename,
+                                        const zip_fileinfo* zipfi,
+                                        const void* extrafield_local,
+                                        uInt size_extrafield_local,
+                                        const void* extrafield_global,
+                                        uInt size_extrafield_global,
+                                        const char* comment,
+                                        int method,
+                                        int level,
+                                        int raw,
+                                        int windowBits,
+                                        int memLevel,
+                                        int strategy,
+                                        const char* password,
+                                        uLong crcForCrypting);
+
+extern int ZEXPORT zipOpenNewFileInZip3_64(zipFile file,
+                                           const char* filename,
+                                           const zip_fileinfo* zipfi,
+                                           const void* extrafield_local,
+                                           uInt size_extrafield_local,
+                                           const void* extrafield_global,
+                                           uInt size_extrafield_global,
+                                           const char* comment,
+                                           int method,
+                                           int level,
+                                           int raw,
+                                           int windowBits,
+                                           int memLevel,
+                                           int strategy,
+                                           const char* password,
+                                           uLong crcForCrypting,
+                                           int zip64);
 
 /*
   Same than zipOpenNewFileInZip2, except
@@ -261,47 +273,45 @@ extern int ZEXPORT zipOpenNewFileInZip3_64 OF((zipFile file,
     crcForCrypting : crc of file to compress (needed for crypting)
  */
 
-extern int ZEXPORT zipOpenNewFileInZip4 OF((zipFile file,
-                                            const char* filename,
-                                            const zip_fileinfo* zipfi,
-                                            const void* extrafield_local,
-                                            uInt size_extrafield_local,
-                                            const void* extrafield_global,
-                                            uInt size_extrafield_global,
-                                            const char* comment,
-                                            int method,
-                                            int level,
-                                            int raw,
-                                            int windowBits,
-                                            int memLevel,
-                                            int strategy,
-                                            const char* password,
-                                            uLong crcForCrypting,
-                                            uLong versionMadeBy,
-                                            uLong flagBase
-                                            ));
-
-
-extern int ZEXPORT zipOpenNewFileInZip4_64 OF((zipFile file,
-                                            const char* filename,
-                                            const zip_fileinfo* zipfi,
-                                            const void* extrafield_local,
-                                            uInt size_extrafield_local,
-                                            const void* extrafield_global,
-                                            uInt size_extrafield_global,
-                                            const char* comment,
-                                            int method,
-                                            int level,
-                                            int raw,
-                                            int windowBits,
-                                            int memLevel,
-                                            int strategy,
-                                            const char* password,
-                                            uLong crcForCrypting,
-                                            uLong versionMadeBy,
-                                            uLong flagBase,
-                                            int zip64
-                                            ));
+extern int ZEXPORT zipOpenNewFileInZip4(zipFile file,
+                                        const char* filename,
+                                        const zip_fileinfo* zipfi,
+                                        const void* extrafield_local,
+                                        uInt size_extrafield_local,
+                                        const void* extrafield_global,
+                                        uInt size_extrafield_global,
+                                        const char* comment,
+                                        int method,
+                                        int level,
+                                        int raw,
+                                        int windowBits,
+                                        int memLevel,
+                                        int strategy,
+                                        const char* password,
+                                        uLong crcForCrypting,
+                                        uLong versionMadeBy,
+                                        uLong flagBase);
+
+
+extern int ZEXPORT zipOpenNewFileInZip4_64(zipFile file,
+                                           const char* filename,
+                                           const zip_fileinfo* zipfi,
+                                           const void* extrafield_local,
+                                           uInt size_extrafield_local,
+                                           const void* extrafield_global,
+                                           uInt size_extrafield_global,
+                                           const char* comment,
+                                           int method,
+                                           int level,
+                                           int raw,
+                                           int windowBits,
+                                           int memLevel,
+                                           int strategy,
+                                           const char* password,
+                                           uLong crcForCrypting,
+                                           uLong versionMadeBy,
+                                           uLong flagBase,
+                                           int zip64);
 /*
   Same than zipOpenNewFileInZip4, except
     versionMadeBy : value for Version made by field
@@ -309,25 +319,25 @@ extern int ZEXPORT zipOpenNewFileInZip4_64 OF((zipFile file,
  */
 
 
-extern int ZEXPORT zipWriteInFileInZip OF((zipFile file,
-                       const void* buf,
-                       unsigned len));
+extern int ZEXPORT zipWriteInFileInZip(zipFile file,
+                                       const void* buf,
+                                       unsigned len);
 /*
   Write data in the zipfile
 */
 
-extern int ZEXPORT zipCloseFileInZip OF((zipFile file));
+extern int ZEXPORT zipCloseFileInZip(zipFile file);
 /*
   Close the current file in the zipfile
 */
 
-extern int ZEXPORT zipCloseFileInZipRaw OF((zipFile file,
-                                            uLong uncompressed_size,
-                                            uLong crc32));
+extern int ZEXPORT zipCloseFileInZipRaw(zipFile file,
+                                        uLong uncompressed_size,
+                                        uLong crc32);
 
-extern int ZEXPORT zipCloseFileInZipRaw64 OF((zipFile file,
-                                            ZPOS64_T uncompressed_size,
-                                            uLong crc32));
+extern int ZEXPORT zipCloseFileInZipRaw64(zipFile file,
+                                          ZPOS64_T uncompressed_size,
+                                          uLong crc32);
 
 /*
   Close the current file in the zipfile, for file opened with
@@ -335,14 +345,14 @@ extern int ZEXPORT zipCloseFileInZipRaw64 OF((zipFile file,
   uncompressed_size and crc32 are value for the uncompressed size
 */
 
-extern int ZEXPORT zipClose OF((zipFile file,
-                const char* global_comment));
+extern int ZEXPORT zipClose(zipFile file,
+                            const char* global_comment);
 /*
   Close the zipfile
 */
 
 
-extern int ZEXPORT zipRemoveExtraInfoBlock OF((char* pData, int* dataLen, short sHeader));
+extern int ZEXPORT zipRemoveExtraInfoBlock(char* pData, int* dataLen, short sHeader);
 /*
   zipRemoveExtraInfoBlock -  Added by Mathias Svensson
 

data/libxlsxwriter/third_party/tmpfileplus/Makefile

@@ -33,10 +33,10 @@ endif
 all: tmpfileplus.o tmpfileplus.so
 
 %.o  : %.c
-	$(Q)$(CC)         -c $(CFLAGS) $<
+	$(Q)$(CC)         -c $(CFLAGS) $(TARGET_ARCH) $<
 
 %.so : %.c
-	$(Q)$(CC) $(FPIC) -c $(CFLAGS) $< -o $@
+	$(Q)$(CC) $(FPIC) -c $(CFLAGS) $(TARGET_ARCH) $< -o $@
 
 clean:
-	$(Q)/bin/rm -f *.o *.so
+	$(Q)rm -f *.o *.so

data/libxlsxwriter/version.txt

@@ -1 +1 @@
-2019-06-17 01:19:43 +0800 56b73bb
+2023-12-29 19:18:35 +0700 e3ede9d

data/sonar-project.properties

@@ -0,0 +1,4 @@
+sonar.sources=.
+sonar.language=ruby
+sonar.ruby.coverage.reportPaths=coverage/.resultset.json
+sonar.exclusions=**/*_test.rb,**/coverage/**

data/test/auto_width_test.rb

@@ -16,4 +16,24 @@ describe "FastExcel text_width" do
 
     assert_equal(sheet.calculated_column_widths, {0 => 3.52, 1 => 5.28, 2 => 14.96, 3 => 44.88})
   end
+
+  it "should set the default column width for an empty column on close" do
+    workbook = FastExcel.open(constant_memory: false)
+    sheet = workbook.add_worksheet
+    sheet.auto_width = true
+
+    sheet.append_row([
+      nil,
+      "tini",
+      "Longer",
+      "Some longer text!",
+      "This gem is FFI binding for libxlsxwriter C library"
+    ])
+
+    assert_equal(sheet.calculated_column_widths, {0 => nil, 1 => 3.52, 2 => 5.28, 3 => 14.96, 4 => 44.88})
+
+    workbook.close
+
+    assert_equal(sheet.calculated_column_widths, {0 => FastExcel::DEF_COL_WIDTH, 1 => 3.52, 2 => 5.28, 3 => 14.96, 4 => 44.88})
+  end
 end

data/test/color_to_hex_test.rb

@@ -0,0 +1,15 @@
+require_relative 'test_helper'
+
+describe "FastExcel.color_to_hex" do
+  it "should convert hex number color to hex" do
+    assert_equal(FastExcel.color_to_hex(0xFF0000), 0xFF0000)
+  end
+
+  it "should convert color name to hex" do
+    assert_equal(FastExcel.color_to_hex("color_lime"), 0x00FF00)
+  end
+
+  it "should convert color name (extra colors) to hex" do
+    assert_equal(FastExcel.color_to_hex("steel_blue"), 0x4682B4)
+  end
+end

data/test/comment_opt_test.rb

@@ -0,0 +1,76 @@
+require_relative 'test_helper'
+
+describe 'FastExcel::Worksheet write_comment_opt' do
+  let(:workbook) { FastExcel.open(constant_memory: true) }
+  let(:worksheet) { workbook.add_worksheet }
+  let(:options) do
+    Libxlsxwriter::CommentOptions.new.tap do |opts|
+      opts.author = 'Lolo'
+      opts.visible = 1
+      opts.width = 200
+      opts.height = 100
+      opts.x_scale = 1.5
+      opts.y_scale = 1.5
+      opts.color = '0xFFFF00'
+      opts.font_name = 'Arial'
+      opts.font_size = 12.0
+      opts.font_family = 2
+      opts.start_row = 0
+      opts.start_col = 1
+      opts.x_offset = 10
+      opts.y_offset = 10
+    end
+  end
+
+  it 'should write a comment with options struct' do
+    assert_equal(:no_error, worksheet.write_comment_opt(0, 0, 'Hello with options', options))
+  end
+
+  it 'should write a comment with hash options' do
+    assert_equal(:no_error, worksheet.write_comment_opt(1, 0, 'Comment via hash', author: 'Author1', visible: 1, color: '#FF0000'))
+  end
+
+  it 'should write a comment using write_comment with optional options' do
+    assert_equal(:no_error, worksheet.write_comment(2, 0, 'Simple comment'))
+    assert_equal(:no_error, worksheet.write_comment(3, 0, 'Comment with hash', author: 'Alice', color: 'lime'))
+  end
+
+  it 'handles nil author and font_name safely' do
+    opts = Libxlsxwriter::CommentOptions.new
+    opts.author = nil
+    opts.font_name = nil
+    assert_nil opts.author
+    assert_nil opts.font_name
+
+    opts.author = 'Bob'
+    assert_equal 'Bob', opts.author
+    opts.author = nil
+    assert_nil opts.author
+  end
+
+  it 'preserves string pointers across garbage collection' do
+    opts = Libxlsxwriter::CommentOptions.new(author: "Temporary #{rand} Author", font_name: 'Courier New')
+    # Run full GC cycles to ensure MemoryPointer is not collected prematurely
+    10.times { GC.start }
+
+    assert opts.author.start_with?('Temporary')
+    assert_equal 'Courier New', opts.font_name
+    assert_equal :no_error, worksheet.write_comment_opt(4, 0, 'GC test comment', opts)
+  end
+
+  it 'generates a valid excel file with styled comments' do
+    temp_file = File.join(Dir.tmpdir, "test_comments_#{Time.now.to_i}.xlsx")
+    begin
+      wb = FastExcel.open(temp_file)
+      ws = wb.add_worksheet
+      ws.write_value(0, 0, 'Data')
+      ws.write_comment(0, 0, 'Styled comment', author: 'Tester', visible: 1, color: 'yellow', font_name: 'Arial')
+      wb.close
+
+      assert File.exist?(temp_file)
+      assert File.size(temp_file) > 0
+    ensure
+      File.delete(temp_file) if File.exist?(temp_file)
+    end
+  end
+end

data/test/date_test.rb

@@ -54,3 +54,17 @@ describe "FastExcel.write_value" do
   end
 
 end
+
+describe "FastExcel.lxw_time" do
+  it "should make Libxlsxwriter::Datetime" do
+    time = Time.at(610421163).utc
+    lxw_time = FastExcel.lxw_time(time)
+
+    assert_equal(lxw_time[:year], 1989)
+    assert_equal(lxw_time[:month], 5)
+    assert_equal(lxw_time[:day], 6)
+    assert_equal(lxw_time[:hour], 1)
+    assert_equal(lxw_time[:min], 26)
+    assert_equal(lxw_time[:sec], 3.0)
+  end
+end

data/test/default_format_test.rb

@@ -9,7 +9,7 @@ describe "FastExcel default_format" do
       bold: true
     })
 
-    #FastExcel.print_ffi_obj(workbook.default_format)
+    # FastExcel.print_ffi_obj(workbook.default_format)
 
     assert_equal("ArialFoo", workbook.default_format.font_family)
     assert_equal(17, workbook.default_format.font_size)

data/test/format_test.rb

@@ -112,7 +112,11 @@ describe "FastExcel::FormatExt colors" do
       @format.font_color = {aaa: 1}
     end
 
-    assert_equal(error.message, "Can not use Hash ({:aaa=>1}) for color value, expected String or Hex Number")
+    if error.message =~ /=>/
+      assert_equal(error.message, "Can not use Hash ({:aaa=>1}) for color value, expected String or Hex Number")
+    else
+      assert_equal(error.message, "Can not use Hash ({aaa: 1}) for color value, expected String or Hex Number")
+    end
   end
 
   it "should raise for unexpected color" do

data/test/get_worksheet_test.rb

@@ -0,0 +1,28 @@
+require_relative 'test_helper'
+
+describe "FastExcel::Worksheet" do
+  before do
+    @workbook = FastExcel.open(constant_memory: true)
+  end
+
+  describe "#get_worksheet_by_name" do
+    it "should return nil if worksheet does not exist" do
+      ws = @workbook.get_worksheet_by_name("Page1")
+      assert_nil(ws)
+
+      assert_nil(@workbook.get_worksheet_by_name(nil))
+      assert_nil(@workbook.get_worksheet_by_name(:Page1))
+    end
+
+    it "should return worksheet if worksheet does exist" do
+      @workbook.add_worksheet("Page1")
+
+      ws = @workbook.get_worksheet_by_name("Page1")
+      ws.write_row(0, ['1'])
+      assert_kind_of(Libxlsxwriter::Worksheet, ws)
+
+      ws_by_sym = @workbook.get_worksheet_by_name(:Page1)
+      assert_kind_of(Libxlsxwriter::Worksheet, ws_by_sym)
+    end
+  end
+end

data/test/test_helper.rb

@@ -1,13 +1,16 @@
+require "simplecov"
+
+SimpleCov.start do
+  add_filter 'test'
+end
+
 require 'bundler/setup'
 require 'minitest/autorun'
 require "minitest/reporters"
 require 'pp'
-
-##Encoding.default_external = Encoding::UTF_8
-##Encoding.default_internal = Encoding::UTF_8
-
 require 'date'
 
+
 Minitest::Reporters.use!(
   Minitest::Reporters::DefaultReporter.new(color: true)
 )