Merge pull request #111 from Jindequan/master

Fill empty cells when write ets

Author: jsonkenl

lib/xlsxir.ex

@@ -129,12 +129,9 @@ defmodule Xlsxir do
   end
 
   defp row_data_to_list(row_data) do
-    # [["A1", 1], ["C1", 2]]
-    row_data
-    # [["A1", 1], ["B1", nil], ["C1", 2]]
-    |> do_get_row()
-    # [1, nil, 2]
-    |> Enum.map(fn [_ref, val] -> val end)
+    # from: [["A1", 1], ["B1", nil], ["C1", 2]]
+    # to: [1, nil, 2]
+    Enum.map(row_data, fn [_ref, val] -> val end)
   end
 
   @doc """
@@ -279,9 +276,7 @@ defmodule Xlsxir do
     :ets.match(tid, {:"$1", :"$2"})
     |> Enum.sort()
     |> Enum.map(fn [_num, row] ->
-      row
-      |> do_get_row()
-      |> Enum.map(fn [_ref, val] -> val end)
+      Enum.map(row, fn [_ref, val] -> val end)
     end)
   end
 
@@ -315,7 +310,6 @@ defmodule Xlsxir do
     :ets.match(tid, {:"$1", :"$2"})
     |> Enum.reduce(%{}, fn [_num, row], acc ->
       row
-      |> do_get_row()
       |> Enum.reduce(%{}, fn [ref, val], acc2 -> Map.put(acc2, ref, val) end)
       |> Enum.into(acc)
     end)
@@ -370,7 +364,6 @@ defmodule Xlsxir do
     add_row =
       h
       |> Enum.at(1)
-      |> do_get_row()
       |> Enum.reduce({%{}, 0}, fn cell, {acc, index} ->
         {Map.put(acc, index, Enum.at(cell, 1)), index + 1}
       end)
@@ -450,70 +443,11 @@ defmodule Xlsxir do
   """
   def get_row(tid, row) do
     case :ets.match(tid, {row, :"$1"}) do
-      [[row]] -> row |> do_get_row() |> Enum.map(fn [_ref, val] -> val end)
+      [[row]] -> row |> Enum.map(fn [_ref, val] -> val end)
       [] -> []
     end
   end
 
-  defp do_get_row(row) do
-    row
-    |> Enum.reduce({[], nil}, fn [ref, val], {values, previous} ->
-      line = ~r/\d+$/ |> Regex.run(ref) |> List.first()
-
-      empty_cells =
-        cond do
-          is_nil(previous) && String.first(ref) != "A" ->
-            fill_empty_cells("A#{line}", ref, line, [])
-
-          !is_nil(previous) && !is_next_col(ref, previous) ->
-            fill_empty_cells(next_col(previous), ref, line, [])
-
-          true ->
-            []
-        end
-
-      {values ++ empty_cells ++ [[ref, val]], ref}
-    end)
-    |> elem(0)
-  end
-
-  defp column_from_index(index, column) when index > 0 do
-    modulo = rem(index - 1, 26)
-    column = [65 + modulo | column]
-    column_from_index(div(index - modulo, 26), column)
-  end
-
-  defp column_from_index(_, column), do: to_string(column)
-
-  defp is_next_col(current, previous) do
-    current == next_col(previous)
-  end
-
-  defp next_col(ref) do
-    [chars, line] = Regex.run(~r/^([A-Z]+)(\d+)/, ref, capture: :all_but_first)
-    chars = chars |> String.to_charlist()
-
-    col_index =
-      Enum.reduce(chars, 0, fn char, acc ->
-        acc = acc * 26
-        acc + char - 65 + 1
-      end)
-
-    "#{column_from_index(col_index + 1, '')}#{line}"
-  end
-
-  defp fill_empty_cells(from, from, _line, cells), do: Enum.reverse(cells)
-
-  defp fill_empty_cells(from, to, line, cells) do
-    next_ref = next_col(from)
-
-    if next_ref == to do
-      fill_empty_cells(to, to, line, [[from, nil] | cells])
-    else
-      fill_empty_cells(next_ref, to, line, [[from, nil] | cells])
-    end
-  end
-
   @doc """
   Accesses `tid` ETS process and returns values of specified column in a `list`.
 
@@ -549,7 +483,6 @@ defmodule Xlsxir do
     |> Enum.sort()
     |> Enum.map(fn [_num, row] ->
       row
-      |> do_get_row()
       |> Enum.filter(fn [ref, _val] -> Regex.scan(~r/[A-Z]+/i, ref) == [[col]] end)
       |> Enum.map(fn [_ref, val] -> val end)
     end)
@@ -624,6 +557,24 @@ defmodule Xlsxir do
     end)
   end
 
+  @doc """
+  Fill every row with `nil` cells at the end.
+  Cells quantity determined by the max length of all rows.
+
+  ## Example
+  Extract first worksheet in an example file named `test.xlsx` located in `./test/test_data`:
+      iex> {:ok, tid} = Xlsxir.extract("./test/test_data/test.xlsx", 10)
+      iex> Xlsxir.set_empty_cells_to_fill_rows(tid)
+      {:ok, tid}
+      iex> Xlsxir.get_row(tid, 1)
+      [1, nil, 1, nil, 1, nil, nil, 1, nil, nil]
+      iex> Xlsxir.get_col(tid, "J")
+      [nil, nil, 1, nil]
+  """
+  def set_empty_cells_to_fill_rows(tid) do
+    Xlsxir.XlsxFile.set_empty_cells_to_fill_rows(tid)
+  end
+
   @doc """
   Deletes ETS process `tid` and returns `:ok` if successful.
 

