csv_plus_plus 0.1.2 → 0.2.0

data/lib/csv_plus_plus/entities/runtime_value.rb

@@ -1,25 +1,55 @@
+# typed: strict
 # frozen_string_literal: true
 
+require_relative './entity'
+
 module CSVPlusPlus
   module Entities
-    # A runtime value. These are values which can be materialized at any point via the +resolve_fn+
-    # which takes an ExecutionContext as a param
-    #
-    # @attr_reader resolve_fn [lambda] A lambda that is called when the runtime value is resolved
-    class RuntimeValue < Entity
-      attr_reader :arguments, :resolve_fn
+    # A runtime value. These are values which can be materialized at any point via the +resolve_fn+ which
+    # will provide a value depending on the +Runtime+'s current state.
+    class RuntimeValue < ::CSVPlusPlus::Entities::Entity
+      extend ::T::Sig
 
-      # @param resolve_fn [lambda] A lambda that is called when the runtime value is resolved
-      def initialize(resolve_fn, arguments: nil)
-        super(:runtime_value)
+      ResolveFn =
+        ::T.type_alias do
+          ::T.proc.params(
+            position: ::CSVPlusPlus::Runtime::Position,
+            arguments: ::T::Enumerable[::CSVPlusPlus::Entities::Entity]
+          ).returns(::CSVPlusPlus::Entities::Entity)
+        end
+      public_constant :ResolveFn
 
-        @arguments = arguments
+      sig do
+        params(resolve_fn: ::CSVPlusPlus::Entities::RuntimeValue::ResolveFn).void
+      end
+      # @param resolve_fn [lambda] A lambda that is called when the runtime value is resolved
+      def initialize(resolve_fn)
         @resolve_fn = resolve_fn
+        super()
+      end
+
+      sig do
+        params(
+          position: ::CSVPlusPlus::Runtime::Position,
+          arguments: ::T::Enumerable[::CSVPlusPlus::Entities::Entity]
+        ).returns(::CSVPlusPlus::Entities::Entity)
+      end
+      # Using the +@resolve_fn+, evaluate this runtime value into an +Entity+ that can be later evaluated
+      def call(position, arguments)
+        @resolve_fn.call(position, arguments)
       end
 
-      # @return [String]
-      def to_s
-        '(runtime_value)'
+      sig { override.params(_position: ::CSVPlusPlus::Runtime::Position).returns(::String) }
+      # Given the current runtime, call +@resolve_fn+ to produce a value
+      #
+      # @param _position [Position]
+      #
+      # @return [Entities::Entity]
+      def evaluate(_position)
+        # TODO: we can do a check on arguments here and make sure that the RuntimeValue is being called
+        # with the number of arguments it requires
+        # @resolve_fn.call(position, ::T.must(arguments)).evaluate(position)
+        '(runtime value)'
       end
     end
   end

data/lib/csv_plus_plus/entities/string.rb

@@ -1,3 +1,4 @@
+# typed: strict
 # frozen_string_literal: true
 
 module CSVPlusPlus
@@ -5,24 +6,39 @@ module CSVPlusPlus
     # A string value
     #
     # @attr_reader value [String]
-    class String < Entity
+    class String < ::CSVPlusPlus::Entities::Entity
+      extend ::T::Sig
+
+      sig { returns(::String) }
       attr_reader :value
 
+      sig { params(value: ::String).void }
       # @param value [String] The string that has been parsed out of the template
       def initialize(value)
-        super(:string)
+        super()
 
-        @value = value.gsub(/^"|"$/, '')
+        @value = ::T.let(value.gsub(/^"|"$/, ''), ::String)
       end
 
-      # @return [String]
-      def to_s
+      sig { override.params(_position: ::CSVPlusPlus::Runtime::Position).returns(::String) }
+      # @param _position [Position]
+      #
+      # @return [::String]
+      def evaluate(_position)
         "\"#{@value}\""
       end
 
-      # @return [boolean]
+      sig { override.params(other: ::BasicObject).returns(::T::Boolean) }
+      # @param other [BasicObject]
+      #
+      # @return [T::Boolean]
       def ==(other)
-        super && value == other.value
+        case other
+        when self.class
+          @value == other.value
+        else
+          false
+        end
       end
     end
   end

data/lib/csv_plus_plus/entities.rb

@@ -1,31 +1,22 @@
+# typed: strict
 # frozen_string_literal: true
 
+require_relative 'entities/entity'
+require_relative 'entities/entity_with_arguments'
+require_relative 'entities/has_identifier'
+
 require_relative 'entities/boolean'
-require_relative 'entities/cell_reference'
 require_relative 'entities/date'
-require_relative 'entities/entity'
 require_relative 'entities/function'
 require_relative 'entities/function_call'
 require_relative 'entities/number'
