f_xlsx 0.2.8

data/ext/xlsx.go

@@ -0,0 +1,299 @@
+package main
+
+import (
+	"fmt"
+	"sync"
+	"unsafe"
+
+	"github.com/google/uuid"
+	"github.com/xuri/excelize/v2"
+)
+
+/*
+#include <stdlib.h>
+#include <types.h>
+*/
+import "C"
+
+var files map[uint32]*excelize.File
+var once sync.Once
+
+func getFile(uid uint32) *excelize.File {
+	return files[uid]
+}
+
+func setFile(uid uint32, file *excelize.File) {
+	once.Do(func() {
+		files = make(map[uint32]*excelize.File)
+	})
+	files[uid] = file
+}
+
+//export printStr
+func printStr(str *C.char) {
+	ss := C.GoString(str)
+	fmt.Println(ss)
+}
+
+//export newFile
+func newFile() uint32 {
+	file := excelize.NewFile()
+	uid := fuuid()
+	setFile(uid, file)
+	return uid
+}
+
+//export openFile
+func openFile(filePath *C.char) uint32 {
+	path := C.GoString(filePath)
+	fmt.Println(path)
+	file, err := excelize.OpenFile(path)
+	if err != nil {
+		fmt.Println(err)
+		return 0
+	}
+	uid := fuuid()
+	setFile(uid, file)
+	return uid
+}
+
+//export newSheet
+func newSheet(fileId uint32, sheetNamcC *C.char) C.int {
+	f := getFile(fileId)
+	sheetName := C.GoString(sheetNamcC)
+	num, _ := f.NewSheet(sheetName)
+	return C.int(num)
+}
+
+//export setSheetName
+func setSheetName(fileId uint32, sheetNameC *C.char, targetSheetNameC *C.char) {
+	f := getFile(fileId)
+	sheetName := C.GoString(sheetNameC)
+	targetSheetName := C.GoString(targetSheetNameC)
+	f.SetSheetName(sheetName, targetSheetName)
+}
+
+//export getSheetList
+func getSheetList(fileId uint32) *C.struct_str_arr {
+	f := getFile(fileId)
+	names := f.GetSheetList()
+	return fromGo2Arrs(names)
+}
+
+//export getSheetName
+func getSheetName(fileId uint32, index int) *C.char {
+	f := getFile(fileId)
+	name := f.GetSheetName(index)
+	rtn := C.CString(name)
+	// defer C.free(unsafe.Pointer(rtn))
+	return rtn
+}
+
+//export closeFile
+func closeFile(fileId uint32) {
+	f := getFile(fileId)
+	f.Close()
+	delete(files, fileId)
+}
+
+//export setSheetVisible
+func setSheetVisible(fileId uint32, sheetNameC *C.char, visible C.int) {
+	f := getFile(fileId)
+	sheetName := C.GoString(sheetNameC)
+	f.SetSheetVisible(sheetName, int(visible) == 1)
+}
+
+//export getSheetVisible
+func getSheetVisible(fileId uint32, sheetNameC *C.char) C.int {
+	f := getFile(fileId)
+	sheetName := C.GoString(sheetNameC)
+	vis, _ := f.GetSheetVisible(sheetName)
+	if vis {
+		return C.int(1)
+	}
+	return C.int(0)
+}
+
+//export deleteSheet
+func deleteSheet(fileId uint32, sheetNameC *C.char) {
+	f := getFile(fileId)
+	sheetName := C.GoString(sheetNameC)
+	f.DeleteSheet(sheetName)
+}
+
+//export setCellValue
+func setCellValue(fileId uint32, sheetNameC *C.char, row C.int, col C.int, value unsafe.Pointer, typ int) {
+	f := getFile(fileId)
+	sheetName := C.GoString(sheetNameC)
+	cell, _ := excelize.CoordinatesToCellName(int(col)+1, int(row)+1)
+	switch int(typ) {
+	case 1: //int
+		ptr := (*C.int)(value)
+		f.SetCellInt(sheetName, cell, int(*ptr))
+	case 2: //float
+		ptr := (*C.float)(value)
+		f.SetCellFloat(sheetName, cell, float64(*ptr), 4, 32)
+	case 3: //string
+		val := (*C.char)(value)
+		f.SetCellStr(sheetName, cell, C.GoString(val))
+	}
+}
+
+//export getCellValue
+func getCellValue(fileId uint32, sheetNameC *C.char, row C.int, col C.int) *C.char {
+	f := getFile(fileId)
+	sheetName := C.GoString(sheetNameC)
+	cell, _ := excelize.CoordinatesToCellName(int(col)+1, int(row)+1)
+	val, _ := f.GetCellValue(sheetName, cell)
+
+	str := C.CString(val)
+	// defer C.free(unsafe.Pointer(str))
+	return str
+}
+
+//export getRows
+func getRows(fileId uint32, sheetNameC *C.char) *C.struct_str_arr2 {
+	f := getFile(fileId)
+	sheetName := C.GoString(sheetNameC)
+	rows, _ := f.GetRows(sheetName)
+	return fromGo2Arrs2(rows)
+}
+
+//export putRows
+func putRows(fileId uint32, sheetNameC *C.char, rowsC *C.struct_str_arr2) {
+	f := getFile(fileId)
+	sheetName := C.GoString(sheetNameC)
+	vRows := (*[2 << 32]*C.struct_str_arr)(unsafe.Pointer(rowsC.arr))
+	for i := 0; i < int(rowsC.s_size); i++ {
+		row := fromArr2Go(vRows[i])
+		innerPutRow(f, sheetName, i, row)
+	}
+
+}
+
+//export putRow
+func putRow(fileId uint32, sheetNameC *C.char, rowIndex int, rowC *C.struct_str_arr) {
+	f := getFile(fileId)
+	sheetName := C.GoString(sheetNameC)
+	row := fromArr2Go(rowC)
+	fmt.Printf("%v\n", len(row))
+	innerPutRow(f, sheetName, rowIndex, row)
+}
+
+func innerPutRow(f *excelize.File, sheetName string, rowIndex int, row []string) {
+	for i := 0; i < len(row); i++ {
+		cell, _ := excelize.CoordinatesToCellName(i+1, rowIndex+1)
+		f.SetCellStr(sheetName, cell, row[i])
+	}
+}
+
+//export mergeCell
+func mergeCell(fileId uint32, sheetNameC *C.char, startRow int, startCol int, endRow int, endCol int) {
+	f := getFile(fileId)
+	sheetName := C.GoString(sheetNameC)
+	cellStart, _ := excelize.CoordinatesToCellName(int(startCol)+1, int(startRow)+1)
+	cellEnd, _ := excelize.CoordinatesToCellName(int(endCol)+1, int(endRow)+1)
+	f.MergeCell(sheetName, cellStart, cellEnd)
+}
+
+//export unMergeCell
+func unMergeCell(fileId uint32, sheetNameC *C.char, startRow int, startCol int, endRow int, endCol int) {
+	f := getFile(fileId)
+	sheetName := C.GoString(sheetNameC)
+	cellStart, _ := excelize.CoordinatesToCellName(int(startCol)+1, int(startRow)+1)
+	cellEnd, _ := excelize.CoordinatesToCellName(int(endCol)+1, int(endRow)+1)
+	f.UnmergeCell(sheetName, cellStart, cellEnd)
+}
+
+//export getMergeCells
+func getMergeCells(fileId uint32, sheetNameC *C.char) *C.merge_cell_arr {
+	f := getFile(fileId)
+	sheetName := C.GoString(sheetNameC)
+	cells, _ := f.GetMergeCells(sheetName)
+	return fromGoCells2C(cells)
+}
+
+//export save
+func save(fileId uint32) {
+	f := getFile(fileId)
+	f.Save()
+	f.Close()
+	delete(files, fileId)
+}
+
+//export saveAs
+func saveAs(fileId uint32, path *C.char) {
+	f := getFile(fileId)
+	strPath := C.GoString(path)
+	f.SaveAs(strPath)
+	f.Close()
+	delete(files, fileId)
+}
+
+func fromGo2Arrs(strs []string) *C.struct_str_arr {
+	var arr = (*C.struct_str_arr)(C.malloc(C.size_t(unsafe.Sizeof(C.struct_str_arr{}))))
+	arr.s_size = C.int(len(strs))
+
+	var ss = C.malloc(C.size_t(arr.s_size) * C.size_t(unsafe.Sizeof(uintptr(0))))
+
+	var arrSs = (*[2 << 32]*C.char)(unsafe.Pointer(ss))
+	for i, s := range strs {
+		arrSs[i] = C.CString(s)
+	}
+	arr.arr = (**C.char)(ss)
+	return arr
+}
+
+func fromGo2Arrs2(strs [][]string) *C.struct_str_arr2 {
+	var arr2 = (*C.struct_str_arr2)(C.malloc(C.size_t(unsafe.Sizeof(C.struct_str_arr2{}))))
+	arr2.s_size = C.int(len(strs))
+	var ss = C.malloc(C.size_t(arr2.s_size) * C.size_t(unsafe.Sizeof(uintptr(0))))
+	var arrSs = (*[2 << 32]*C.struct_str_arr)(unsafe.Pointer(ss))
+
+	for i, _strs := range strs {
+		arrSs[i] = fromGo2Arrs(_strs)
+	}
+	arr2.arr = (**C.struct_str_arr)(ss)
+	return arr2
+}
+
+func fromArr2Go(rowC *C.struct_str_arr) []string {
+	vRow := (*[2 << 32]*C.char)(unsafe.Pointer(rowC.arr))
+	row := make([]string, 0, int(rowC.s_size))
+	for ii := 0; ii < int(rowC.s_size); ii++ {
+		row = append(row, C.GoString(vRow[ii]))
+	}
+	return row
+}
+
+func fromGoCells2C(cells []excelize.MergeCell) *C.merge_cell_arr {
+	var cCells = (**C.merge_cell)(C.malloc(C.size_t(len(cells)) * C.size_t(unsafe.Sizeof(C.merge_cell{}))))
+	var cellArr = (*C.merge_cell_arr)(C.malloc(C.size_t(unsafe.Sizeof(C.merge_cell_arr{}))))
+	cellArr.s_size = C.int(len(cells))
+	cellArr.cells = cCells
+	var arrCells = (*[2 << 32]*C.merge_cell)(unsafe.Pointer(cCells))
+	for i := 0; i < len(cells); i++ {
+		c := cells[i]
+		mc := (*C.merge_cell)(C.malloc(C.size_t(unsafe.Sizeof(C.merge_cell{}))))
+		startA := c.GetStartAxis()
+		startCol, startRow, _ := excelize.CellNameToCoordinates(startA)
+		endA := c.GetEndAxis()
+		endCol, endRow, _ := excelize.CellNameToCoordinates(endA)
+		cellValue := c.GetCellValue()
+		fmt.Println(cellValue)
+		mc.val = C.CString(cellValue)
+		mc.start_row = C.int(startRow) - 1
+		mc.start_col = C.int(startCol) - 1
+		mc.end_row = C.int(endRow) - 1
+		mc.end_col = C.int(endCol) - 1
+		arrCells[i] = mc
+	}
+	return cellArr
+}
+
+func fuuid() uint32 {
+	return uuid.New().ID()
+}
+
+func main() {
+}

