csv_plus_plus 0.1.2 → 0.2.0

data/lib/csv_plus_plus/modifier.rb

@@ -1,179 +1,108 @@
+# 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
-
-    # Set this modifier to expand infinitely
-    #
-    # @return [::Expand]
-    def expand!
-      @expand = ::CSVPlusPlus::Expand.new if row_level?
-    end
-
-    # Set a text format (bolid, italic, underline or strikethrough)
-    #
-    # @param value [:bold, :italic, :underline, :strikethrough]
-    def format=(value)
-      @formats << value
-    end
+require_relative './modifier/conditional_formatting'
+require_relative './modifier/data_validation'
+require_relative './modifier/expand'
+require_relative './modifier/modifier'
 
-    # Is the given format set?
-    #
-    # @param type [:bold, :italic, :underline, :strikethrough]
-    #
-    # @return [Boolean]
-    def formatted?(type)
-      @formats.include?(type)
+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
 
-    # Freeze the row from edits
-    #
-    # @return [true]
-    def freeze!
-      @frozen = true
+    # 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 row frozen?
-    #
-    # @return [boolean]
-    def frozen?
-      @frozen
+    # The possible values for a horizontal alignment
+    class HorizontalAlign < ::T::Enum
+      enums do
+        Left = new
+        Right = new
+        Center = new
+      end
     end
 
-    # Mark this modifer as row-level
-    #
-    # @return [true]
-    def row_level!
-      @row_level = 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 this a row-level modifier?
-    #
-    # @return [boolean]
-    def row_level?
-      @row_level
+    # 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
 
-    # @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})"
+    # The possible values for a horizontal alignment
+    class VerticalAlign < ::T::Enum
+      enums do
+        Top = new
+        Bottom = new
+        Center = new
+      end
     end
 
-    # Create a new modifier instance, with all values defaulted from +other+
-    #
-    # @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)
+    sig do
+      params(
+        options: ::CSVPlusPlus::Options::Options,
+        row_level: ::T::Boolean
+      ).returns(::CSVPlusPlus::Modifier::Modifier)
+    end
+    # Return a +Modifier+ with the proper validation and helper functions attached for the given output
+    #
+    # @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)
+    #
+    # @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'

data/lib/csv_plus_plus/options/file_options.rb

@@ -0,0 +1,49 @@
+# typed: strict
+# frozen_string_literal: true
+
+module CSVPlusPlus
+  module Options
+    # The options that are specific for compiling to a file
+    #
+    # @attr output_filename [Pathname] The file to write our compiled results to
+    class FileOptions < ::CSVPlusPlus::Options::Options
+      extend ::T::Sig
+      extend ::T::Helpers
+
+      sig { returns(::Pathname) }
+      attr_accessor :output_filename
+
+      sig { params(sheet_name: ::String, output_filename: ::String).void }
+      # Initialize an +Options+ object for writing to a file
+      def initialize(sheet_name, output_filename)
+        super(sheet_name)
+
+        @output_filename = ::T.let(::Pathname.new(output_filename), ::Pathname)
+      end
+
+      sig { override.returns(::CSVPlusPlus::Options::OutputFormat) }
+      # Given the options, figure out which type of +OutputFormat+ we'll be writing to
+      #
+      # @return [Options::OutputFormat]
+      def output_format
+        case output_filename.extname
+        when '.csv' then ::CSVPlusPlus::Options::OutputFormat::CSV
+        when '.ods' then ::CSVPlusPlus::Options::OutputFormat::OpenDocument
+        when /\.xl(sx|sm|tx|tm)$/ then ::CSVPlusPlus::Options::OutputFormat::Excel
+        else raise(::CSVPlusPlus::Error::CLIError, "Unsupported file extension: #{output_filename}")
+        end
+      end
+
+      sig { override.returns(::String) }
+      # Verbose summary for options specific to compiling to a file
+      #
+      # @return [String]
+      def verbose_summary
+        shared_summary(
+          <<~OUTPUT)
+            > Output filename                     | #{output_filename}
+          OUTPUT
+      end
+    end
+  end
+end

data/lib/csv_plus_plus/options/google_sheets_options.rb

