csv_plus_plus 0.1.1 → 0.1.2

data/lib/csv_plus_plus/error/modifier_validation_error.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require_relative './syntax_error'
+
+module CSVPlusPlus
+  module Error
+    # An error that can be thrown when a modifier doesn't pass our validation.
+    #
+    # @attr_reader modifier [Symbol] The modifier being parsed when the bad input was encountered
+    # @attr_reader bad_input [String] The offending input that caused the error to be thrown
+    # @attr_reader choices [Array<Symbol>, nil] The choices that +value+ must be one of (but violated)
+    # @attr_reader message [String, nil] A relevant message to show
+    class ModifierValidationError < ::CSVPlusPlus::Error::Error
+      attr_reader :bad_input, :choices, :message, :modifier
+
+      # You must supply either a +choices+ or +message+
+      #
+      # @param modifier [Symbol] The modifier being parsed when the bad input was encountered
+      # @param bad_input [String] The offending input that caused the error to be thrown
+      # @param choices [Array<Symbol>, nil] The choices that +value+ must be one of (but violated)
+      # @param message [String, nil] A relevant message to show
+      def initialize(modifier, bad_input, choices: nil, message: nil)
+        @bad_input = bad_input
+        @choices = choices
+        @modifier = modifier
+
+        @message =
+          if @choices
+            "must be one of (#{@choices.map(&:to_s).join(', ')})"
+          else
+            message
+          end
+
+        super(@message)
+      end
+
+      # Create a relevant error message given +@choices+ or +@message+ (one of them must be supplied).
+      #
+      # @return [::String]
+      def error_message
+        <<~ERROR_MESSAGE
+          Error parsing modifier: [[#{@modifier}=...]]
+          Bad input: #{@bad_input}
+          Reason: #{@message}
+        ERROR_MESSAGE
+      end
+    end
+  end
+end

data/lib/csv_plus_plus/{language → error}/syntax_error.rb

@@ -1,21 +1,17 @@
 # frozen_string_literal: true
 
 module CSVPlusPlus
-  module Language
+  module Error
     # An error that can be thrown for various syntax errors
-    class SyntaxError < ::CSVPlusPlus::Error
-      # @param message [String] The primary message to be shown to the user
-      # @param bad_input [String] The offending input that caused the error to be thrown
+    class SyntaxError < ::CSVPlusPlus::Error::Error
       # @param runtime [Runtime] The current runtime
       # @param wrapped_error [StandardError] The underlying error that caused the syntax error.  For example a
       #   Racc::ParseError that was thrown
-      def initialize(message, bad_input, runtime, wrapped_error: nil)
-        @bad_input = bad_input.to_s
+      def initialize(runtime, wrapped_error: nil)
         @runtime = runtime
         @wrapped_error = wrapped_error
-        @message = message
 
-        super(message)
+        super()
       end
 
       # @return [String]
@@ -34,7 +30,7 @@ module CSVPlusPlus
       #
       # @return [String]
       def to_trace
-        "#{message_prefix}#{cell_index} #{message_postfix}"
+        "#{message_prefix}#{cell_index} #{error_message}"
       end
 
       private
@@ -55,11 +51,7 @@ module CSVPlusPlus
         filename = @runtime.filename
 
         line_str = line_number ? ":#{line_number}" : ''
-        "csv++ #{filename}#{line_str}"
-      end
-
-      def message_postfix
-        "#{@message}: \"#{@bad_input}\""
+        "#{filename}#{line_str}"
       end
     end
   end

data/lib/csv_plus_plus/error/writer_error.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module CSVPlusPlus
+  module Error
+    # An error that can be thrown when writing a spreadsheet
+    class WriterError < ::CSVPlusPlus::Error::Error
+    end
+  end
+end

data/lib/csv_plus_plus/error.rb

@@ -1,7 +1,14 @@
 # frozen_string_literal: true
 
+require_relative './error/error'
+require_relative './error/formula_syntax_error'
+require_relative './error/modifier_syntax_error'
+require_relative './error/modifier_validation_error'
+require_relative './error/syntax_error'
+require_relative './error/writer_error'
+
 module CSVPlusPlus
-  # An error thrown by our code (generally to be handled at the top level bin/ command)
-  class Error < StandardError
+  # A module containing errors to be raised
+  module Error
   end
 end

data/lib/csv_plus_plus/expand.rb

@@ -4,11 +4,13 @@ module CSVPlusPlus
   Expand =
     ::Struct.new(:repetitions) do
       # Does this infinitely expand?
+      #
+      # @return [boolean]
       def infinite?
         repetitions.nil?
       end
 
-      # to_s
+      # @return [::String]
       def to_s
         "Expand #{repetitions || 'infinity'}"
       end

data/lib/csv_plus_plus/google_api_client.rb

@@ -4,6 +4,8 @@ module CSVPlusPlus
   # A convenience wrapper around Google's REST API client
   module GoogleApiClient
     # Get a +::Google::Apis::SheetsV4::SheetsService+ instance connected to the sheets API
+    #
+    # @return [Google::Apis::SheetsV4::SheetsService]
     def self.sheets_client
       ::Google::Apis::SheetsV4::SheetsService.new.tap do |s|
         s.authorization = ::Google::Auth.get_application_default(['https://www.googleapis.com/auth/spreadsheets'].freeze)
@@ -11,6 +13,8 @@ module CSVPlusPlus
     end
 
     # Get a +::Google::Apis::DriveV3::DriveService+ instance connected to the drive API
+    #
+    # @return [Google::Apis::DriveV3::DriveService]
     def self.drive_client
       ::Google::Apis::DriveV3::DriveService.new.tap do |d|
         d.authorization = ::Google::Auth.get_application_default(['https://www.googleapis.com/auth/drive.file'].freeze)

data/lib/csv_plus_plus/lexer/lexer.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative '../color'
+
 module CSVPlusPlus
   # Common methods to be mixed into the Racc parsers
   #
@@ -32,17 +34,21 @@ module CSVPlusPlus
       do_parse
       return_value
     rescue ::Racc::ParseError => e
-      runtime.raise_syntax_error("Error parsing #{parse_subject}", e.message, wrapped_error: e)
+      runtime.raise_formula_syntax_error("Error parsing #{parse_subject}", e.message, wrapped_error: e)
+    rescue ::CSVPlusPlus::Error::ModifierValidationError => e
+      raise(::CSVPlusPlus::Error::ModifierSyntaxError.new(runtime, wrapped_error: e))
     end
 
     TOKEN_LIBRARY = {
-      TRUE: [/true/i, :TRUE],
+      A1_NOTATION: [::CSVPlusPlus::Entities::CellReference::A1_NOTATION_REGEXP, :A1_NOTATION],
       FALSE: [/false/i, :FALSE],
+      HEX_COLOR: [::CSVPlusPlus::Color::HEX_STRING_REGEXP, :HEX_COLOR],
+      ID: [/[$!\w:]+/, :ID],
+      INFIX_OP: [%r{\^|\+|-|\*|/|&|<|>|<=|>=|<>}, :INFIX_OP],
       NUMBER: [/-?[\d.]+/, :NUMBER],
       STRING: [%r{"(?:[^"\\]|\\(?:["\\/bfnrt]|u[0-9a-fA-F]{4}))*"}, :STRING],
-      INFIX_OP: [%r{\^|\+|-|\*|/|&|<|>|<=|>=|<>}, :INFIX_OP],
-      VAR_REF: [/\$\$/, :VAR_REF],
-      ID: [/[$!\w:]+/, :ID]
+      TRUE: [/true/i, :TRUE],
+      VAR_REF: [/\$\$/, :VAR_REF]
     }.freeze
     public_constant :TOKEN_LIBRARY
 
@@ -71,7 +77,8 @@ module CSVPlusPlus
       elsif tokenizer.scan_catchall
         @tokens << [tokenizer.last_match, tokenizer.last_match]
       else
-        runtime.raise_syntax_error("Unable to parse #{parse_subject} starting at", tokenizer.peek)
+        # TODO: this should raise a modifier_syntax_error if we're on the modifier parser
+        runtime.raise_formula_syntax_error("Unable to parse #{parse_subject} starting at", tokenizer.peek)
       end
     end
   end

data/lib/csv_plus_plus/modifier/conditional_formatting.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module CSVPlusPlus
+  module Modifier
+    # A class that handles the rules for modifiers to support conditional formatting.
+    class ConditionalFormatting
+      attr_reader :arguments, :condition, :invalid_reason
+
+      # @param value [::String] The unparsed conditional formatting rule
+      def initialize(value)
+        condition, args = value.split(/\si:\s*/)
+        @condition = condition.to_sym
+        @arguments = args.split(/\s+/)
+      end
+    end
+  end
+end

data/lib/csv_plus_plus/modifier.rb

@@ -3,30 +3,54 @@
 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 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 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
+  # @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 valign [:top, :center, :bottom] Vertical alignment
+  # @attr var [Symbol] The variable bound to this cell
   #
-  # @attr_writer borderstyle ['dashed', 'dotted', 'double', 'solid', 'solid_medium', 'solid_thick']
+  # @attr_writer borderstyle [:hashed, :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
+  # @attr_reader borders [Array<Symbol>]
+  # @attr_reader formats [Array<Symbol>] Bold/italics/underline/strikethrough formatting
   class Modifier
-    attr_reader :bordercolor, :borders, :color, :fontcolor, :formats
+    attr_accessor :bordercolor,
+                  :color,
+                  :expand,
+                  :fontcolor,
+                  :fontfamily,
+                  :fontsize,
+                  :halign,
+                  :valign,
+                  :note,
+                  :numberformat,
+                  :row_level,
+                  :validation,
+                  :var
+    attr_reader :borders, :formats
     attr_writer :borderstyle
-    attr_accessor :expand, :fontfamily, :fontsize, :halign, :valign, :note, :numberformat, :row_level, :validation
+
+    # 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)
@@ -36,70 +60,68 @@ module CSVPlusPlus
       @formats = ::Set.new
     end
 
-    # Set the color
+    # Are there any borders set?
     #
-    # @param hex_value [String]
+    # @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 [Color]
-    def color=(hex_value)
-      @color = ::CSVPlusPlus::Color.new(hex_value)
+    # @return [Boolean]
+    def cell_level?
+      !@row_level
     end
 
     # Assign a border
     #
-    # @param side ['top', 'left', 'bottom', 'right', 'all']
+    # @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']
+    # @param side [:top, :left, :bottom, :right, :all]
     #
-    # @return [Boolean]
+    # @return [boolean]
     def border_along?(side)
-      @borders.include?('all') || @borders.include?(side)
+      @borders.include?(:all) || @borders.include?(side)
     end
 
     # Does this have a border along all sides?
     #
-    # @return [Boolean]
+    # @return [boolean]
     def border_all?
-      @borders.include?('all') \
-        || (border_along?('top') && border_along?('bottom') && border_along?('left') && border_along?('right'))
+      @borders.include?(:all) \
+        || (border_along?(:top) && border_along?(:bottom) && border_along?(:left) && border_along?(:right))
     end
 
-    # Set the bordercolor
+    # Set this modifier to expand infinitely
     #
-    # @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)
+    # @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']
+    # @param value [:bold, :italic, :underline, :strikethrough]
     def format=(value)
       @formats << value
     end
 
     # Is the given format set?
     #
-    # @param type ['bold', 'italic', 'underline', 'strikethrough']
+    # @param type [:bold, :italic, :underline, :strikethrough]
     #
     # @return [Boolean]
     def formatted?(type)
@@ -115,7 +137,7 @@ module CSVPlusPlus
 
     # Is the row frozen?
     #
-    # @return [Boolean]
+    # @return [boolean]
     def frozen?
       @frozen
     end
@@ -129,26 +151,12 @@ module CSVPlusPlus
 
     # Is this a row-level modifier?
     #
-    # @return [Boolean]
+    # @return [boolean]
     def row_level?
       @row_level
     end
 
-    # Is this a cell-level modifier?
-    #
-    # @return [Boolean]
-    def cell_level?
-      !@row_level
-    end
-
-    # Style of border
-    #
-    # @return [String]
-    def borderstyle
-      @borderstyle || 'solid'
-    end
-
-    # @return [String]
+    # @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} " \

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,84 +212,84 @@ 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
   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
   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
   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
   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
@@ -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