csv_plus_plus 0.1.2 → 0.1.3

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

data/lib/csv_plus_plus/modifier.rb

@@ -1,179 +1,103 @@
+# typed: strict
 # frozen_string_literal: true
 
-module CSVPlusPlus
-  # A container representing the operations that can be applied to a cell or row
-  #
-  # @attr bordercolor [Color]
-  # @attr borders [Array<Symbol>] The borders that will be set
-  # @attr color [Color] The background color of the cell
-  # @attr expand [Expand] Whether this row expands into multiple rows
-  # @attr fontcolor [Color] The font color of the cell
-  # @attr fontfamily [::String] The font family
-  # @attr fontsize [Integer] The font size
-  # @attr halign [:left, :center, :right] Horizontal alignment
-  # @attr note [::String] A note/comment on the cell
-  # @attr numberformat [Symbol] A number format to apply to the value in the cell
-  # @attr row_level [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 validation [Object]
-  # @attr valign [:top, :center, :bottom] Vertical alignment
-  # @attr var [Symbol] The variable bound to this cell
-  #
-  # @attr_writer borderstyle [:hashed, :dotted, :double, :solid, :solid_medium, :solid_thick]
-  #   The style of border on the cell
-  #
-  # @attr_reader borders [Array<Symbol>]
-  # @attr_reader formats [Array<Symbol>] Bold/italics/underline/strikethrough formatting
-  class Modifier
-    attr_accessor :bordercolor,
-                  :color,
-                  :expand,
-                  :fontcolor,
-                  :fontfamily,
-                  :fontsize,
-                  :halign,
-                  :valign,
-                  :note,
-                  :numberformat,
-                  :row_level,
-                  :validation,
-                  :var
-    attr_reader :borders, :formats
-    attr_writer :borderstyle
-
-    # When instantiating a new object, extend it with our validation functionality.
-    #
-    # I'm not sure why I need to do it this way tbh, using +include ValidatedModifier+ at the
-    # class level didn't seem to have access to the parent methods
-    # def self.new(*args, **kwargs, &)
-    #   allocate.tap do |i|
-    #     i.__send__(:initialize, *args, **kwargs, &)
-    #     i.extend(::CSVPlusPlus::ValidatedModifier)
-    #   end
-    # end
-
-    # @param row_level [Boolean] Whether or not this modifier applies to the entire row
-    def initialize(row_level: false)
-      @row_level = row_level
-      @freeze = false
-      @borders = ::Set.new
-      @formats = ::Set.new
-    end
-
-    # Are there any borders set?
-    #
-    # @return [Boolean]
-    def any_border?
-      !@borders.empty?
-    end
-
-    # Style of border
-    #
-    # @return [Symbol]
-    def borderstyle
-      @borderstyle || :solid
-    end
-
-    # Is this a cell-level modifier?
-    #
-    # @return [Boolean]
-    def cell_level?
-      !@row_level
-    end
-
-    # Assign a border
-    #
-    # @param side [:top, :left, :bottom, :right, :all]
-    def border=(side)
-      @borders << side
-    end
-
-    # Does this have a border along +side+?
-    #
-    # @param side [:top, :left, :bottom, :right, :all]
-    #
-    # @return [boolean]
-    def border_along?(side)
-      @borders.include?(:all) || @borders.include?(side)
-    end
-
-    # Does this have a border along all sides?
-    #
-    # @return [boolean]
-    def border_all?
-      @borders.include?(:all) \
-        || (border_along?(:top) && border_along?(:bottom) && border_along?(:left) && border_along?(:right))
-    end
+require_relative './modifier/conditional_formatting'
+require_relative './modifier/data_validation'
+require_relative './modifier/expand'
+require_relative './modifier/modifier'
 