@@ -0,0 +1,42 @@
+# typed: strict
+# frozen_string_literal: true
+
+module CSVPlusPlus
+  module Options
+    # The Google-specific options a user can supply.
+    #
+    # @attr sheet_id [String] The ID of the Google Sheet to write to.
+    class GoogleSheetsOptions < Options
+      extend ::T::Sig
+
+      sig { returns(::String) }
+      attr_reader :sheet_id
+
+      sig { params(sheet_name: ::String, sheet_id: ::String).void }
+      # @param sheet_name [String] The name of the sheet
+      # @param sheet_id [String] The unique ID Google uses to reference the sheet
+      def initialize(sheet_name, sheet_id)
+        super(sheet_name)
+
+        @sheet_id = sheet_id
+      end
+
+      sig { override.returns(::CSVPlusPlus::Options::OutputFormat) }
+      # @return [OutputFormat]
+      def output_format
+        ::CSVPlusPlus::Options::OutputFormat::GoogleSheets
+      end
+
+      sig { override.returns(::String) }
+      # Format a string with a verbose description of Google-specific options
+      #
+      # @return [String]
+      def verbose_summary
+        shared_summary(
+          <<~SUMMARY)
+            > Sheet ID | #{@sheet_id}
+          SUMMARY
+      end
+    end
+  end
+end

data/lib/csv_plus_plus/options/options.rb

@@ -0,0 +1,97 @@
+# typed: strict
+# frozen_string_literal: true
+
+module CSVPlusPlus
+  module Options
+    # The options a user can supply (via CLI flags)
+    #
+    # @attr backup [Boolean] Create a backup of the spreadsheet before writing
+    # @attr create_if_not_exists [Boolean] Create the spreadsheet if it does not exist?
+    # @attr key_values [Hash] Additional variables that can be supplied to the template
+    # @attr offset [Array<Integer>] An [x, y] offset (array with two integers)
+    # @attr sheet_name [String] The name of the spreadsheet to write to
+    # @attr verbose [Boolean] Include extra verbose output?
+    class Options
+      extend ::T::Sig
+      extend ::T::Helpers
+
+      abstract!
+
+      sig { returns(::T::Boolean) }
+      attr_accessor :backup
+
+      sig { returns(::T::Boolean) }
+      attr_accessor :create_if_not_exists
+
+      sig { returns(::T::Hash[::Symbol, ::CSVPlusPlus::Entities::Entity]) }
+      attr_accessor :key_values
+
+      sig { returns(::T::Array[::Integer]) }
+      attr_accessor :offset
+
+      sig { returns(::String) }
+      attr_accessor :sheet_name
+
+      sig { returns(::T::Boolean) }
+      attr_accessor :verbose
+
+      sig { params(sheet_name: ::String).void }
+      # Initialize a defaul +Options+ object
+      def initialize(sheet_name)
+        @sheet_name = sheet_name
+        @offset = ::T.let([0, 0], ::T::Array[::Integer])
+        @create_if_not_exists = ::T.let(false, ::T::Boolean)
+        @key_values = ::T.let({}, ::T::Hash[::Symbol, ::CSVPlusPlus::Entities::Entity])
+        @verbose = ::T.let(false, ::T::Boolean)
+        @backup = ::T.let(false, ::T::Boolean)
+      end
+
+      sig { abstract.returns(::CSVPlusPlus::Options::OutputFormat) }
+      # Given the options, figure out which type of +OutputFormat+ we'll be writing to
+      #
+      # @return [Options::OutputFormat]
+      def output_format; end
+
+      sig { abstract.returns(::String) }
+      # Return a string with a verbose description of what we're doing with the options
+      #
+      # @return [String]
+      def verbose_summary; end
+
+      protected
+
+      sig { params(str: ::String).returns(::String) }
+      # Return a string with a verbose description of what we're doing with the options
+      #
+      # @return [String]
+      def shared_summary(str)
+        <<~SUMMARY
+          #{summary_divider}
+
+          # csv++ Command Options
+
+          > Sheet name                          | #{@sheet_name}
+          > Create sheet if it does not exist?  | #{@create_if_not_exists}
+          > Spreadsheet row-offset              | #{@offset[0]}
+          > Spreadsheet cell-offset             | #{@offset[1]}
+          > User-supplied key-values            | #{@key_values}
+          > Verbose                             | #{@verbose}
+          > Backup                              | #{@backup}
+
+          ## Output Options
+
+          #{str}
+
+          #{summary_divider}
+        SUMMARY
+      end
+
+      private
+
+      sig { returns(::String) }
+      def summary_divider
+        '========================================================================='
+      end
+    end
+  end
+end

data/lib/csv_plus_plus/options.rb

@@ -1,88 +1,45 @@
+# typed: strict
 # frozen_string_literal: true
 
