axlsx_styler 0.1.5 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: cd31d073d9ff50b0f751553c2623c372ec9a4d1d
-  data.tar.gz: d8c93fe14f0215c0aa0619ebfcb37cc6479f9781
+SHA256:
+  metadata.gz: 6da36a303dacdfc72388437e8e993607859fa1fc35bcf7c7937e73c0f85d71ba
+  data.tar.gz: a234265db298461f325be13515e56eeab110c08671ee976c30c59f57ed8b470e
 SHA512:
-  metadata.gz: e99d3aae264ab742166af6b76fb34d9d2b19d61e2a57cf56d9d35d3102f7a45365da068cc18f16f945082907ec73beece46e9a79808acfb3b290498b07b6efde
-  data.tar.gz: 392fcc8712ce0fc970894f19671324ff327bc8a712a2753be62230ff80f08df12e6501073c7f0521c57b596b144e06b7cfff45ea6e1737f35a99de20c24d84ff
+  metadata.gz: eab70334fc493760f7b4f561067d0d3a447bae22b236cbe78926a6ba87aa4fe4e88ae5b0532582eddc14b2d570100cfa04b0b7e3412ca2626badedb659214063
+  data.tar.gz: d5ea3bf3bdb7c611b1ab988963f8916f575d14309443bf9fedb85872e347fc594cf64adebbea615acf4ffdbf4fac1bfabcc615570cc6ef35713029cb235e1f76

data/CHANGELOG.md

