csv_plus_plus 0.1.2 → 0.2.0

data/lib/csv_plus_plus/modifier/google_sheet_modifier.rb

@@ -0,0 +1,133 @@
+# typed: strict
+# frozen_string_literal: true
+
+module CSVPlusPlus
+  module Modifier
+    # Decorate a +Modifier+ so it is more compatible with the Google Sheets API
+    class GoogleSheetModifier < ::CSVPlusPlus::Modifier::Modifier
+      extend ::T::Sig
+
+      sig { returns(::T.nilable(::Google::Apis::SheetsV4::Color)) }
+      # Format the color for Google Sheets
+      #
+      # @return [Google::Apis::SheetsV4::Color]
+      def background_color
+        google_sheets_color(@color) if @color
+      end
+
+      sig { returns(::T.nilable(::Google::Apis::SheetsV4::Border)) }
+      # Format the border for Google Sheets
+      #
+      # @return [Google::Apis::SheetsV4::Border]
+      def border
+        return unless any_border?
+
+        # TODO: allow different border styles per side?
+        ::Google::Apis::SheetsV4::Border.new(
+          color: google_sheets_color(bordercolor || ::CSVPlusPlus::Color.new('#000000')),
+          style: border_style
+        )
+      end
+
+      sig { returns(::T.nilable(::Google::Apis::SheetsV4::Color)) }
+      # Format the fontcolor for Google Sheets
+      #
+      # @return [Google::Apis::SheetsV4::Color]
+      def font_color
+        google_sheets_color(@fontcolor) if @fontcolor
+      end
+
+      sig { returns(::T.nilable(::String)) }
+      # Format the halign for Google Sheets
+      #
+      # @return [::String]
+      def horizontal_alignment
+        halign&.serialize&.upcase
+      end
+
+      sig { returns(::T.nilable(::Google::Apis::SheetsV4::NumberFormat)) }
+      # Format the numberformat for Google Sheets
+      #
+      #
+      # @return [Google::Apis::SheetsV4::NumberFormat]
+      def number_format
+        ::Google::Apis::SheetsV4::NumberFormat.new(type: number_format_type(@numberformat)) if @numberformat
+      end
+
+      sig { returns(::Google::Apis::SheetsV4::TextFormat) }
+      # Builds a SheetsV4::TextFormat with the underlying Modifier
+      #
+      # @return [Google::Apis::SheetsV4::TextFormat]
+      def text_format
+        ::Google::Apis::SheetsV4::TextFormat.new(
+          bold: formatted?(::CSVPlusPlus::Modifier::TextFormat::Bold) || nil,
+          italic: formatted?(::CSVPlusPlus::Modifier::TextFormat::Italic) || nil,
+          strikethrough: formatted?(::CSVPlusPlus::Modifier::TextFormat::Strikethrough) || nil,
+          underline: formatted?(::CSVPlusPlus::Modifier::TextFormat::Underline) || nil,
+          font_family: fontfamily,
+          font_size: fontsize,
+          foreground_color: font_color
+        )
+      end
+
+      sig { returns(::T.nilable(::String)) }
+      # Format the valign for Google Sheets
+      def vertical_alignment
+        valign&.serialize&.upcase
+      end
+
+      private
+
+      sig { returns(::T.nilable(::String)) }
+      # Format the border style for Google Sheets
+      #
+      # @see https://developers.google.com/apps-script/reference/spreadsheet/border-style
+      #
+      # @return [::String, nil]
+      # rubocop:disable Metrics/CyclomaticComplexity
+      def border_style
+        return 'SOLID' unless @borderstyle
+
+        case @borderstyle
+        when ::CSVPlusPlus::Modifier::BorderStyle::Dashed then 'DASHED'
+        when ::CSVPlusPlus::Modifier::BorderStyle::Dotted then 'DOTTED'
+        when ::CSVPlusPlus::Modifier::BorderStyle::Double then 'DOUBLE'
+        when ::CSVPlusPlus::Modifier::BorderStyle::Solid then 'SOLID'
+        when ::CSVPlusPlus::Modifier::BorderStyle::SolidMedium then 'SOLID_MEDIUM'
+        when ::CSVPlusPlus::Modifier::BorderStyle::SolidThick then 'SOLID_THICK'
+        else ::T.absurd(@borderstyle)
+        end
+      end
+      # rubocop:enable Metrics/CyclomaticComplexity
+
+      sig { params(color: ::CSVPlusPlus::Color).returns(::Google::Apis::SheetsV4::Color) }
+      def google_sheets_color(color)
+        ::Google::Apis::SheetsV4::Color.new(
+          red: color.red_percent,
+          green: color.green_percent,
+          blue: color.blue_percent
+        )
+      end
+
+      sig { params(numberformat: ::CSVPlusPlus::Modifier::NumberFormat).returns(::String) }
+      # @see https://developers.google.com/sheets/api/reference/rest/v4/spreadsheets/cells#NumberFormat
+      #
+      # @return [::String]
+      # rubocop:disable Metrics/CyclomaticComplexity, Metrics/MethodLength
+      def number_format_type(numberformat)
+        case numberformat
+        when ::CSVPlusPlus::Modifier::NumberFormat::Currency then 'CURRENCY'
+        when ::CSVPlusPlus::Modifier::NumberFormat::Date then 'DATE'
+        when ::CSVPlusPlus::Modifier::NumberFormat::DateTime then 'DATE_TIME'
+        when ::CSVPlusPlus::Modifier::NumberFormat::Number then 'NUMBER'
+        when ::CSVPlusPlus::Modifier::NumberFormat::Percent then 'PERCENT'
+        when ::CSVPlusPlus::Modifier::NumberFormat::Text then 'TEXT'
+        when ::CSVPlusPlus::Modifier::NumberFormat::Time then 'TIME'
+        when ::CSVPlusPlus::Modifier::NumberFormat::Scientific then 'SCIENTIFIC'
+        else ::T.absurd(numberformat)
+        end
+      end
+      # rubocop:enable Metrics/CyclomaticComplexity, Metrics/MethodLength
+    end
+  end
+end