+require_relative 'entities/reference'
 require_relative 'entities/runtime_value'
 require_relative 'entities/string'
-require_relative 'entities/variable'
 
 module CSVPlusPlus
+  # The entities that form abstract syntax trees which make up the language
   module Entities
-    TYPES = {
-      boolean: ::CSVPlusPlus::Entities::Boolean,
-      cell_reference: ::CSVPlusPlus::Entities::CellReference,
-      date: ::CSVPlusPlus::Entities::Date,
-      function: ::CSVPlusPlus::Entities::Function,
-      function_call: ::CSVPlusPlus::Entities::FunctionCall,
-      number: ::CSVPlusPlus::Entities::Number,
-      runtime_value: ::CSVPlusPlus::Entities::RuntimeValue,
-      string: ::CSVPlusPlus::Entities::String,
-      variable: ::CSVPlusPlus::Entities::Variable
-    }.freeze
-
-    public_constant :TYPES
   end
 end
 

data/lib/csv_plus_plus/error/cli_error.rb

@@ -0,0 +1,17 @@
+# typed: strict
+# frozen_string_literal: true
+
+module CSVPlusPlus
+  module Error
+    # An error that represents an invalid CLI option or state
+    class CLIError < ::CSVPlusPlus::Error::Error
+      extend ::T::Sig
+
+      sig { override.returns(::String) }
+      # @return [String]
+      def error_message
+        message
+      end
+    end
+  end
+end

data/lib/csv_plus_plus/error/compiler_error.rb

@@ -0,0 +1,17 @@
+# typed: strict
+# frozen_string_literal: true
+
+module CSVPlusPlus
+  module Error
+    # An error that represents an invalid state during compilation.
+    class CompilerError < ::CSVPlusPlus::Error::Error
+      extend ::T::Sig
+
+      sig { override.returns(::String) }
+      # @return [String]
+      def error_message
+        message
+      end
+    end
+  end
+end

data/lib/csv_plus_plus/error/error.rb

@@ -1,10 +1,33 @@
+# typed: strict
 # frozen_string_literal: true
 
 module CSVPlusPlus
   module Error
     # An error thrown by our code (generally to be handled at the top level bin/ command)
-    class Error < StandardError
-      # TODO: perhaps give this a better name? something more descriptive than just Error
+    class Error < ::StandardError
+      extend ::T::Sig
+      extend ::T::Helpers
+
+      abstract!
+
+      sig { returns(::T.nilable(::StandardError)) }
+      attr_reader :wrapped_error
+
+      sig { params(message: ::String, wrapped_error: ::T.nilable(::StandardError)).void }
+      # @param wrapped_error [StandardError] The underlying error that caused the syntax error.  For example a
+      #   Racc::ParseError that was thrown
+      def initialize(message, wrapped_error: nil)
+        super(message)
+
+        @message = message
+        @wrapped_error = wrapped_error
+      end
+
+      sig { abstract.returns(::String) }
+      # Return an error message for display to a command-line user.
+      #
+      # @return [::String]
+      def error_message; end
     end
   end
 end

data/lib/csv_plus_plus/error/formula_syntax_error.rb

@@ -1,35 +1,35 @@
+# typed: strict
 # frozen_string_literal: true
 
-require_relative './syntax_error'
-
 module CSVPlusPlus
   module Error
     # An error that can be thrown when there is an error parsing a modifier
     #
     # @attr_reader message [::String] A helpful error message
     # @attr_reader bad_input [String] The offending input that caused the error to be thrown
-    class FormulaSyntaxError < ::CSVPlusPlus::Error::SyntaxError
-      attr_reader :message, :bad_input
+    class FormulaSyntaxError < ::CSVPlusPlus::Error::Error
+      extend ::T::Sig
+      include ::CSVPlusPlus::Error::PositionalError
 
-      # You must supply either a +choices+ or +message+
-      #
+      sig { returns(::String) }
+      attr_reader :bad_input
+
+      sig { params(message: ::String, bad_input: ::String, wrapped_error: ::T.nilable(::StandardError)).void }
       # @param message [String] A relevant message to show
       # @param bad_input [String] The offending input that caused the error to be thrown
-      # @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)
+      def initialize(message, bad_input:, wrapped_error: nil)
+        super(message, wrapped_error:)
         @bad_input = bad_input
-        @message = message
-
-        super(runtime, wrapped_error:)
       end
 
+      sig { override.returns(::String) }
       # Create a relevant error message given +@bad_input+ and +@message+.
       #
       # @return [::String]
       def error_message
-        "#{@message}: \"#{@bad_input}\""
+        "#{message}: \"#{bad_input}\""
       end
     end
   end

data/lib/csv_plus_plus/error/modifier_syntax_error.rb

