heatmap-builder 0.1.0 → 0.4.3

data/README.md

@@ -1,17 +1,22 @@
 # HeatmapBuilder
 
-A Ruby gem that generates embeddable SVG heatmap visualizations with GitHub-style calendar layouts and linear progress indicators. Perfect for Rails applications and any project that needs to display activity data in a visual format.
+A Ruby gem that generates embeddable SVG heatmap visualizations with GitHub-style calendar layouts. Perfect for Rails applications and any project that needs to display activity data in a visual format.
 
 ![GitHub-style Calendar](examples/calendar_github_style.svg)
 
 ## Features
 
 - GitHub-style calendar layouts for date-based data.
-- Linear heatmaps.
+- Vector-based output (SVG) for crisp rendering at any resolution.
+- Optional numeric values displayed in each cell.
+- **Use pre-calculated scores or raw numeric values** - automatic mapping to color scales.
+- Custom value-to-score conversion functions for advanced scoring logic.
 - Parametric everything: customize cell size, spacing, colors, fonts, etc.
-- Shows numeric values in each cell.
+- Rounded corners (and circular cells, if you're into that kind of thing).
+- Dynamic palette generation from two colors or manually-specified colors.
+- OKLCH color interpolation for clean color transitions and perceptual uniformity.
+- Tooltip support with native browser fallback and JS library integration hooks.
 - **Zero dependencies.**
-- Responsive: SVG format scales perfectly at any size
 
 ## Installation
 
@@ -31,90 +36,358 @@ Or install it yourself as:
 
 ## Usage
 
-### Linear Heatmaps
+### Calendar Heatmaps
 
 ```ruby
-require 'heatmap-builder'
+# GitHub-style calendar heatmap
+scores_by_date = {
+  '2026-01-01' => 2,
+  '2026-01-02' => 4,
+  '2026-01-03' => 1,
+  # ... more dates
+}
+
+svg = HeatmapBuilder.build_calendar(scores: scores_by_date)
+```
+
+![GitHub-style Calendar](examples/calendar_github_style.svg)
+
+### Calendar Heatmap Options
+
+You must provide either `scores:` or `values:` (but not both). All other options are optional keyword arguments with sensible defaults.
+
+**Data options:**
+
+- `scores` - Hash of pre-calculated scores by date (integers from 0 to number of colors minus 1). Keys can be Date objects or date strings (e.g., `'2024-01-01'`). Required if `values` is not provided.
+- `values` - Hash of arbitrary numeric values by date to be automatically mapped to scores. Keys can be Date objects or date strings. Required if `scores` is not provided. See [Using Raw Values Instead of Scores](#using-raw-values-instead-of-scores).
+
+**Value-to-score conversion options** (only used with `values:`):
+
+- `value_min` - Minimum boundary for value-to-score mapping. Defaults to the minimum value in your data.
+- `value_max` - Maximum boundary for value-to-score mapping. Defaults to the maximum value in your data.
+- `value_to_score` - Custom callable for value-to-score conversion. Receives `value:`, `date:`, `min:`, `max:`, `max_score:` parameters and must return an integer between 0 and `max_score`. See [Custom Scoring Logic](#custom-scoring-logic) for details.
 
-# Generate SVG for daily scores
-scores = [0, 1, 2, 3, 4, 5, 2, 1]
-svg = HeatmapBuilder.generate(scores)
+**Appearance options:**
+
+- `cell_size` - Size of each square in pixels. Defaults to 12.
+- `cell_spacing` - Space between squares in pixels. Defaults to 1.
+- `font_size` - Font size for labels in pixels. Defaults to 8.
+- `border_width` - Border width around each cell in pixels. Defaults to 1.
+- `border_lightness_factor` - Controls the border color, derived from each cell's color by scaling its lightness (in OKLCH) by this factor. Values below 1 produce a darker border; a value of 1 makes the border match the cell color, in which case the border is omitted entirely. Must be positive. Defaults to 0.9.
+- `corner_radius` - Corner radius for rounded cells. Must be between 0 (square corners) and `floor(cell_size/2)` (circular cells). Values outside this range are automatically clamped. Defaults to 0.
+
+**Color options:**
+
+- `colors` - Color palette for the heatmap. Can be a predefined palette constant (e.g., `HeatmapBuilder::Calendar::GITHUB_GREEN`), an array of hex color strings (e.g., `%w[#ebedf0 #9be9a8 #40c463]`), or a hash for OKLCH interpolation (e.g., `{ from: "#ebedf0", to: "#216e39", steps: 5 }`). Defaults to `HeatmapBuilder::Calendar::GITHUB_GREEN`. See [Predefined Color Palettes](#predefined-color-palettes) and [Dynamic Palettes Generation](#dynamic-palettes-generation).
+
+**Calendar-specific options:**
+
+- `start_of_week` - First day of the week. One of `:sunday`, `:monday`, `:tuesday`, `:wednesday`, `:thursday`, `:friday`, `:saturday`. Defaults to `:monday`.
+- `month_spacing` - Extra horizontal space between months in pixels. Defaults to 0.
+- `show_month_labels` - Show month names at the top of the calendar. Defaults to `true`.
+- `show_day_labels` - Show day abbreviations on the left side of the calendar. Defaults to `true`.
+- `show_outside_cells` - Show cells outside the date range with inactive styling. Defaults to `false`.
+
+**Tooltip options:**
+
+- `tooltip` - Callable invoked per active cell with `date:`, `score:`, and `value:` keyword arguments. Return value is used as the tooltip text. Emits a native SVG `<title>` element (browser fallback) and a data attribute (JS library hook). Defaults to `nil` (no tooltip markup).
+- `tooltip_attribute` - Name of the `data-*` attribute written on each cell's `<g>` wrapper for JS tooltip library pickup. Defaults to `"data-tooltip"`. Set to `nil` to suppress the data attribute and use only the native `<title>` fallback. See [Tooltips](#tooltips).
+
+**Internationalization options:**
+
+- `day_labels` - Array of day abbreviations starting from Sunday (7 elements). Defaults to `%w[S M T W T F S]`. See [I18n](#i18n).
+- `month_labels` - Array of month abbreviations from January to December (12 elements). Defaults to `%w[Jan Feb Mar Apr May Jun Jul Aug Sep Oct Nov Dec]`. See [I18n](#i18n).
+
+### Using Raw Values Instead of Scores
+
+A **score** is an integer (0 to N-1) that maps directly to a color in your palette. For example, with 5 colors, valid scores are 0-4.
+
+Instead of pre-calculating scores, you can provide raw numeric values (like 45.2, 78, 1000) and let the builder automatically map them to scores using linear distribution:
+
+```ruby
+# Calendar heatmap with automatic score calculation
+values_by_date = {
+  Date.new(2026, 1, 1) => 45.2,
+  Date.new(2026, 1, 2) => 78.5,
+  Date.new(2026, 1, 3) => 12.0
+}
 
-# In a Rails view
-<%= raw HeatmapBuilder.generate(@daily_scores) %>
+svg = HeatmapBuilder.build_calendar(
+  values: values_by_date,
+  value_min: 0,
+  value_max: 100
+)
 ```
 
-![Weekly Progress](examples/weekly_progress.svg)
+The builder will automatically:
+- Calculate min/max boundaries from your data if not specified
+- Map values to color scores using linear distribution
+- Clamp values outside the boundaries
+- Handle nil values by treating them as the minimum boundary
 
-### Calendar Heatmaps
+### Custom Scoring Logic
+
+By default, values are mapped to scores using linear distribution. You can provide a custom value-to-score conversion function for different behaviors like logarithmic scales, exponential curves, or custom thresholds.
+
+The callable receives these parameters:
+- `value:` - The current value being converted
+- `date:` - The date for the data point
+- `min:` - The minimum boundary value
+- `max:` - The maximum boundary value
+- `max_score:` - The maximum valid score (color palette length minus 1)
+
+The function must return an integer between 0 and `max_score`.
+
+Custom scoring logic - logarithmic scale for data with wide range (e.g., 1 to 10000):
 
 ```ruby
-# GitHub-style calendar heatmap
-scores_by_date = {
-  '2024-01-01' => 2,
-  '2024-01-02' => 4,
-  '2024-01-03' => 1,
-  # ... more dates
+logarithmic_formula = ->(value:, date:, min:, max:, max_score:) {
+  return 0 if value <= 0 || min <= 0
+
+  log_value = Math.log10(value)
+  log_min = Math.log10(min)
+  log_max = Math.log10(max)
+
+  ((log_value - log_min) / (log_max - log_min) * max_score).round.clamp(0, max_score)
 }
 
-svg = HeatmapBuilder.generate_calendar(scores_by_date)
+svg = HeatmapBuilder.build_calendar(
+  values: values_by_date,
+  value_to_score: logarithmic_formula
+)
+```
+
+### Predefined Color Palettes
+
+#### GitHub Green (Default)
+
+```ruby
+HeatmapBuilder.build_calendar(scores: calendar_data, colors: HeatmapBuilder::Calendar::GITHUB_GREEN)
+```
+
+![Default Calendar](examples/calendar_default.svg)
+
+#### Blue Ocean
+
+```ruby
+HeatmapBuilder.build_calendar(scores: calendar_data, colors: HeatmapBuilder::Calendar::BLUE_OCEAN)
+```
+
+![Blue Ocean Calendar](examples/calendar_blue_ocean.svg)
+
+#### Warm Sunset
+
+```ruby
+HeatmapBuilder.build_calendar(scores: calendar_data, colors: HeatmapBuilder::Calendar::WARM_SUNSET)
+```
+
+![Warm Sunset Calendar](examples/calendar_warm_sunset.svg)
+
+#### Purple Vibes
+
+```ruby
+HeatmapBuilder.build_calendar(scores: calendar_data, colors: HeatmapBuilder::Calendar::PURPLE_VIBES)
+```
+
+![Purple Vibes Calendar](examples/calendar_purple_vibes.svg)
+
+#### Red to Green
+
+```ruby
+HeatmapBuilder.build_calendar(scores: calendar_data, colors: HeatmapBuilder::Calendar::RED_TO_GREEN)
 ```
 
-### Custom Configuration
+![Red to Green Calendar](examples/calendar_red_to_green.svg)
+
+### Dynamic Palettes Generation
+
+Generate custom color palettes from any two colors using OKLCH color space for superior color interpolation:
 
 ```ruby
-# Customize linear heatmap appearance
-options = {
-  cell_size: 35,           # Size of each square (default: 20)
-  cell_spacing: 1,         # Space between squares (default: 2)
-  font_size: 20,           # Font size for score text (default: 12)
-  colors: %w[              # Custom color palette (default: GitHub-style)
-    #f0f0f0
-    #c6e48b
-    #7bc96f
-    #239a3b
-    #196127
-  ]
+# Generate a 5-step palette from electric cyan to hot magenta
+neon_gradient = {
+  from: "#00FFFF",
+  to: "#FF1493",
+  steps: 5
 }
 
-svg = HeatmapBuilder.generate([1, 2, 3, 4, 5, 6, 7], options)
+svg = HeatmapBuilder.build_calendar(scores: calendar_data, colors: neon_gradient)
+```
+
+The OKLCH color space ensures perceptually uniform color transitions, making gradients appear smooth and natural to the human eye.
+
+### Cell Borders
+
+Each cell has a border whose color is derived from the cell's own color. The `border_width` option sets its thickness, and `border_lightness_factor` controls its shade: the cell color's OKLCH lightness is multiplied by this factor, so values below `1` produce a darker border (the default `0.9` is a subtle darkening).
+
+Setting `border_lightness_factor` to `1` keeps the border color identical to the cell color. In that case the border is invisible, so it is omitted from the SVG entirely.
+
+```ruby
+HeatmapBuilder.build_calendar(
+  scores: calendar_data,
+  border_width: 1,
+  border_lightness_factor: 0.7
+)
+```
+
+![Calendar with Cell Borders](examples/calendar_cell_borders.svg)
+
+With `border_lightness_factor` set to `1`, the border is omitted entirely, leaving cells edge to edge:
+
+```ruby
+HeatmapBuilder.build_calendar(
+  scores: calendar_data,
+  border_width: 1,
+  border_lightness_factor: 1
+)
 ```
 
-![Large Cells](examples/large_cells.svg)
+![Calendar with No Cell Borders](examples/calendar_no_borders.svg)
+
+### Rounded Corners
+
+Calendar heatmaps support rounded corners using the `corner_radius` option.
+
+The `corner_radius` value must be between 0 (square corners) and `floor(cell_size/2)`. Values outside this range are automatically clamped to the valid range (negative values become 0, values exceeding the maximum become `floor(cell_size/2)`).
+
+A typical value is around 2 pixels for a subtle rounded effect:
 
 ```ruby
-# Calendar heatmap options
-calendar_options = {
+# Calendar heatmap with rounded corners
+HeatmapBuilder.build_calendar(
+  scores: calendar_data,
+  corner_radius: 2,
+  cell_size: 14
+)
+```
+
+![Calendar Rounded Corners](examples/calendar_rounded_corners.svg)
+
+Maximum radius values render circular cells:
+
+```ruby
+# Calendar heatmap with max radius rounded corners - circular cells
+HeatmapBuilder.build_calendar(
+  scores: calendar_data,
+  corner_radius: 7,
+  cell_size: 14
+)
+```
+
+![Calendar Rounded Corners](examples/calendar_rounded_corners_max_radius.svg)
+
+### Month Spacing
+
+Add visual separation between months using the `month_spacing` option. This adds horizontal gaps at month boundaries, making it easier to distinguish individual months:
+
+```ruby
+HeatmapBuilder.build_calendar(
+  scores: calendar_data,
   cell_size: 14,
-  start_of_week: :sunday,    # :monday (default) or :sunday
-  show_outside_cells: true   # Show cells outside date range
-}
+  month_spacing: 10,
+  corner_radius: 3
+)
+```
+
+![Calendar with Month Spacing](examples/calendar_month_spacing_rounded.svg)
 
-svg = HeatmapBuilder.generate_calendar(scores_by_date, calendar_options)
+### Tooltips
+
+The `tooltip:` option accepts a callable that is invoked once per active cell. It receives `date:`, `score:`, and `value:` keyword arguments and should return the tooltip text string. `value:` is the original input value when `values:` mode is used, and `nil` when `scores:` mode is used.
+
+```ruby
+HeatmapBuilder.build_calendar(
+  scores: calendar_data,
+  tooltip: ->(date:, score:, value: nil) { "#{date.strftime('%b %-d')}: #{score} contributions" }
+)
 ```
 
-![Calendar with Sunday Start](examples/calendar_sunday_start.svg)
+When `tooltip:` is set, each active cell is wrapped in an SVG `<g>` element containing a `<title>` child. The `<title>` element is the standard SVG mechanism for native browser tooltips — it works out of the box in any browser that renders inline SVG, with no JavaScript required.
 
-### Color Mapping
+```xml
+<g data-tooltip="Jan 15: 4 contributions">
+  <title>Jan 15: 4 contributions</title>
+  <rect fill="#40c463" .../>
+</g>
+```
+
+The `tooltip_attribute:` option (default: `"data-tooltip"`) controls which `data-*` attribute is emitted on the `<g>` wrapper. This attribute is the hook for any JS tooltip library:
+
+```js
+// Tippy.js — one line of initialization
+tippy('[data-tooltip]', { content: el => el.dataset.tooltip })
+```
 
-- Score `0`: Uses the first color (typically light gray)
-- Score `1+`: Cycles through remaining colors based on score value
-- Higher scores automatically map to available colors in the palette
+Set `tooltip_attribute: nil` to suppress the data attribute and rely solely on the native `<title>` fallback. Use any other attribute name to match your tooltip library's expected selector:
+
+```ruby
+# Matches data-tippy-content used by some Tippy.js configurations
+HeatmapBuilder.build_calendar(
+  scores: calendar_data,
+  tooltip: ->(date:, score:, value: nil) { "#{date}: #{score}" },
+  tooltip_attribute: "data-tippy-content"
+)
+```
+
+Outside cells rendered via `show_outside_cells: true` never receive tooltip markup.
+
+### I18n
+
+Calendar heatmaps support internationalization by customizing the `day_labels` and `month_labels` options:
+
+```ruby
+# French calendar
+HeatmapBuilder.build_calendar(
+  scores: calendar_data,
+  day_labels: %w[D L M M J V S],  # Dimanche, Lundi, Mardi, etc.
+  month_labels: %w[Jan Fév Mar Avr Mai Jun Jul Aoû Sep Oct Nov Déc]
+)
+
+# German calendar
+HeatmapBuilder.build_calendar(
+  scores: calendar_data,
+  day_labels: %w[S M D M D F S],  # Sonntag, Montag, Dienstag, etc.
+  month_labels: %w[Jan Feb Mär Apr Mai Jun Jul Aug Sep Okt Nov Dez]
+)
+
+# Italian calendar
+HeatmapBuilder.build_calendar(
+  scores: calendar_data,
+  day_labels: %w[D L M M G V S],  # Domenica, Lunedì, Martedì, etc.
+  month_labels: %w[Gen Feb Mar Apr Mag Giu Lug Ago Set Ott Nov Dic]
+)
+
+# Spanish calendar
+HeatmapBuilder.build_calendar(
+  scores: calendar_data,
+  day_labels: %w[D L M X J V S],  # Domingo, Lunes, Martes, etc.
+  month_labels: %w[Ene Feb Mar Abr May Jun Jul Ago Sep Oct Nov Dic]
+)
+```
+
+The `day_labels` array should contain 7 elements starting from Sunday, and `month_labels` should contain 12 elements for January through December.
 
 ## Development
 
-After checking out the repo, run `bin/setup` to install dependencies. Run tests with:
+After checking out the repo, run `bin/setup` to install development dependencies.
+
+### Running Tests
 
 ```bash
-ruby -Ilib:test test/heatmap_builder_test.rb
-```
+# Run all tests
+rake test
+
+# Run tests with code linting
+rake
 
-To install this gem onto your local machine, run `bundle exec rake install`.
+# Update test snapshots after making intentional changes to output
+rake update_snapshots
+```
 
 To generate all example SVG files you see in this readme:
 
 ```bash
-ruby examples/generate_samples.rb
+bin/generate_examples
 ```
 
 ## Contributing
@@ -127,4 +400,4 @@ The gem is available as open source under the terms of the [MIT License](https:/
 
 ## Code of Conduct
 
-Everyone interacting in the HeatmapBuilder project's codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/dreikanter/heatmap-builder/blob/master/CODE_OF_CONDUCT.md).
+Everyone interacting in the HeatmapBuilder project's codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/dreikanter/heatmap-builder/blob/main/CODE_OF_CONDUCT.md).

data/Rakefile

@@ -13,4 +13,19 @@ rescue LoadError
   # standard is not available
 end
 
+desc "Update test snapshots"
+task :update_snapshots do
+  require "fileutils"
+  snapshots_dir = File.expand_path("test/snapshots", __dir__)
+
+  if Dir.exist?(snapshots_dir)
+    puts "Removing existing snapshots..."
+    FileUtils.rm_rf(Dir["#{snapshots_dir}/*"])
+  end
+
+  puts "Regenerating snapshots..."
+  ENV["UPDATE_SNAPSHOTS"] = "1"
+  Rake::Task[:test].invoke
+end
+
 task default: [:standard, :test]

data/bin/generate_examples

@@ -0,0 +1,177 @@
+#!/usr/bin/env ruby
+
+require "date"
+$LOAD_PATH.unshift File.expand_path("../lib", __dir__)
+require "heatmap-builder"
+
+EXAMPLES_DIR = File.expand_path("../examples", __dir__)
+
+def example_path(filename)
+  File.join(EXAMPLES_DIR, filename)
+end
+
+def generate_example(filename, description, force: false, &block)
+  puts "Generating #{description}..."
+
+  filepath = example_path(filename)
+  puts File.basename(filepath)
+
+  if File.exist?(filepath) && !force
+    puts "skipped - already exists"
+  else
+    svg = block.call
+    File.write(filepath, svg)
+    puts "created"
+  end
+
+  puts
+end
+
+def generate_sample_svgs(force: false)
+  Dir.mkdir(EXAMPLES_DIR) unless Dir.exist?(EXAMPLES_DIR)
+
+  calendar_data = sample_calendar_data
+
+  generate_example("calendar_github_style.svg", "GitHub-style calendar", force: force) do
+    HeatmapBuilder.build_calendar(
+      values: calendar_data,
+      cell_size: 14,
+      month_spacing: 0
+    )
+  end
+
+  generate_example("calendar_default.svg", "default colors calendar", force: force) do
+    HeatmapBuilder.build_calendar(
+      values: calendar_data,
+      cell_size: 14,
+      month_spacing: 0
+    )
+  end
+
+  generate_example("calendar_blue_ocean.svg", "calendar with Blue Ocean palette", force: force) do
+    HeatmapBuilder.build_calendar(
+      values: calendar_data,
+      colors: HeatmapBuilder::Calendar::BLUE_OCEAN,
+      cell_size: 14,
+      month_spacing: 0
+    )
+  end
+
+  generate_example("calendar_warm_sunset.svg", "calendar with Warm Sunset palette", force: force) do
+    HeatmapBuilder.build_calendar(
+      values: calendar_data,
+      colors: HeatmapBuilder::Calendar::WARM_SUNSET,
+      cell_size: 14,
+      month_spacing: 0
+    )
+  end
+
+  generate_example("calendar_purple_vibes.svg", "calendar with Purple Vibes palette", force: force) do
+    HeatmapBuilder.build_calendar(
+      values: calendar_data,
+      colors: HeatmapBuilder::Calendar::PURPLE_VIBES,
+      cell_size: 14,
+      month_spacing: 0
+    )
+  end
+
+  generate_example("calendar_red_to_green.svg", "calendar with Red to Green palette", force: force) do
+    HeatmapBuilder.build_calendar(
+      values: calendar_data,
+      colors: HeatmapBuilder::Calendar::RED_TO_GREEN,
+      cell_size: 14,
+      month_spacing: 0
+    )
+  end
+
+  generate_example("calendar_sunday_start.svg", "calendar with Sunday start", force: force) do
+    HeatmapBuilder.build_calendar(
+      values: calendar_data,
+      cell_size: 14,
+      start_of_week: :sunday,
+      month_spacing: 0
+    )
+  end
+
+  generate_example("calendar_with_outside_cells.svg", "calendar with outside cells", force: force) do
+    HeatmapBuilder.build_calendar(
+      values: calendar_data,
+      cell_size: 14,
+      show_outside_cells: true,
+      month_spacing: 0
+    )
+  end
+
+  generate_example("calendar_rounded_corners.svg", "calendar with rounded corners", force: force) do
+    HeatmapBuilder.build_calendar(
+      values: calendar_data,
+      cell_size: 14,
+      corner_radius: 2,
+      month_spacing: 0
+    )
+  end
+
+  generate_example("calendar_rounded_corners_max_radius.svg", "calendar with rounded corners (max radius)", force: force) do
+    HeatmapBuilder.build_calendar(
+      values: calendar_data,
+      cell_size: 14,
+      corner_radius: 7,
+      month_spacing: 0
+    )
+  end
+
+  generate_example("calendar_cell_borders.svg", "calendar with cell borders", force: force) do
+    HeatmapBuilder.build_calendar(
+      values: calendar_data,
+      cell_size: 14,
+      border_width: 1,
+      border_lightness_factor: 0.7,
+      month_spacing: 0
+    )
+  end
+
+  generate_example("calendar_no_borders.svg", "calendar with no cell borders", force: force) do
+    HeatmapBuilder.build_calendar(
+      values: calendar_data,
+      cell_size: 14,
+      border_width: 1,
+      border_lightness_factor: 1,
+      month_spacing: 0
+    )
+  end
+
+  generate_example("calendar_month_spacing_rounded.svg", "calendar with month spacing and rounded corners", force: force) do
+    HeatmapBuilder.build_calendar(
+      values: calendar_data,
+      cell_size: 14,
+      month_spacing: 10,
+      corner_radius: 3
+    )
+  end
+
+  puts "Done"
+end
+
+def sample_calendar_data
+  srand(42)
+
+  current_year = Date.today.year
+  start_date = Date.new(current_year, 1, 1)
+  end_date = Date.new(current_year, 12, 31)
+
+  (start_date..end_date).each_with_object({}) do |date, data|
+    day_of_year = date.yday
+    seasonal_factor = Math.sin((day_of_year - 91.25) * 2 * Math::PI / 365) # Peak in summer
+    base_score = (seasonal_factor * 2.7 + 3.6).round
+
+    score = rand(0..base_score)
+    score /= 2 if [0, 6].include?(date.wday) # Weekend reduction
+
+    data[date.to_s] = score
+  end
+end
+
+if __FILE__ == $0
+  force = ARGV.include?("--force")
+  generate_sample_svgs(force: force)
+end