data/lib/csv_plus_plus/modifier/modifier.rb

@@ -0,0 +1,222 @@
+# typed: strict
+# frozen_string_literal: true
+
+module CSVPlusPlus
+  module Modifier
+    # A container representing the operations that can be applied to a cell or row
+    #
+    # @attr bordercolor [Color, nil]
+    # @attr color [Color, nil] The background color of the cell
+    # @attr expand [Modifier::Expand, nil] Whether this row expands into multiple rows
+    # @attr fontcolor [Color, nil] The font color of the cell
+    # @attr fontfamily [::String, nil] The font family
+    # @attr fontsize [Numeric, nil] The font size
+    # @attr halign [Modifier::HorizontalAlign, nil] Horizontal alignment
+    # @attr note [::String, nil] A note/comment on the cell
+    # @attr numberformat [Modifier::NumberFormat, nil] A number format to apply to the value in the cell
+    # @attr row_level [T::Boolean] Is this a row modifier? If so it's values will apply to all cells in the row
+    #   (unless overridden by the cell modifier)
+    # @attr validate [Modifier::DataValidation, nil]
+    # @attr valign [Modifier::VerticalAlign, nil] Vertical alignment
+    # @attr var [Symbol, nil] The variable bound to this cell
+    #
+    # @attr_writer borderstyle [Modifier::BorderStyle] The style of border on the cell
+    #
+    # @attr_reader borders [Set<Modifier::BorderSide>] The sides of the cell where a border will be applied.
+    # @attr_reader formats [Set<Modifier::TextFormat>] Bold/italics/underline and strikethrough formatting.
+    #
+    # rubocop:disable Metrics/ClassLength
+    class Modifier
+      extend ::T::Sig
+
+      sig { returns(::T.nilable(::CSVPlusPlus::Color)) }
+      attr_accessor :bordercolor
+
+      sig { returns(::T.nilable(::CSVPlusPlus::Color)) }
+      attr_accessor :color
+
+      sig { returns(::T.nilable(::CSVPlusPlus::Modifier::Expand)) }
+      attr_accessor :expand
+
+      sig { returns(::T.nilable(::CSVPlusPlus::Color)) }
+      attr_accessor :fontcolor
+
+      sig { returns(::T.nilable(::String)) }
+      attr_accessor :fontfamily
+
+      sig { returns(::T.nilable(::Numeric)) }
+      attr_accessor :fontsize
+
+      sig { returns(::T.nilable(::CSVPlusPlus::Modifier::HorizontalAlign)) }
+      attr_accessor :halign
+
+      sig { returns(::T.nilable(::String)) }
+      attr_accessor :note
+
+      sig { returns(::T.nilable(::CSVPlusPlus::Modifier::NumberFormat)) }
+      attr_accessor :numberformat
+
+      sig { returns(::T::Boolean) }
+      attr_accessor :row_level
+
+      sig { returns(::T.nilable(::CSVPlusPlus::Modifier::DataValidation)) }
+      attr_accessor :validate
+
+      sig { returns(::T.nilable(::CSVPlusPlus::Modifier::VerticalAlign)) }
+      attr_accessor :valign
+
+      sig { returns(::T.nilable(::Symbol)) }
+      attr_accessor :var
+
+      sig { returns(::T::Set[::CSVPlusPlus::Modifier::BorderSide]) }
+      attr_reader :borders
+
+      sig { returns(::T::Set[::CSVPlusPlus::Modifier::TextFormat]) }
+      attr_reader :formats
+
+      sig do
+        params(borderstyle: ::CSVPlusPlus::Modifier::BorderStyle)
+          .returns(::T.nilable(::CSVPlusPlus::Modifier::BorderStyle))
+      end
+      attr_writer :borderstyle
+
+      sig { params(row_level: ::T::Boolean).void }
+      # @param row_level [Boolean] Whether or not this modifier applies to the entire row
+      def initialize(row_level: false)
+        @row_level = row_level
+        @frozen = ::T.let(false, ::T::Boolean)
+        @borders = ::T.let(::Set.new, ::T::Set[::CSVPlusPlus::Modifier::BorderSide])
+        @formats = ::T.let(::Set.new, ::T::Set[::CSVPlusPlus::Modifier::TextFormat])
+      end
+
+      sig { returns(::T::Boolean) }
+      # Are there any borders set?
+      #
+      # @return [::T::Boolean]
+      def any_border?
+        !@borders.empty?
+      end
+
+      sig { returns(::CSVPlusPlus::Modifier::BorderStyle) }
+      # Style of the border
+      #
+      # @return [::CSVPlusPlus::Modifier::BorderStyle]
+      def borderstyle
+        @borderstyle || ::CSVPlusPlus::Modifier::BorderStyle::Solid
+      end
+
+      sig { returns(::T::Boolean) }
+      # Is this a cell-level modifier?
+      #
+      # @return [T::Boolean]
+      def cell_level?
+        !@row_level
+      end
+
+      sig { params(side: ::CSVPlusPlus::Modifier::BorderSide).returns(::T::Set[::CSVPlusPlus::Modifier::BorderSide]) }
+      # Put a border on the given +side+
+      #
+      # @param side [Modifier::BorderSide]
+      def border=(side)
+        @borders << side
+      end
+
+      sig { params(side: ::CSVPlusPlus::Modifier::BorderSide).returns(::T::Boolean) }
+      # Does this have a border along +side+?
+      #
+      # @param side [Modifier::BorderSide]
+      #
+      # @return [T::Boolean]
+      def border_along?(side)
+        @borders.include?(::CSVPlusPlus::Modifier::BorderSide::All) || @borders.include?(side)
+      end
+
+      sig { returns(::T::Boolean) }
+      # Does this have a border along all sides?
+      #
+      # @return [T::Boolean]
+      def border_all?
+        @borders.include?(::CSVPlusPlus::Modifier::BorderSide::All) \
+          || (border_along?(::CSVPlusPlus::Modifier::BorderSide::Top) \
+              && border_along?(::CSVPlusPlus::Modifier::BorderSide::Bottom) \
+              && border_along?(::CSVPlusPlus::Modifier::BorderSide::Left) \
+              && border_along?(::CSVPlusPlus::Modifier::BorderSide::Right))
+      end
+
+      sig { returns(::T.nilable(::CSVPlusPlus::Modifier::Expand)) }
+      # Set this modifier to expand infinitely
+      #
+      # @return [Expand, nil]
+      def infinite_expand!
+        @expand = ::CSVPlusPlus::Modifier::Expand.new if row_level?
+      end
+
+      sig { params(format: ::CSVPlusPlus::Modifier::TextFormat).returns(::T::Set[::CSVPlusPlus::Modifier::TextFormat]) }
+      # Set a text format (bolid, italic, underline or strikethrough)
+      #
+      # @param format [TextFormat]
+      def format=(format)
+        @formats << format
+      end
+
+      sig { params(format: ::CSVPlusPlus::Modifier::TextFormat).returns(::T::Boolean) }
+      # Is the given format set?
+      #
+      # @param format [TextFormat]
+      #
+      # @return [T::Boolean]
+      def formatted?(format)
+        @formats.include?(format)
+      end
+
+      sig { returns(::T::Boolean) }
+      # Freeze the row or cell from edits
+      #
+      # @return [true]
+      def freeze!
+        @frozen = true
+      end
+
+      sig { returns(::T::Boolean) }
+      # Is the cell or row frozen from edits?
+      #
+      # @return [T::Boolean]
+      def frozen?
+        @frozen
+      end
+
+      sig { returns(::T::Boolean) }
+      # Mark this modifer as row-level
+      #
+      # @return [true]
+      def row_level!
+        @row_level = true
+      end
+
+      sig { returns(::T::Boolean) }
+      # Is this a row-level modifier?
+      #
+      # @return [T::Boolean]
+      def row_level?
+        @row_level
+      end
+
+      sig { params(other: ::CSVPlusPlus::Modifier::Modifier).void }
+      # Create a new modifier instance, with all values defaulted from +other+
+      #
+      # @param other [Modifier]
+      #
+      # @return [Modifier]
+      def take_defaults_from!(other)
+        other.instance_variables.each do |property|
+          # don't propagate row-specific values
+          next if property == :@row_level
+
+          value = other.instance_variable_get(property)
+          instance_variable_set(property, value.clone)
+        end
+      end
+    end
+    # rubocop:enable Metrics/ClassLength
+  end
+end