@@ -1,26 +1,48 @@
+# typed: strict
 # frozen_string_literal: true
 
-require_relative './syntax_error'
-
 module CSVPlusPlus
   module Error
-    # An Error that wraps a +ModifierValidationError+ with a +Runtime+.
-    class ModifierSyntaxError < ::CSVPlusPlus::Error::SyntaxError
-      # You must supply either a +choices+ or +message+
-      #
-      # @param runtime [Runtime] The current runtime
+    # A syntax error encountered when parsing a modifier definition
+    class ModifierSyntaxError < ::CSVPlusPlus::Error::Error
+      extend ::T::Sig
+      include ::CSVPlusPlus::Error::PositionalError
+
+      sig { returns(::String) }
+      attr_reader :bad_input
+
+      sig { returns(::T.nilable(::Symbol)) }
+      attr_reader :modifier
+
+      sig do
+        params(
+          message: ::String,
+          bad_input: ::String,
+          modifier: ::T.nilable(::Symbol),
+          wrapped_error: ::T.nilable(::StandardError)
+        ).void
+      end
+      # @param message [String] The error message
+      # @param bad_input [String] The offending input
+      # @param modifier [Symbol] The modifier being parsed
       # @param wrapped_error [ModifierValidationError] The validtion error that this is wrapping
-      def initialize(runtime, wrapped_error:)
-        @wrapped_error = wrapped_error
+      def initialize(message, bad_input:, modifier: nil, wrapped_error: nil)
+        super(message, wrapped_error:)
 
-        super(runtime, wrapped_error:)
+        @bad_input = bad_input
+        @modifier = modifier
       end
 
-      # Calls +wrapped_error.error_message+.
+      sig { override.returns(::String) }
+      # Create a relevant error message given +@choices+ or +@message+ (one of them must be supplied).
       #
       # @return [::String]
       def error_message