-require_relative './cli_flag'
-require_relative './google_options'
-
 module CSVPlusPlus
-  # The options a user can supply (via CLI flags)
-  #
-  # @attr backup [boolean] Create a backup of the spreadsheet before writing
-  # @attr create_if_not_exists [boolean] Create the spreadsheet if it does not exist?
-  # @attr key_values [Hash] Additional variables that can be supplied to the template
-  # @attr offset [Array<Integer>] An [x, y] offset (array with two integers)
-  # @attr output_filename [String] The file to write our compiled results to
-  # @attr sheet_name [String] The name of the spreadsheet to write to
-  # @attr verbose [boolean] Include extra verbose output?
-  # @attr_reader google [GoogleOptions] Options that are specific to the Google Sheets writer
-  class Options
-    attr_accessor :backup, :create_if_not_exists, :key_values, :offset, :output_filename, :sheet_name, :verbose
-    attr_reader :google
-
-    # initialize
-    def initialize
-      @offset = [0, 0]
-      @create_if_not_exists = false
-      @key_values = {}
-      @verbose = false
-      @backup = false
+  # Options that a user can supply - either specific for compiling to a file (xlsx, csv) or Google Sheets
+  module Options
+    extend ::T::Sig
+
+    # The supported output formats.  We use this to dispatch flow in several places
+    class OutputFormat < ::T::Enum
+      enums do
+        CSV = new
+        Excel = new
+        GoogleSheets = new
+        OpenDocument = new
+      end
     end
 
-    # Set the Google Sheet ID
-    #
-    # @param sheet_id [String] The identifier used by Google's API to reference the sheet.  You can find it in the URL
-    #   for the sheet
-    #
-    # @return [String]
-    def google_sheet_id=(sheet_id)
-      @google = ::CSVPlusPlus::GoogleOptions.new(sheet_id)
+    sig do
+      params(flags: ::T::Hash[::Symbol, ::String], input_filename: ::Pathname).returns(::CSVPlusPlus::Options::Options)
     end
-
-    # Returns an error string or nil if there are no validation problems
+    # Use the given +flags+ to determine if we're dealing with either a Google Sheets or file-based
+    # compilation and build an +Options+ instance accordingly.
     #
-    # @return [String, nil]
-    def validate
-      return if @google || @output_filename
-
-      'You must supply either a Google Sheet ID or an output file'
-    end
-
-    # Return a string with a verbose description of what we're doing with the options
+    # @param flags [Hash<Symbol, String>]
+    # @param input_filename [Pathname]
     #
-    # @return [String]
-    def verbose_summary
-      <<~SUMMARY
-        #{summary_divider}
-
-        # csv++ Command Options
-
-        > Input filename                      | #{@filename}
-        > Sheet name                          | #{@sheet_name}
-        > Create sheet if it does not exist?  | #{@create_if_not_exists}
-        > Spreadsheet row-offset              | #{@offset[0]}
-        > Spreadsheet cell-offset             | #{@offset[1]}
-        > User-supplied key-values            | #{@key_values}
-        > Verbose                             | #{@verbose}
-
-        ## Output Options
-
-        > Backup                              | #{@backup}
-        > Output filename                     | #{@output_filename}
-
-        #{@google&.verbose_summary || ''}
-        #{summary_divider}
-      SUMMARY
-    end
-
-    # @return [String]
-    def to_s
-      "Options(create_if_not_exists: #{@create_if_not_exists}, google: #{@google}, key_values: #{@key_values}, " \
-        "offset: #{@offset}, sheet_name: #{@sheet_name}, verbose: #{@verbose})"
-    end
-
-    private
-
-    def summary_divider
-      '========================================================================='
+    # @return [Options::Options]
+    def self.from_cli_flags(flags, input_filename)
+      sheet_name = flags[:'sheet-name'] || input_filename.sub_ext('').to_s
+      if (google_sheet_id = flags[:'google-sheet-id'])
+        ::CSVPlusPlus::Options::GoogleSheetsOptions.new(sheet_name, google_sheet_id)
+      elsif (output_filename = flags[:output])
+        ::CSVPlusPlus::Options::FileOptions.new(sheet_name, output_filename)
+      else
+        raise(::CSVPlusPlus::Error::CLIError, 'You must supply either -o/--output or -g/-google-sheet-id')
+      end
     end
   end
 end
+
+require_relative './options/options'
+
+require_relative './options/file_options'
+require_relative './options/google_sheets_options'