data/lib/csv_plus_plus/modifier/modifier_validator.rb

@@ -0,0 +1,243 @@
+# typed: strict
+# frozen_string_literal: true
+
+module CSVPlusPlus
+  module Modifier
+    # Validates and coerces modifier user inputs as they are parsed.
+    #
+    # Previously this logic was handled in the parser's grammar, but with the introduction of variable binding the
+    # grammar is no longer context free so we need the parser to be a little looser on what it accepts and validate it
+    # here.  Having this layer is also nice because we can provide better error messages to the user for what went
+    # wrong during the parse.
+    # rubocop:disable Metrics/ClassLength
+    class ModifierValidator
+      extend ::T::Sig
+
+      sig { returns(::CSVPlusPlus::Modifier::Modifier) }
+      attr_reader :modifier
+
+      sig { params(modifier: ::CSVPlusPlus::Modifier::Modifier).void }
+      # @param modifier [Modifier::Modifier] The modifier to set the validated attributes on.
+      def initialize(modifier)
+        @modifier = modifier
+      end
+
+      sig { params(border_side: ::String).void }
+      # Validates that +border_side+ is 'all', 'top', 'bottom', 'left' or 'right'.
+      #
+      # @param border_side [::String, Modifier::BorderSide] The unvalidated user input
+      #
+      # @return [Set<Modifier::BorderSide>]
+      def border=(border_side)
+        @modifier.border = ::T.cast(
+          one_of(:border, border_side, ::CSVPlusPlus::Modifier::BorderSide),
+          ::CSVPlusPlus::Modifier::BorderSide
+        )
+      end
+
+      sig { params(border_color: ::String).void }
+      # Validates that +border_color+ is a hex color.
+      #
+      # @param border_color [::String] The unvalidated user input
+      def bordercolor=(border_color)
+        @modifier.bordercolor = color_value(:bordercolor, border_color)
+      end
+
+      sig { params(border_style: ::String).void }
+      # Validates that +borderstyle+ is 'dashed', 'dotted', 'double', 'solid', 'solid_medium' or 'solid_thick'.
+      #
+      # @param border_style [::String] The unvalidated user input
+      def borderstyle=(border_style)
+        @modifier.borderstyle = ::T.cast(
+          one_of(:borderstyle, border_style, ::CSVPlusPlus::Modifier::BorderStyle),
+          ::CSVPlusPlus::Modifier::BorderStyle
+        )
+      end
+
+      sig { params(color: ::String).void }
+      # Validates that +color+ is a hex color.
+      #
+      # @param color [::String] The unvalidated user input
+      def color=(color)
+        @modifier.color = color_value(:color, color)
+      end
+
+      sig { params(repetitions: ::String).void }
+      # Validates that +repetitions+ is a positive integer.
+      #
+      # @param repetitions [String] The unvalidated user input
+      def expand=(repetitions)
+        @modifier.expand = ::CSVPlusPlus::Modifier::Expand.new(repetitions: positive_integer(:expand, repetitions))
+      end
+
+      sig { params(font_color: ::String).void }
+      # Validates that +font_color+ is a hex color.
+      #
+      # @param font_color [::String] The unvalidated user input
+      def fontcolor=(font_color)
+        @modifier.fontcolor = color_value(:fontcolor, font_color)
+      end
+
+      sig { params(font_family: ::String).void }
+      # Validates that +font_family+ is a string that looks like a valid font family.  There's only so much validation
+      # we can do here
+      #
+      # @param font_family [::String] The unvalidated user input
+      def fontfamily=(font_family)
+        @modifier.fontfamily = matches_regexp(
+          :fontfamily,
+          ::CSVPlusPlus::Lexer.unquote(font_family),
+          /^[\w\s]+$/,
+          'It is not a valid font family.'
+        )
+      end
+
+      sig { params(font_size: ::String).void }
+      # Validates that +font_size+ is a positive integer
+      #
+      # @param font_size [::String] The unvalidated user input
+      def fontsize=(font_size)
+        @modifier.fontsize = positive_integer(:fontsize, font_size)
+      end
+
+      sig { params(text_format: ::String).void }
+      # Validates that +text_format+ is 'bold', 'italic', 'strikethrough' or 'underline'.
+      #
+      # @param text_format [::String] The unvalidated user input
+      def format=(text_format)
+        @modifier.format = ::T.cast(
+          one_of(:format, text_format, ::CSVPlusPlus::Modifier::TextFormat),
+          ::CSVPlusPlus::Modifier::TextFormat
+        )
+      end
+
+      sig { void }
+      # Sets the row or cell to be frozen
+      def freeze!
+        @modifier.freeze!
+      end
+
+      sig { void }
+      # Sets an infinite +Expand+ on the +Modifier+.
+      def infinite_expand!
+        @modifier.infinite_expand!
+      end
+
+      sig { params(halign: ::String).void }
+      # Validates that +halign+ is a string representation of +Modifier::HorizontalAlign+
+      #
+      # @param halign [::String] The unvalidated user input
+      def halign=(halign)
+        @modifier.halign = ::T.cast(
+          one_of(:halign, halign, ::CSVPlusPlus::Modifier::HorizontalAlign),
+          ::CSVPlusPlus::Modifier::HorizontalAlign
+        )
+      end
+
+      sig { params(note: ::String).void }
+      # Validates that +note+ is a quoted string.
+      #
+      # @param note [::String] The unvalidated user input
+      def note=(note)
+        @modifier.note = note
+      end
+
+      sig { params(number_format: ::String).void }
+      # Validates that +number_format+ is a string version of a +Modifier::NumberFormat+
+      #
+      # @param number_format [::String] The unvalidated user input
+      def numberformat=(number_format)
+        @modifier.numberformat = ::T.cast(
+          one_of(:numberformat, number_format, ::CSVPlusPlus::Modifier::NumberFormat),
+          ::CSVPlusPlus::Modifier::NumberFormat
+        )
+      end
+
+      sig { params(valign: ::String).void }
+      # Validates that +valign+ is a string representation of +Modifier::VerticalAlign+
+      #
+      # @param valign [::String] The unvalidated user input
+      def valign=(valign)
+        @modifier.valign = ::T.cast(
+          one_of(:valign, valign, ::CSVPlusPlus::Modifier::VerticalAlign),
+          ::CSVPlusPlus::Modifier::VerticalAlign
+        )
+      end
+
+      sig { params(rule: ::String).void }
+      # Validates that the conditional validating rules are well-formed.
+      #
+      # Pretty much based off of the Google Sheets API spec here:
+      # @see https://developers.google.com/sheets/api/samples/data#apply_data_validation_to_a_range
+      #
+      # @param rule [::String] The validation rule to apply to this row or cell
+      def validate=(rule)
+        @modifier.validate = a_data_validation(:validate, rule)
+      end
+
+      sig { params(var: ::String).void }
+      # Validates +var+ is a valid variable identifier.
+      #
+      # @param var [::String] The unvalidated user input
+      def var=(var)
+        # TODO: I need a shared definition of what a variable can be (I guess the :ID token)
+        @modifier.var = matches_regexp(:var, var, /^\w+$/, 'It must be a sequence of letters, numbers and _.').to_sym
+      end
+
+      private
+
+      sig { params(modifier: ::Symbol, value: ::String).returns(::CSVPlusPlus::Modifier::DataValidation) }
+      def a_data_validation(modifier, value)
+        data_validation = ::CSVPlusPlus::Modifier::DataValidation.new(value)
+        return data_validation if data_validation.valid?
+
+        raise_error(modifier, value, message: data_validation.invalid_reason)
+      end
+
+      sig { params(modifier: ::Symbol, value: ::String).returns(::CSVPlusPlus::Color) }
+      def color_value(modifier, value)
+        unless ::CSVPlusPlus::Color.valid_hex_string?(value)
+          raise_error(modifier, value, message: 'It must be a 3 or 6 digit hex code.')
+        end
+
+        ::CSVPlusPlus::Color.new(value)
+      end
+
+      sig { params(modifier: ::Symbol, value: ::String, regexp: ::Regexp, message: ::String).returns(::String) }
+      def matches_regexp(modifier, value, regexp, message)
+        raise_error(modifier, value, message:) unless value =~ regexp
+        value
+      end
+
+      sig { params(modifier: ::Symbol, value: ::String, choices: ::T.class_of(::T::Enum)).returns(::T::Enum) }
+      def one_of(modifier, value, choices)
+        choices.deserialize(value.downcase.gsub('_', ''))
+      rescue ::KeyError
+        raise_error(modifier, value, choices:)
+      end
+
+      sig { params(modifier: ::Symbol, value: ::String).returns(::Integer) }
+      def positive_integer(modifier, value)
+        Integer(value.to_s, 10).tap do |i|
+          raise_error(modifier, value, message: 'It must be positive and greater than 0.') unless i.positive?
+        end
+      rescue ::ArgumentError
+        raise_error(modifier, value, message: 'It must be a valid (whole) number.')
+      end
+
+      sig do
+        type_parameters(:E)
+          .params(
+            modifier: ::Symbol,
+            bad_input: ::String,
+            choices: ::T.nilable(::T.all(::T.type_parameter(:E), ::T.class_of(::T::Enum))),
+            message: ::T.nilable(::String)
+          ).returns(::T.noreturn)
+      end
+      def raise_error(modifier, bad_input, choices: nil, message: nil)
+        raise(::CSVPlusPlus::Error::ModifierValidationError.new(modifier, bad_input:, choices:, message:))
+      end
+    end
+    # rubocop:enable Metrics/ClassLength
+  end
+end