data/f_xlsx.gemspec

@@ -0,0 +1,43 @@
+
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "f_xlsx/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "f_xlsx"
+  spec.version       = FXlsx::VERSION
+  spec.authors       = ["dong.wang"]
+  spec.email         = ["dong.wang@rccchina.com"]
+
+  spec.summary       = %q{cgo support xlsx, from golang excelize}
+  spec.description   = %q{cgo support xlsx, from golang excelize}
+  spec.homepage      = "https://github.com/secondrocker/f_xlsx"
+  spec.license       = "MIT"
+
+  # Prevent pushing this gem to RubyGems.org. To allow pushes either set the 'allowed_push_host'
+  # to allow pushing to a single host or delete this section to allow pushing to any host.
+  if spec.respond_to?(:metadata)
+    # spec.metadata["allowed_push_host"] = "TODO: Set to 'http://mygemserver.com'"
+
+    spec.metadata["homepage_uri"] = spec.homepage
+    spec.metadata["source_code_uri"] = "https://github.com/secondrocker/f_xlsx"
+    # spec.metadata["changelog_uri"] = "TODO: Put your gem's CHANGELOG.md URL here."
+  else
+    raise "RubyGems 2.0 or newer is required to protect against " \
+      "public gem pushes."
+  end
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", '>= 1.0', '<= 3.0'
+  spec.add_development_dependency "rake", '~> 13.0'
+  spec.add_development_dependency "rspec", "~> 3.0"
+  spec.add_dependency "ffi", "~> 1"
+end

