csv_plus_plus 0.1.1 → 0.1.3

data/lib/csv_plus_plus/modifier.rb

@@ -1,171 +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 borders [Array<String>] The borders that will be set
-  # @attr expand [Expand] Whether this row expands into multiple rows
-  # @attr fontfamily [String] The font family
-  # @attr fontsize [Number] The font size
-  # @attr halign ['left', 'center', 'right'] Horizontal alignment
-  # @attr note [String] A note/comment on the cell
-  # @attr numberformat [String] 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_writer borderstyle ['dashed', 'dotted', 'double', 'solid', 'solid_medium', 'solid_thick']
-  #   The style of border on the cell
-  #
-  # @attr_reader bordercolor [String]
-  # @attr_reader borders [Array<String>]
-  # @attr_reader color [Color] The background color of the cell
-  # @attr_reader fontcolor [Color] The font color of the cell
-  # @attr_reader formats [Array<String>] Bold/italics/underline/strikethrough formatting
-  class Modifier
-    attr_reader :bordercolor, :borders, :color, :fontcolor, :formats
-    attr_writer :borderstyle
-    attr_accessor :expand, :fontfamily, :fontsize, :halign, :valign, :note, :numberformat, :row_level, :validation
-
-    # @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
-
-    # Set the color
-    #
-    # @param hex_value [String]
-    #
-    # @return [Color]
-    def color=(hex_value)
-      @color = ::CSVPlusPlus::Color.new(hex_value)
-    end
+require_relative './modifier/conditional_formatting'
+require_relative './modifier/data_validation'
+require_relative './modifier/expand'
+require_relative './modifier/modifier'
 
-    # 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 the bordercolor
-    #
-    # @param hex_value [String] formatted as '#000000', '#000' or '000000'
-    def bordercolor=(hex_value)
-      @bordercolor = ::CSVPlusPlus::Color.new(hex_value)
-    end
-
-    # Are there any borders set?
-    #
-    # @return [Boolean]
-    def any_border?
-      !@borders.empty?
-    end
-
-    # Set the fontcolor
-    #
-    # @param hex_value [String] formatted as '#000000', '#000' or '000000'
-    def fontcolor=(hex_value)
-      @fontcolor = ::CSVPlusPlus::Color.new(hex_value)
-    end
-
-    # Set a text format (bolid, italic, underline or strikethrough)
-    #
-    # @param value ['bold', 'italic', 'underline', 'strikethrough']
-    def format=(value)
-      @formats << value
-    end
-
-    # 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
 
-    # Is this a cell-level modifier?
-    #
-    # @return [Boolean]
-    def cell_level?
-      !@row_level
+    # The possible values for a horizontal alignment
+    class VerticalAlign < ::T::Enum
+      enums do
+        Top = new
+        Bottom = new
+        Center = new
+      end
     end
 
-    # Style of border
+    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 [String]
-    def borderstyle
-      @borderstyle || 'solid'
-    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'

data/lib/csv_plus_plus/options.rb

@@ -1,8 +1,6 @@
+# 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)
   #
@@ -15,28 +13,80 @@ module CSVPlusPlus
   # @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
+    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
+
+    sig { returns(::T::Boolean) }
+    attr_accessor :backup
+
+    sig { returns(::T::Boolean) }
+    attr_accessor :create_if_not_exists
+
+    sig { returns(::T::Hash[::Symbol, ::String]) }
+    attr_accessor :key_values
+
+    sig { returns(::T::Array[::Integer]) }
+    attr_accessor :offset
+
+    sig { returns(::T.nilable(::String)) }
+    attr_accessor :output_filename
+
+    sig { returns(::T.nilable(::String)) }
+    attr_accessor :sheet_name
+
+    sig { returns(::T::Boolean) }
+    attr_accessor :verbose
+
+    sig { returns(::T.nilable(::CSVPlusPlus::GoogleOptions)) }
     attr_reader :google
 
-    # initialize
+    sig { void }
+    # Initialize a default +Options+ object
     def initialize
-      @offset = [0, 0]
-      @create_if_not_exists = false
-      @key_values = {}
-      @verbose = false
-      @backup = false
+      @offset = ::T.let([0, 0], ::T::Array[::Integer])
+      @create_if_not_exists = ::T.let(false, ::T::Boolean)
+      @key_values = ::T.let({}, ::T::Hash[::Symbol, ::String])
+      @verbose = ::T.let(false, ::T::Boolean)
+      @backup = ::T.let(false, ::T::Boolean)
+      @google = ::T.let(nil, ::T.nilable(::CSVPlusPlus::GoogleOptions))
     end
 
+    sig { params(sheet_id: ::String).returns(::CSVPlusPlus::GoogleOptions) }
     # 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
+    # @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]
+    # @return [::String]
     def google_sheet_id=(sheet_id)
       @google = ::CSVPlusPlus::GoogleOptions.new(sheet_id)
     end
 