data/lib/csv_plus_plus/modifier/rubyxl_modifier.rb

@@ -0,0 +1,84 @@
+# typed: strict
+# frozen_string_literal: true
+
+module CSVPlusPlus
+  module Modifier
+    # Build a RubyXL-decorated Modifier class adds some support for Excel
+    class RubyXLModifier < ::CSVPlusPlus::Modifier::Modifier
+      extend ::T::Sig
+
+      # @see https://www.rubydoc.info/gems/rubyXL/RubyXL/NumberFormats
+      # @see https://support.microsoft.com/en-us/office/number-format-codes-5026bbd6-04bc-48cd-bf33-80f18b4eae68
+      NUM_FMT_IDS = ::T.let(
+        {
+          ::CSVPlusPlus::Modifier::NumberFormat::Currency => 5,
+          ::CSVPlusPlus::Modifier::NumberFormat::Date => 14,
+          ::CSVPlusPlus::Modifier::NumberFormat::DateTime => 22,
+          ::CSVPlusPlus::Modifier::NumberFormat::Number => 1,
+          ::CSVPlusPlus::Modifier::NumberFormat::Percent => 9,
+          ::CSVPlusPlus::Modifier::NumberFormat::Text => 49,
+          ::CSVPlusPlus::Modifier::NumberFormat::Time => 21,
+          ::CSVPlusPlus::Modifier::NumberFormat::Scientific => 48
+        }.freeze,
+        ::T::Hash[::CSVPlusPlus::Modifier::NumberFormat, ::Integer]
+      )
+      private_constant :NUM_FMT_IDS
+
+      # @see http://www.datypic.com/sc/ooxml/t-ssml_ST_BorderStyle.html
+      # ST_BorderStyle = %w{ none thin medium dashed dotted thick double hair mediumDashed dashDot mediumDashDot
+      #                      dashDotDot slantDashDot }
+      BORDER_STYLES = ::T.let(
+        {
+          ::CSVPlusPlus::Modifier::BorderStyle::Dashed => 'dashed',
+          ::CSVPlusPlus::Modifier::BorderStyle::Dotted => 'dotted',
+          ::CSVPlusPlus::Modifier::BorderStyle::Double => 'double',
+          ::CSVPlusPlus::Modifier::BorderStyle::Solid => 'thin',
+          ::CSVPlusPlus::Modifier::BorderStyle::SolidMedium => 'medium',
+          ::CSVPlusPlus::Modifier::BorderStyle::SolidThick => 'thick'
+        }.freeze,
+        ::T::Hash[::CSVPlusPlus::Modifier::BorderStyle, ::String]
+      )
+      private_constant :BORDER_STYLES
+
+      sig { returns(::T.nilable(::String)) }
+      # The excel-specific border weight
+      #
+      # @return [::String, nil]
+      def border_weight
+        # rubocop:disable Lint/ConstantResolution
+        BORDER_STYLES[borderstyle]
+        # rubocop:enable Lint/ConstantResolution
+      end
+
+      sig { returns(::T.nilable(::String)) }
+      # The horizontal alignment, formatted for the RubyXL API
+      #
+      # @return [::String, nil]
+      def horizontal_alignment
+        @halign&.serialize
+      end
+
+      sig { returns(::T.nilable(::String)) }
+      # The excel-specific number format code
+      #
+      # @return [::String]
+      def number_format_code
+        return unless @numberformat
+
+        ::RubyXL::NumberFormats::DEFAULT_NUMBER_FORMATS.find_by_format_id(
+          # rubocop:disable Lint/ConstantResolution
+          NUM_FMT_IDS[@numberformat]
+          # rubocop:enable Lint/ConstantResolution
+        ).format_code
+      end
+
+      sig { returns(::T.nilable(::String)) }
+      # The vertical alignment, formatted for the RubyXL API
+      #
+      # @return [::String, nil]
+      def vertical_alignment
+        @valign&.serialize
+      end
+    end
+  end
+end