data/lib/f_xlsx/base_types.rb

@@ -0,0 +1,63 @@
+module FXlsx
+  class CStrArray  < FFI::Struct
+    layout :arr, :pointer,
+           :s_size, :int
+    
+    def value
+      str = []
+      self[:arr].read_array_of_pointer(self[:s_size]).map do |str_ptr| 
+        str << str_ptr.read_string
+        LibC.free(str_ptr)
+      end
+      LibC.free(self[:arr])
+      LibC.free(self)
+      str 
+    end
+  end
+
+  class CStrArray2 < FFI::Struct
+    layout :arr, :pointer,
+           :s_size, :int
+    def value
+      rows = []
+      self[:arr].read_array_of_pointer(self[:s_size]).each do |p|
+        # CStrArray value方法自动释放指针，本处不需释放
+        rows << CStrArray.new(p).value
+      end
+      LibC.free(self[:arr])
+      LibC.free(self)
+      rows
+    end
+  end
+
+  class CCell < FFI::Struct
+    layout :start_row, :int,
+           :start_col, :int,
+           :end_row, :int,
+           :end_col, :int,
+           :val, :string
+  end
+
+  class CCellArray < FFI::Struct
+    layout :cells, :pointer,
+           :s_size, :int
+
+    def values
+      _cells = []
+      self[:cells].read_array_of_pointer(self[:s_size]).each do |cell_ptr|
+        c = CCell.new(cell_ptr)
+        _cells << {
+          start_row: c[:start_row],
+          start_col: c[:start_col],
+          end_row: c[:end_row],
+          end_col: c[:end_col],
+          value: c[:val]
+        }
+        LibC.free(cell_ptr)
+      end
+      LibC.free(self[:cells])
+      LibC.free(self)
+      _cells
+    end
+  end
+end