-        @wrapped_error.error_message
+        <<~ERROR_MESSAGE
+          Error parsing modifier: [[#{@modifier}=...]]
+          Bad input: #{@bad_input}
+          Reason: #{@message}
+        ERROR_MESSAGE
       end
     end
   end

data/lib/csv_plus_plus/error/modifier_validation_error.rb

@@ -1,7 +1,6 @@
+# typed: strict
 # 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.
@@ -10,39 +9,34 @@ module CSVPlusPlus
     # @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
+    class ModifierValidationError < ::CSVPlusPlus::Error::ModifierSyntaxError
+      extend ::T::Sig
+      include ::CSVPlusPlus::Error::PositionalError
 
+      sig do
+        params(
+          modifier: ::Symbol,
+          bad_input: ::String,
+          choices: ::T.nilable(::T.class_of(::T::Enum)),
+          message: ::T.nilable(::String)
+        ).void
+      end
       # 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(', ')})"
+      def initialize(modifier, bad_input:, choices: nil, message: nil)
+        message = ::T.let(
+          if choices
+            "must be one of (#{choices.values.map(&:serialize).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
+            ::T.must(message)
+          end,
+          ::String
+        )
+        super(message, bad_input:, modifier:)
       end
     end
   end

data/lib/csv_plus_plus/error/positional_error.rb

@@ -0,0 +1,15 @@
+# typed: strict
+# frozen_string_literal: true
+
+module CSVPlusPlus
+  module Error
+    # Methods that can be included into a class to denote that it's result it dependent on the current
+    # +Runtime::Position+
+    module PositionalError
+      extend ::T::Sig
+      extend ::T::Helpers
+
+      interface!
+    end
+  end
+end

data/lib/csv_plus_plus/error/writer_error.rb

@@ -1,9 +1,17 @@
+# typed: strict
 # frozen_string_literal: true
 
 module CSVPlusPlus
   module Error
     # An error that can be thrown when writing a spreadsheet
     class WriterError < ::CSVPlusPlus::Error::Error
+      extend ::T::Sig
+
+      sig { override.returns(::String) }
+      # @return [::String]
+      def error_message
+        "Error writing csvpp template: #{message}"
+      end
     end
   end
 end

data/lib/csv_plus_plus/error.rb

@@ -1,10 +1,14 @@
+# typed: strict
 # frozen_string_literal: true
 
 require_relative './error/error'
+require_relative './error/positional_error'
+
+require_relative './error/cli_error'
+require_relative './error/compiler_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

data/lib/csv_plus_plus/error_formatter.rb

@@ -0,0 +1,111 @@
+# typed: strict
+# frozen_string_literal: true
+
+module CSVPlusPlus
+  # Handle any errors potentially thrown during compilation.  This could be anything from a user error (for example
+  # calling with invalid csvpp code) to an error calling Google Sheets API or writing to the filesystem.
+  class ErrorFormatter
+    extend ::T::Sig
+
+    sig do
+      params(options: ::CSVPlusPlus::Options::Options, runtime: ::CSVPlusPlus::Runtime::Runtime).void
+    end
+    # @param options [Options]
+    # @param runtime [Runtime::Runtime]
+    def initialize(options:, runtime:)
+      @options = options
+      @runtime = runtime
+    end
+
+    sig { params(error: ::StandardError).void }
+    # Nicely handle a given error.  How it's handled depends on if it's our error and if @options.verbose
+    #
+    # @param error [CSVPlusPlus::Error, Google::Apis::ClientError, StandardError]
+    def handle_error(error)
+      # make sure that we're on a newline (verbose mode will probably be in the middle of printing a benchmark)
+      puts("\n\n") if @options.verbose
+
+      case error
+      when ::CSVPlusPlus::Error::Error
+        handle_internal_error(error)
+      when ::Google::Apis::ClientError
+        handle_google_error(error)
+      else
+        unhandled_error(error)
+      end
+    end
+
+    private
+
+    sig { params(error: ::StandardError).void }
+    # An error was thrown that we weren't planning on
+    def unhandled_error(error)
+      warn(
+        <<~ERROR_MESSAGE)
+          An unexpected error was encountered.  Please try running again with --verbose and
+          report the error at: https://github.com/patrickomatic/csv-plus-plus/issues/new'
+        ERROR_MESSAGE
+
+      return unless @options.verbose
+
+      warn(error.full_message)
+      warn("Cause: #{error.cause}") if error.cause
+    end
+
+    sig { params(error: ::CSVPlusPlus::Error::Error).void }
+    def handle_internal_error(error)
+      warn(with_position(error))
+      handle_wrapped_error(::T.must(error.wrapped_error)) if error.wrapped_error
+    end
+
+    sig { params(wrapped_error: ::StandardError).void }
+    def handle_wrapped_error(wrapped_error)
+      return unless @options.verbose
+
+      warn(wrapped_error.full_message)
+      warn((wrapped_error.backtrace || []).join("\n")) if wrapped_error.backtrace
+    end
+
+    sig { params(error: ::Google::Apis::ClientError).void }
+    def handle_google_error(error)
+      warn("Error making Google Sheets API request: #{error.message}")
+      return unless @options.verbose
+
+      warn("#{error.status_code} Error making Google API request [#{error.message}]: #{error.body}")
+    end
+
+    sig { params(error: ::CSVPlusPlus::Error::Error).returns(::String) }
+    # Output a user-helpful string that references the runtime state
+    #
+    # @param error [Error::Error] The error message to be prefixed with a filename and position
+    #
+    # @return [String]
+    def with_position(error)
+      message = error.error_message
+      case error
+      when ::CSVPlusPlus::Error::PositionalError
+        "#{message_prefix}#{cell_index} #{message}"
+      else
+        message
+      end
+    end
+
+    sig { returns(::String) }
+    def cell_index
+      if @runtime.parsing_csv_section?
+        "[#{@runtime.position.row_index},#{@runtime.position.cell_index}]"
+      else
+        ''
+      end
+    end
+
+    sig { returns(::String) }
+    def message_prefix
+      line_number = @runtime.position.line_number
+      filename = @runtime.source_code.filename
+
+      line_str = ":#{line_number}"
+      "#{filename}#{line_str}"
+    end
+  end
+end

data/lib/csv_plus_plus/google_api_client.rb

@@ -1,24 +1,39 @@
+# typed: strict
 # frozen_string_literal: true
 
 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
+    extend ::T::Sig
+
+    sig { returns(::Google::Apis::SheetsV4::SheetsService) }
+    # Get a +Google::Apis::SheetsV4::SheetsService+ instance configured to connect 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)
-      end
+    def sheets_client
+      ::T.must(
+        @sheets_client ||= ::T.let(
+          ::Google::Apis::SheetsV4::SheetsService.new.tap do |s|
+            s.authorization = ::Google::Auth.get_application_default(['https://www.googleapis.com/auth/spreadsheets'].freeze)
+          end,
+          ::T.nilable(::Google::Apis::SheetsV4::SheetsService)
+        )
+      )
     end
 
-    # Get a +::Google::Apis::DriveV3::DriveService+ instance connected to the drive API
+    sig { returns(::Google::Apis::DriveV3::DriveService) }
+    # 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)
-      end
+    def drive_client
+      ::T.must(
+        @drive_client ||= ::T.let(
+          ::Google::Apis::DriveV3::DriveService.new.tap do |d|
+            d.authorization = ::Google::Auth.get_application_default(['https://www.googleapis.com/auth/drive.file'].freeze)
+          end,
+          ::T.nilable(::Google::Apis::DriveV3::DriveService)
+        )
+      )
     end
   end
 end