+    sig { returns(::CSVPlusPlus::Options::OutputFormat) }
+    # Given the options, figure out which type of +OutputFormat+ we'll be writing to
+    #
+    # @return [Options::OutputFormat]
+    def output_format
+      return ::CSVPlusPlus::Options::OutputFormat::GoogleSheets if @google
+
+      case @output_filename
+      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::Error, "Unsupported file extension: #{@output_filename}")
+      end
+    end
+
+    sig { returns(::T.nilable(::String)) }
     # Returns an error string or nil if there are no validation problems
     #
     # @return [String, nil]
@@ -46,6 +96,7 @@ module CSVPlusPlus
       'You must supply either a Google Sheet ID or an output file'
     end
 
+    sig { returns(::String) }
     # Return a string with a verbose description of what we're doing with the options
     #
     # @return [String]
@@ -55,7 +106,6 @@ module CSVPlusPlus
 
         # 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]}
@@ -73,14 +123,9 @@ module CSVPlusPlus
       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
 
+    sig { returns(::String) }
     def summary_divider
       '========================================================================='
     end

data/lib/csv_plus_plus/{language → parser}/cell_value.tab.rb

@@ -7,14 +7,14 @@
 require 'racc/parser.rb'
 
   require_relative '../lexer'
-  require_relative '../language/ast_builder'
+  require_relative '../entities/ast_builder'
 
 module CSVPlusPlus
-  module Language
-    class CellValueParser < Racc::Parser
+  module Parser
+    class CellValue < Racc::Parser
 
-module_eval(<<'...end cell_value.y/module_eval...', 'cell_value.y', 48)
-  include ::CSVPlusPlus::Language::ASTBuilder
+module_eval(<<'...end cell_value.y/module_eval...', 'cell_value.y', 49)
+  include ::CSVPlusPlus::Entities::ASTBuilder
   include ::CSVPlusPlus::Lexer
 
   protected
@@ -201,7 +201,7 @@ Racc_debug_parser = false
 
 # reduce 0 omitted
 
-module_eval(<<'.,.,', 'cell_value.y', 20)
+module_eval(<<'.,.,', 'cell_value.y', 21)
   def _reduce_1(val, _values, result)
      @ast = val[1]
     result
@@ -212,86 +212,86 @@ module_eval(<<'.,.,', 'cell_value.y', 20)
 
 # reduce 3 omitted
 
-module_eval(<<'.,.,', 'cell_value.y', 24)
+module_eval(<<'.,.,', 'cell_value.y', 25)
   def _reduce_4(val, _values, result)
      result = val[1]
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'cell_value.y', 25)
+module_eval(<<'.,.,', 'cell_value.y', 26)
   def _reduce_5(val, _values, result)
-     result = variable(val[1])
+     result = variable(val[1].to_sym)
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'cell_value.y', 26)
+module_eval(<<'.,.,', 'cell_value.y', 27)
   def _reduce_6(val, _values, result)
      result = string(val[0])
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'cell_value.y', 27)
+module_eval(<<'.,.,', 'cell_value.y', 28)
   def _reduce_7(val, _values, result)
      result = number(val[0])
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'cell_value.y', 28)
+module_eval(<<'.,.,', 'cell_value.y', 29)
   def _reduce_8(val, _values, result)
      result = boolean(true)
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'cell_value.y', 29)
+module_eval(<<'.,.,', 'cell_value.y', 30)
   def _reduce_9(val, _values, result)
      result = boolean(false)
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'cell_value.y', 30)
+module_eval(<<'.,.,', 'cell_value.y', 31)
   def _reduce_10(val, _values, result)
-     result = cell_reference(val[0])
+     result = cell_reference(ref: val[0])
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'cell_value.y', 32)
+module_eval(<<'.,.,', 'cell_value.y', 33)
   def _reduce_11(val, _values, result)
-     result = function_call(val[0], val[2])
+     result = function_call(val[0].to_sym, val[2])
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'cell_value.y', 33)
+module_eval(<<'.,.,', 'cell_value.y', 34)
   def _reduce_12(val, _values, result)
-     result = function_call(val[0], [])
+     result = function_call(val[0].to_sym, [])
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'cell_value.y', 35)
+module_eval(<<'.,.,', 'cell_value.y', 36)
   def _reduce_13(val, _values, result)
      result = val[0] << val[2]
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'cell_value.y', 36)
+module_eval(<<'.,.,', 'cell_value.y', 37)
   def _reduce_14(val, _values, result)
      result = [val[0]]
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'cell_value.y', 38)
+module_eval(<<'.,.,', 'cell_value.y', 39)
   def _reduce_15(val, _values, result)
-     result = function_call(val[1], [val[0], val[2]], infix: true)
+     result = function_call(val[1].to_sym, [val[0], val[2]], infix: true)
     result
   end
 .,.,
@@ -300,6 +300,6 @@ def _reduce_none(val, _values, result)
   val[0]
 end
 
-    end   # class CellValueParser
-  end   # module Language
+    end   # class CellValue
+  end   # module Parser
 end   # module CSVPlusPlus