@@ -0,0 +1,23 @@
+# Changelog
+
+- **1.1.0 - August 26, 2020**
+  - [Issue #29](https://github.com/axlsx-styler-gem/axlsx_styler/issues/29) - Fix error `Invalid cellXfs id` when applying `dxf` styles
+  - [PR #28](https://github.com/axlsx-styler-gem/axlsx_styler/pull/28) - Allow passing arrays of cell ranges to the `add_style` and `add_border` methods
+- **1.0.0 - January 5, 2020**
+  - Switch to the `caxlsx` gem (Community Axlsx) from the legacy unmaintained `axlsx` gem. Axlsx has had a long history of being poorly maintained so this community gem improves the situation.
+  - Require Ruby 2.3+
+  - Improve Package and Styles monkey patches using `prepend`
+  - Removed unnecessary module `AxlsxStyler::Axlsx`
+  - Major test suite improvements
+  - Add Rails dummy app to test suite and test with `axlsx_rails`
+- **0.2.0**
+  - Add support for `axlsx` v3 (at this time for v3.0.0.pre).
+  - Update test suite to run against both v2 and v3 of `axlsx`
+- **0.1.7**
+  - Allow mixing vanilla `axlsx` styles and those from `add_style` and `add_border`. See [this example](./examples/mixing_styles.rb)
+- **0.1.5**
+  - Hide `Workbook#apply_styles` method to make it easier to use.
+- **0.1.3**
+  - Make border styles customizable.
+- **0.1.2**
+  - Allow applying multiple style hashes.

data/README.md

@@ -1,32 +1,34 @@
 # axlsx_styler
 
-[axlsx](https://github.com/randym/axlsx) gem is an excellent tool to
-build Excel spreadsheets. The sheets are
-created row-by-row and styles are immediately added to each cell when a
-row is created.
+<a href="https://badge.fury.io/rb/axlsx_styler" target="_blank"><img height="21" style='border:0px;height:21px;' border='0' src="https://badge.fury.io/rb/axlsx_styler.svg" alt="Gem Version"></a>
+<a href='https://travis-ci.org/axlsx-styler-gem/axlsx_styler' target='_blank'><img height='21' style='border:0px;height:21px;' src='https://api.travis-ci.org/axlsx-styler-gem/axlsx_styler.svg?branch=master' border='0' alt='Build Status' /></a>
+<a href='https://rubygems.org/gems/axlsx_styler' target='_blank'><img height='21' style='border:0px;height:21px;' src='https://ruby-gem-downloads-badge.herokuapp.com/axlsx_styler?label=rubygems&type=total&total_label=downloads&color=brightgreen' border='0' alt='RubyGems Downloads' /></a>
 
-`axlsx_styler` allows to separate styles from content: you can fill out
-a spreadsheet with data and apply styles later. Paired with
-[axlsx_rails](https://github.com/straydogstudio/axlsx_rails) this gem
-allows to build clean and maintainable Excel views in a Rails app. It can also
-be used outside of any specific Ruby framework as shown in example below.
+`axlsx_styler` is a gem that allows you to build clean and maintainable styles for your `axlsx` spreadsheets. Build your spreadsheeet with data and then apply styles later.
 
-## Usage
+While [`axlsx`](https://github.com/randym/axlsx) is an excellent tool to build Excel spreadsheets in Ruby, the sheets styles are only applied immediately as the row is created. This makes it very difficult to style easily and effectively.
 
-This gem provides a DSL that allows you to apply styles to ranges of cells, e.g.
+To solve this issue, `axlsx_styler` was born to allow the separation of styles from content within your `axlsx` code. It gives you the ability to fill out a spreadsheet with data and apply styles later. 
+
+Works well in any Rails app or outside of any specific Ruby framework.
+
+# Usage
+
+This gem provides a DSL that allows you to apply styles or borders to ranges of cells.
+
+## Styles
 
 ```ruby
 sheet.add_style 'A1:D10', b: true, sz: 14
 ```
 
-The styles can be overlayed, so that later on you can add another style
-to cells that already have styles, e.g.
+The styles can be overlayed, so that later on you can add another style to cells that already have styles.
 
 ```ruby
 sheet.add_style 'A1:D1', bg_color: 'FF0000'
 ```
 
-Applying multiple styles as a sequence of Ruby hashes is also possible:
+Applying multiple styles as a sequence of Ruby hashes is also possible.
 
 ```ruby
 bold     = { b: true }
@@ -34,25 +36,41 @@ centered = { alignment: { horizontal: :center } }
 sheet.add_style 'A2:D2', bold, centered
 ```
 
-You can also add borders to ranges of cells:
+Applying a style to multiple ranges at once.
+
+```ruby
+sheet.add_style ['A2:G2', "A8:G8", "A12:G12"], b: true, sz: 14
+```
+
+## Borders
+
+The border style is to draw a thin black border on all four edges of the selected cell range.
 
 ```ruby
 sheet.add_border 'B2:D5'
+```
+
+You can easily customize the border styles.
+
+```ruby
 sheet.add_border 'B2:D5', [:bottom, :right]
 sheet.add_border 'B2:D5', { edges: [:bottom, :right], style: :thick, color: 'FF0000' }
 ```
 
-Border parameters are optional. The default is to draw a thin black border on all four edges of the selected cell range.
+Applying border to multiple ranges at once.
+
+```ruby
+sheet.add_border ['A2:G2', "A8:G8", "A12:G12"]
+```
 
 
-### Example
+## Example
 
 Suppose we want create the following spreadsheet:
 
 ![alt text](./spreadsheet.png "Sample Spreadsheet")
 
-You can apply styles after all data is entered, similar to how you'd create
-an Excel document by hand:
+You can apply styles after all data is entered, similar to how you'd create an Excel document by hand.
 
 ```ruby
 require 'axlsx_styler'
@@ -79,13 +97,19 @@ end
 axlsx.serialize 'grocery.xlsx'
 ```
 
-Producing the same spreadsheet with vanilla `axlsx` turns out [a bit trickier](./examples/vanilla_axlsx.md).
+If you try creating this same spreadsheet using only `axlsx`, you will find this is much more difficult. See this [See this example](./examples/vanilla_axlsx.md)
+
+For more examples, please see the [examples folder](./examples/)
+
+# Contributing
+
+We use the `appraisal` gem for testing multiple versions of `axlsx`. Please use the following steps to test using `appraisal`.
+
+1. `bundle exec appraisal install`
+2. `bundle exec appraisal rake test`
 
+# Credits
 
-## Change log
+Created by Anton Sakovich - @sakovias
 
-Version | Change
---------|-------
-0.1.5 | Hide `Workbook#apply_styles` method to make it easier to use.
-0.1.3 | Make border styles customazible.
-0.1.2 | Allow applying multiple style hashes.
+Maintained by Weston Ganger - @westonganger - Uses `axlsx_styler` within the gem,  [`spreadsheet_architect`](https://github.com/westonganger/spreadsheet_architect)

data/Rakefile

@@ -1,7 +1,21 @@
 require "bundler/gem_tasks"
-require 'rake/testtask'
 
-Rake::TestTask.new do |t|
-  t.libs << 'test'
-  t.pattern = "test/*_test.rb"
+task :test do 
+  require 'rake/testtask'
+
+  Rake::TestTask.new(:test) do |t|
+    t.libs << 'lib'
+    t.libs << 'test'
+    t.pattern = 'test/**/*_test.rb'
+    t.verbose = false
+  end
+end
+
+task default: :test
+
+task :console do
+  require 'axlsx_styler'
+
+  require 'irb'
+  binding.irb
 end

data/lib/axlsx_styler.rb

@@ -1,31 +1,12 @@
 require 'axlsx'
-
 require 'axlsx_styler/version'
+
+require 'axlsx_styler/axlsx_package'
+require 'axlsx_styler/axlsx_styles'
 require 'axlsx_styler/axlsx_workbook'
 require 'axlsx_styler/axlsx_worksheet'
 require 'axlsx_styler/axlsx_cell'
 
-Axlsx::Workbook.send :include, AxlsxStyler::Axlsx::Workbook
-Axlsx::Worksheet.send :include, AxlsxStyler::Axlsx::Worksheet
-Axlsx::Cell.send :include, AxlsxStyler::Axlsx::Cell
-
-module Axlsx
-  class Package
-
-    # Patches the original Axlsx::Package#serialize method so that styles are
-    # applied when the workbook is saved
-    original_serialize = instance_method(:serialize)
-    define_method :serialize do |*args|
-      workbook.apply_styles if !workbook.styles_applied
-      original_serialize.bind(self).(*args)
-    end
+module AxlsxStyler
 
-    # Patches the original Axlsx::Package#to_stream method so that styles are
-    # applied when the workbook is converted to StringIO
-    original_to_stream = instance_method(:to_stream)
-    define_method :to_stream do |*args|
-      workbook.apply_styles if !workbook.styles_applied
-      original_to_stream.bind(self).(*args)
-    end
-  end
 end

data/lib/axlsx_styler/axlsx_cell.rb

@@ -1,42 +1,44 @@
 require 'active_support/core_ext/hash/deep_merge'
 
 module AxlsxStyler
-  module Axlsx
-    module Cell
-      attr_accessor :raw_style
-
-      def add_style(style)
-        self.raw_style ||= {}
-        add_to_raw_style(style)
-        workbook.add_styled_cell self
-      end
+  module Cell
+    attr_accessor :raw_style
 
-      private
+    def add_style(style)
+      self.raw_style ||= {}
+      add_to_raw_style(style)
+      workbook.add_styled_cell self
+    end
 
-      def workbook
-        row.worksheet.workbook
-      end
+    private
 
-      def add_to_raw_style(style)
-        # using deep_merge from active_support:
-        # with regular Hash#merge adding borders fails miserably
-        new_style = raw_style.deep_merge style
-        if with_border?(raw_style) && with_border?(style)
-          border_at = (raw_style[:border][:edges] || all_edges) + (style[:border][:edges] || all_edges)
-          new_style[:border][:edges] = border_at.uniq.sort
-        elsif with_border?(style)
-          new_style[:border] = style[:border]
-        end
-        self.raw_style = new_style
-      end
+    def workbook
+      row.worksheet.workbook
+    end
 
-      def with_border?(style)
-        !style[:border].nil?
-      end
+    def add_to_raw_style(style)
+      # using deep_merge from active_support:
+      # with regular Hash#merge adding borders fails miserably
+      new_style = raw_style.deep_merge style
 
-      def all_edges
-        [:top, :right, :bottom, :left]
+      if with_border?(raw_style) && with_border?(style)
+        border_at = (raw_style[:border][:edges] || all_edges) + (style[:border][:edges] || all_edges)
+        new_style[:border][:edges] = border_at.uniq.sort
+      elsif with_border?(style)
+        new_style[:border] = style[:border]
       end
+
+      self.raw_style = new_style
+    end
+
+    def with_border?(style)
+      !style[:border].nil?
+    end
+
+    def all_edges
+      [:top, :right, :bottom, :left]
     end
   end
 end
+
+Axlsx::Cell.send(:include, AxlsxStyler::Cell)

data/lib/axlsx_styler/axlsx_package.rb

@@ -0,0 +1,17 @@
+module AxlsxStyler
+  module Package
+
+    def serialize(*args)
+      workbook.apply_styles if !workbook.styles_applied
+      super
+    end
+
+    def to_stream(*args)
+      workbook.apply_styles if !workbook.styles_applied
+      super
+    end
+
+  end
+end
+
+Axlsx::Package.send(:prepend, AxlsxStyler::Package)

data/lib/axlsx_styler/axlsx_styles.rb

@@ -0,0 +1,36 @@
+module AxlsxStyler
+  module Styles
+
+    # An index for cell styles where keys are styles codes as per Axlsx::Style and values are Cell#raw_style
+    # The reason for the backward key/value ordering is that style lookup must be most efficient, while `add_style` can be less efficient
+    def style_index
+      @style_index ||= {}
+    end
+
+    # Ensure plain axlsx styles are added to the axlsx_styler style_index cache
+    def add_style(options={})
+      if options[:type] == :dxf
+        style_id = super
+      else
+        raw_style = {type: :xf, name: 'Arial', sz: 11, family: 1}.merge(options)
+
+        if raw_style[:format_code]
+          raw_style.delete(:num_fmt)
+        end
+
+        style_id = style_index.key(raw_style)
+
+        if !style_id
+          style_id = super 
+
+          style_index[style_id] = raw_style
+        end
+      end
+
+      return style_id
+    end
+
+  end
+end
+
+Axlsx::Styles.send(:prepend, AxlsxStyler::Styles)

data/lib/axlsx_styler/axlsx_workbook.rb

@@ -1,56 +1,39 @@
 require 'set'
+require 'active_support/core_ext/hash/deep_merge'
 
 module AxlsxStyler
-  module Axlsx
-    module Workbook
-      # An array that holds all cells with styles
-      attr_accessor :styled_cells
-
-      # Checks if styles are idexed to make it work for pre 0.1.5 version
-      # users that still explicitly call @workbook.apply_styles
-      attr_accessor :styles_applied
-
-      # An index for cell styles
-      #   {
-      #     1 => < style_hash >,
-      #     2 => < style_hash >,
-      #     ...
-      #     K => < style_hash >
-      #   }
-      # where keys are Cell#raw_style and values are styles
-      # codes as per Axlsx::Style
-      attr_accessor :style_index
-
-      def add_styled_cell(cell)
-        self.styled_cells ||= Set.new
-        self.styled_cells << cell
-      end
+  module Workbook
+    # An array that holds all cells with styles
+    attr_accessor :styled_cells
 
-      def apply_styles
-        return unless styled_cells
-        styled_cells.each do |cell|
-          set_style_index(cell)
-        end
-        self.styles_applied = true
-      end
+    # Checks if styles are indexed to make it work for pre 0.1.5 version
+    # users that still explicitly call @workbook.apply_styles
+    attr_accessor :styles_applied
+
+    def add_styled_cell(cell)
+      self.styled_cells ||= Set.new
+      self.styled_cells << cell
+    end
 
-      private
+    def apply_styles
+      return unless styled_cells
 
-      # Check if style code
-      def set_style_index(cell)
-        self.style_index ||= {}
+      styled_cells.each do |cell|
+        current_style = styles.style_index[cell.style]
 
-        index_item = style_index.select { |_, v| v == cell.raw_style }.first
-        if index_item
-          cell.style = index_item.first
+        if current_style
+          new_style = current_style.deep_merge(cell.raw_style)
         else
-          old_style = cell.raw_style.dup
-          new_style = styles.add_style(cell.raw_style)
-          cell.style = new_style
-          # cell.raw_style.delete(:num_fmt)
-          style_index[new_style] = old_style
+          new_style = cell.raw_style
         end
+
+        cell.style = styles.add_style(new_style)
       end
+
+      self.styles_applied = true
     end
+
   end
 end
+
+Axlsx::Workbook.send(:include, AxlsxStyler::Workbook)

data/lib/axlsx_styler/axlsx_worksheet.rb

@@ -1,35 +1,52 @@
 require_relative './border_creator'
 
 module AxlsxStyler
-  module Axlsx
-    module Worksheet
-      # Example to add a single style:
-      #   add_style 'A1:B5', b: true, sz: 14
-      #
-      # Example to add multiple styles:
-      #   bold = { b: true }
-      #   large_text = { sz: 30 }
-      #   add_style 'B2:F8', bold, large_text
-      def add_style(cell_ref, *styles)
+  module Worksheet
+    # Example to add a single style:
+    #   add_style 'A1:B5', b: false
+    #   add_style ['B1', 'B3'], b: false
+    #   add_style ['D3:D4', 'F2:F6'], b: false 
+    #
+    # Example to add multiple styles:
+    #   bold = { b: true }
+    #   large_text = { sz: 30 }
+    #   add_style 'B2:F8', bold, large_text
+    def add_style(cell_refs, *styles)
+      if !cell_refs.is_a?(Array)
+        cell_refs = [cell_refs]
+      end
+
+      cell_refs.each do |cell_ref|
         item = self[cell_ref]
+
         cells = item.is_a?(Array) ? item : [item]
+
         cells.each do |cell|
           styles.each do |style|
             cell.add_style(style)
           end
         end
       end
+    end
+
+    # Examples:
+    #   add_border 'B2:F8', [:left, :top], :medium, '00330f'
+    #   add_border 'B2:F8', [:left, :top], :medium
+    #   add_border 'C2:G10', [:top]
+    #   add_border 'C2:G10'
+    #   add_border 'B2:D5', { style: :thick, color: '00330f', edges: [:left, :right] }
+    #   add_border ['D3:D4', 'F2:F6'], [:left]
+    def add_border(cell_refs, args = :all)
+      if !cell_refs.is_a?(Array)
+        cell_refs = [cell_refs]
+      end
 
-      # Examples:
-      #   add_border 'B2:F8', [:left, :top], :medium, '00330f'
-      #   add_border 'B2:F8', [:left, :top], :medium
-      #   add_border 'C2:G10', [:top]
-      #   add_border 'C2:G10'
-      #   add_border 'B2:D5', { style: :thick, color: '00330f', edges: [:left, :right] }
-      def add_border(cell_ref, args = :all)
+      cell_refs.each do |cell_ref|
         cells = self[cell_ref]
         BorderCreator.new(self, cells, args).draw
       end
     end
   end
 end
+
+Axlsx::Worksheet.send(:include, AxlsxStyler::Worksheet)