-    # Set this modifier to expand infinitely
-    #
-    # @return [::Expand]
-    def expand!
-      @expand = ::CSVPlusPlus::Expand.new if row_level?
+module CSVPlusPlus
+  # All modifier-specific logic is hidden in this module and callers should just call +#new+ on this module.
+  module Modifier
+    extend ::T::Sig
+
+    # The sides that a border can be on
+    class BorderSide < ::T::Enum
+      enums do
+        All = new
+        Top = new
+        Bottom = new
+        Left = new
+        Right = new
+      end
     end
 
-    # Set a text format (bolid, italic, underline or strikethrough)
-    #
-    # @param value [:bold, :italic, :underline, :strikethrough]
-    def format=(value)
-      @formats << value
+    # The various border styles
+    class BorderStyle < ::T::Enum
+      enums do
+        Dashed = new
+        Dotted = new
+        Double = new
+        Solid = new
+        SolidMedium = new
+        SolidThick = new
+      end
     end
 
-    # Is the given format set?
-    #
-    # @param type [:bold, :italic, :underline, :strikethrough]
-    #
-    # @return [Boolean]
-    def formatted?(type)
-      @formats.include?(type)
+    # The possible values for a horizontal alignment
+    class HorizontalAlign < ::T::Enum
+      enums do
+        Left = new
+        Right = new
+        Center = new
+      end
     end
 
-    # Freeze the row from edits
-    #
-    # @return [true]
-    def freeze!
-      @frozen = true
+    # The allowed number formats
+    class NumberFormat < ::T::Enum
+      enums do
+        Currency = new
+        Date = new
+        DateTime = new
+        Number = new
+        Percent = new
+        Text = new
+        Time = new
+        Scientific = new
+      end
     end
 
-    # Is the row frozen?
-    #
-    # @return [boolean]
-    def frozen?
-      @frozen
+    # The types of formats that can be applied to text.
+    class TextFormat < ::T::Enum
+      enums do
+        Bold = new
+        Italic = new
+        Strikethrough = new
+        Underline = new
+      end
     end
 
-    # Mark this modifer as row-level
-    #
-    # @return [true]
-    def row_level!
-      @row_level = true
+    # The possible values for a horizontal alignment
+    class VerticalAlign < ::T::Enum
+      enums do
+        Top = new
+        Bottom = new
+        Center = new
+      end
     end
 
-    # Is this a row-level modifier?
+    sig { params(options: ::CSVPlusPlus::Options, row_level: ::T::Boolean).returns(::CSVPlusPlus::Modifier::Modifier) }
+    # Return a +Modifier+ with the proper validation and helper functions attached for the given output
     #
-    # @return [boolean]
-    def row_level?
-      @row_level
-    end
-
-    # @return [::String]
-    def to_s
-      # TODO... I dunno, not sure how to manage this
-      "Modifier(row_level: #{@row_level} halign: #{@halign} valign: #{@valign} format: #{@formats} " \
-        "font_size: #{@font_size})"
-    end
-
-    # Create a new modifier instance, with all values defaulted from +other+
+    # @param options [boolean] is this a row level modifier? (otherwise cell-level)
+    # @param row_level [boolean] is this a row level modifier? (otherwise cell-level)
     #
-    # @param other [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)
+    # @return [ValidatedModifier]
+    def self.new(options, row_level: false)
+      output_format = options.output_format
+      case output_format
+      when ::CSVPlusPlus::Options::OutputFormat::CSV, ::CSVPlusPlus::Options::OutputFormat::OpenDocument
+        ::CSVPlusPlus::Modifier::Modifier.new(row_level:)
+      when ::CSVPlusPlus::Options::OutputFormat::Excel
+        ::CSVPlusPlus::Modifier::RubyXLModifier.new(row_level:)
+      when ::CSVPlusPlus::Options::OutputFormat::GoogleSheets
+        ::CSVPlusPlus::Modifier::GoogleSheetModifier.new(row_level:)
+      else ::T.absurd(output_format)
       end
     end
   end
 end
+
+require_relative './modifier/google_sheet_modifier'
+require_relative './modifier/modifier_validator'
+require_relative './modifier/rubyxl_modifier'