data/lib/f_xlsx/file.rb

@@ -0,0 +1,180 @@
+module FXlsx
+  class File
+    attr_accessor :id, :closed, :has_file
+    
+    def self.new_file
+      XlsxExt.load_lib
+      instance = File.new
+      instance.id = XlsxExt.newFile()
+      instance
+    end
+  
+    def self.open_file(path)
+      XlsxExt.load_lib
+      instance = File.new
+      instance.id = XlsxExt.openFile(path)
+      instance.has_file = true
+      instance
+    end
+  
+    def closed?
+      closed
+    end
+  
+    def new_sheet(sheet_name)
+      raise "file closed" if self.closed?
+  
+      XlsxExt.newSheet(self.id, sheet_name)
+    end
+  
+    def set_sheet_name(sheet_name, target_sheet_name)
+      raise "file closed" if self.closed?
+  
+      XlsxExt.setSheetName(self.id, sheet_name, target_sheet_name)
+    end
+
+    def set_sheet_visible(sheet_name, visible)
+      raise "file closed" if self.closed?
+
+      XlsxExt.setSheetVisible(self.id, sheet_name, visible ? 1 : 0)
+    end
+
+    def get_sheet_visible(sheet_name)
+      raise "file closed" if self.closed?
+
+      XlsxExt.getSheetVisible(self.id, sheet_name) == 1
+    end
+  
+    def delete_sheet(sheet_name)
+      raise "file closed" if self.closed?
+  
+      XlsxExt.deleteSheet(self.id, sheet_name)
+    end
+  
+    def get_sheet_list
+      raise "file closed" if self.closed?
+  
+      ptr =  XlsxExt.getSheetList(self.id)
+      ptr.value
+    end
+  
+    def get_sheet_name(index)
+      raise "file closed" if self.closed?
+  
+      XlsxExt.getSheetName(self.id, index)
+    end
+  
+  
+    def set_cell_value(sheet_name, row, col, value)
+      raise "file closed" if self.closed?
+  
+      value = '' if value.nil?
+      ptr = nil
+      typ = if value.is_a?(Integer)
+        ptr = FFI::MemoryPointer.new(:int)
+        ptr.write_int(value)
+        1
+      elsif value.is_a?(Float)
+        ptr = FFI::MemoryPointer.new(:float)
+        ptr.write_float(value)
+        2
+      else
+        ptr = FFI::MemoryPointer.from_string(value.to_s)
+        3
+      end
+      XlsxExt.setCellValue(self.id, sheet_name, row, col, ptr, typ)
+      ptr.free if ptr
+    end
+  
+    def get_cell_value(sheet_name, row, col)
+      raise "file closed" if self.closed?
+  
+      XlsxExt.getCellValue(self.id, sheet_name, row, col)
+    end
+  
+    def get_rows(sheet_name)
+      raise "file closed" if self.closed?
+  
+      XlsxExt.getRows(self.id, sheet_name).value
+    end
+  
+    def put_row(sheet_name, row_index, row)
+      raise "file closed" if self.closed?
+      
+      # 不需要手动释放
+      str = CStrArray.new
+      str[:s_size] = row.size
+      ptr = FFI::MemoryPointer.new(:pointer, row.size)
+      pps = row.map{|x| FFI::MemoryPointer.from_string(x.to_s) }
+      ptr.write_array_of_pointer(pps)
+      str[:arr] = ptr
+      XlsxExt.putRow(self.id, sheet_name, row_index,str)
+      pps.each(&:free)
+      ptr.free
+    end
+  
+    def put_rows(sheet_name, rows)
+      raise "file closed" if self.closed?
+      #不需要手动释放
+      str2 = CStrArray2.new
+      str2[:s_size] = rows.size
+      ptr2 = FFI::MemoryPointer.new(:pointer, rows.size)
+      todoRelease = [ptr2]
+      
+      ptr2_arr = rows.map do |row|
+        # 不需要手动释放
+        str = CStrArray.new
+        str[:s_size] = row.size
+  
+        ptr = FFI::MemoryPointer.new(:pointer, row.size)
+        todoRelease << ptr
+        sptrs = row.map{|s| FFI::MemoryPointer.from_string(s.to_s)}
+        todoRelease += sptrs
+        ptr.write_array_of_pointer(sptrs)
+        str[:arr] = ptr
+        str.pointer
+      end
+      todoRelease += ptr2_arr
+      ptr2.write_array_of_pointer(ptr2_arr)
+      str2[:arr] = ptr2
+      XlsxExt.putRows(self.id, sheet_name, str2)
+      todoRelease.each(&:free)
+    end
+
+    def merge_cell(sheet_name, start_row, start_col, end_row, end_col)
+      raise "file closed" if self.closed?
+      
+      XlsxExt.mergeCell(self.id, sheet_name, start_row, start_col, end_row, end_col)
+    end
+
+    def unmerge_cell(sheet_name, start_row, start_col, end_row, end_col)
+      raise "file closed" if self.closed?
+      
+      XlsxExt.unMergeCell(self.id, sheet_name, start_row, start_col, end_row, end_col)
+    end
+
+    def get_merge_cells(sheet_name)
+      raise "file closed" if self.closed?
+      XlsxExt.getMergeCells(self.id, sheet_name).values
+    end
+  
+    def save
+      raise "file closed" if self.closed?
+      raise "new file can't save, call save_as" unless has_file
+      XlsxExt.save(self.id)
+      self.closed = true
+    end
+  
+    def save_as(path)
+      raise "file closed" if self.closed?
+      XlsxExt.saveAs(self.id,path)
+      self.closed = true
+    end
+  
+    def close
+      raise "file closed" if self.closed?
+      XlsxExt.closeFile(self.id)
+      self.closed = true
+    end
+  end
+end