lib/xlsxir/parse_worksheet.ex

@@ -122,7 +122,7 @@ defmodule Xlsxir.ParseWorksheet do
     unless Enum.empty?(state.row) do
       [[row]] = ~r/\d+/ |> Regex.scan(state.row |> List.first() |> List.first())
       row = row |> String.to_integer()
-      value = state.row |> Enum.reverse()
+      value = state.row |> Enum.reverse() |> fill_nil()
 
       :ets.insert(tid, {row, value})
       if !is_nil(max_rows) and row == max_rows, do: raise(SaxError, state: state)
@@ -133,6 +133,64 @@ defmodule Xlsxir.ParseWorksheet do
 
   def sax_event_handler(_, state, _, _), do: state
 
+  defp fill_nil(rows) do
+    Enum.reduce(rows, {[], nil}, fn [ref, val], {values, previous} ->
+      line = ~r/\d+$/ |> Regex.run(ref) |> List.first()
+
+      empty_cells =
+        cond do
+          is_nil(previous) && String.first(ref) != "A" ->
+            fill_empty_cells("A#{line}", ref, line, [])
+
+          !is_nil(previous) && !is_next_col(ref, previous) ->
+            fill_empty_cells(next_col(previous), ref, line, [])
+
+          true ->
+            []
+        end
+
+      {values ++ empty_cells ++ [[ref, val]], ref}
+    end)
+    |> elem(0)
+  end
+
+  def column_from_index(index, column) when index > 0 do
+    modulo = rem(index - 1, 26)
+    column = [65 + modulo | column]
+    column_from_index(div(index - modulo, 26), column)
+  end
+
+  def column_from_index(_, column), do: to_string(column)
+
+  defp is_next_col(current, previous) do
+    current == next_col(previous)
+  end
+
+  def next_col(ref) do
+    [chars, line] = Regex.run(~r/^([A-Z]+)(\d+)/, ref, capture: :all_but_first)
+    chars = chars |> String.to_charlist()
+
+    col_index =
+      Enum.reduce(chars, 0, fn char, acc ->
+        acc = acc * 26
+        acc + char - 65 + 1
+      end)
+
+    "#{column_from_index(col_index + 1, '')}#{line}"
+  end
+
+  def fill_empty_cells(from, from, _line, cells), do: Enum.reverse(cells)
+
+  def fill_empty_cells(from, to, line, cells) do
+    next_ref = next_col(from)
+
+    if next_ref == to do
+      fill_empty_cells(to, to, line, [[from, nil] | cells])
+    else
+      fill_empty_cells(next_ref, to, line, [[from, nil] | cells])
+    end
+  end
+
   defp format_cell_value(%{shared_strings: strings_tid}, list) do
     case list do
       # Cell with no value attribute

lib/xlsxir/xlsx_file.ex

@@ -95,6 +95,47 @@ defmodule Xlsxir.XlsxFile do
     {:ok, tid}
   end
 
+  @doc """
+  Fill every row with `nil` cells at the end.
+  Cells quantity determined by the max length of all rows.
+  """
+  def set_empty_cells_to_fill_rows(tid) do
+    max_len =
+      :ets.match(tid, {:"$1", :"$2"})
+      |> Enum.map(fn [_num, row] -> Enum.count(row) end)
+      |> Enum.max()
+
+    end_column = Xlsxir.ParseWorksheet.column_from_index(max_len + 1, "")
+
+    first_key = :ets.first(tid)
+    fill_empty_cells_at_end(tid, end_column, first_key)
+  end
+
+  defp fill_empty_cells_at_end(tid, _, :"$end_of_table"), do: {:ok, tid}
+
+  defp fill_empty_cells_at_end(tid, end_column, index) when is_integer(index) do
+    build_and_replace(tid, end_column, index)
+    nex_index= :ets.next(tid, index)
+    fill_empty_cells_at_end(tid, end_column, nex_index)
+  end
+
+  defp fill_empty_cells_at_end(tid, end_column, index) do
+    nex_index = :ets.next(tid, index)
+    fill_empty_cells_at_end(tid, end_column, nex_index)
+  end
+
+  defp build_and_replace(tid, end_column, index) do
+    [{index, cells}] = :ets.lookup(tid, index)
+    [last_ref, _] = List.last(cells)
+    from = Xlsxir.ParseWorksheet.next_col(last_ref)
+    to = end_column <> Integer.to_string(index)
+
+    empty_cells = Xlsxir.ParseWorksheet.fill_empty_cells(from, to, index, [])
+    new_cells = cells ++ empty_cells
+
+    true = :ets.insert(tid, {index,  new_cells})
+  end
+
   @doc """
   Parse all worksheets of the XlsxFile and store their content in ETS tables.
   returns `[{:ok, worksheet_1_table_id}, ..., {:ok, worksheet_n_table_id}]` when `timer` is `false`