data/lib/f_xlsx/lib_c.rb

@@ -0,0 +1,20 @@
+require 'ffi'
+
+module FXlsx
+  module LibC
+    extend FFI::Library
+    ffi_lib FFI::Library::LIBC
+    
+    # memory allocators
+    attach_function :malloc, [:size_t], :pointer
+    attach_function :calloc, [:size_t], :pointer
+    attach_function :valloc, [:size_t], :pointer
+    attach_function :realloc, [:pointer, :size_t], :pointer
+    attach_function :free, [:pointer], :void
+    
+    # memory movers
+    attach_function :memcpy, [:pointer, :pointer, :size_t], :pointer
+    attach_function :bcopy, [:pointer, :pointer, :size_t], :void
+    
+  end # module LibC
+end

data/lib/f_xlsx/version.rb

@@ -0,0 +1,3 @@
+module FXlsx
+  VERSION = "0.2.8"
+end

data/lib/f_xlsx/xlsx_ext.rb

@@ -0,0 +1,44 @@
+LIB_PATH = File.expand_path("../../../ext/excel.#{FFI::Platform::LIBSUFFIX}", __FILE__)
+module FXlsx
+  module XlsxExt
+
+    def self.load_lib
+      return if @lib_loaded
+      @lib_loaded = true
+      extend FFI::Library
+      ffi_lib LIB_PATH
+      attach_function :printStr, [:string], :void
+      
+      attach_function :newFile, [], :uint32
+      attach_function :openFile, [:string], :uint32
+      
+      attach_function :newSheet, [:uint32, :string], :int
+      attach_function :deleteSheet, [:uint32, :string], :void
+      attach_function :setSheetName, [:uint32, :string, :string], :void
+      attach_function :setSheetVisible, [:uint32, :string, :int], :void
+      attach_function :getSheetVisible, [:uint32, :string], :int
+
+      attach_function :getSheetList, [:uint32], CStrArray.ptr
+      attach_function :getSheetName, [:uint32, :int], :string
+
+      attach_function :setCellValue, [:uint32, :string, :int, :int, :pointer, :int], :void
+      attach_function :getCellValue, [:uint32, :string, :int, :int], :string
+
+      attach_function :getRows, [:uint32, :string], CStrArray2.ptr
+      
+      attach_function :putRow, [:uint32, :string, :int, CStrArray.ptr], :void
+      attach_function :putRows, [:uint32, :string, CStrArray2.ptr], :void
+
+
+      attach_function :mergeCell, [:uint32, :string, :int, :int, :int, :int], :void
+      attach_function :unMergeCell, [:uint32, :string, :int, :int, :int, :int], :void
+
+      attach_function :getMergeCells, [:uint32, :string], CCellArray.ptr
+
+      attach_function :save, [:uint32], :void
+      attach_function :saveAs, [:uint32, :string], :void
+
+      attach_function :closeFile, [:uint32], :void
+    end
+  end
+end

data/lib/f_xlsx.rb

@@ -0,0 +1,17 @@
+require "f_xlsx/version"
+require "f_xlsx/lib_c"
+require "f_xlsx/base_types"
+require "f_xlsx/xlsx_ext"
+require "f_xlsx/file"
+
+module FXlsx
+
+  def self.new_file
+    File.new_file
+  end
+
+  def self.open_file(path)
+    File.open_file(path)
+  end
+  
+end

data/test.rb

@@ -0,0 +1,22 @@
+require 'f_xlsx'
+stop = false
+fork do
+  File.open("test.pid","w"){ |f| f.puts(Process.pid)}
+  trap('INT') do
+    puts 'will stop'
+    stop = true
+  end
+  while true do
+    # path2 = "/Users/wangdong/Desktop/3620230626131231产品录入模板.xlsx"
+    path2 = "/Users/wangdong/Desktop/批量搜索产品清单.xlsx"
+    f2 = FXlsx.open_file(path2)
+    # f2.put_row('Sheet1',5,[5,'b','c'])
+    # f2.put_rows('Sheet1',[[2,nil],[1,'b','c']])
+    pp f2.get_merge_cells('使用说明')
+
+    f2.unmerge_cell('使用说明', 0,0, 48, 44)
+    f2.close
+    # f2.save_as(path2)
+    break if stop
+  end
+end