csv_plus_plus 0.1.1 → 0.1.3

data/lib/csv_plus_plus/entities/entity_with_arguments.rb

@@ -0,0 +1,57 @@
+# typed: strict
+# frozen_string_literal: true
+
+module CSVPlusPlus
+  module Entities
+    # An entity that can take other entities as arguments.  Current use cases for this
+    # are function calls and function definitions
+    #
+    # @attr_reader arguments [Array<Entity>] The arguments supplied to this entity.
+    class EntityWithArguments < Entity
+      extend ::T::Sig
+
+      abstract!
+
+      sig { returns(::T::Array[::CSVPlusPlus::Entities::Entity]) }
+      attr_reader :arguments
+
+      sig do
+        params(
+          type: ::CSVPlusPlus::Entities::Type,
+          id: ::T.nilable(::Symbol),
+          arguments: ::T::Array[::CSVPlusPlus::Entities::Entity]
+        ).void
+      end
+      # @param type [Entities::Type]
+      # @param id [::String]
+      # @param arguments [Array<Entity>]
+      def initialize(type, id: nil, arguments: [])
+        super(type, id:)
+        @arguments = arguments
+      end
+
+      sig { override.params(other: ::CSVPlusPlus::Entities::Entity).returns(::T::Boolean) }
+      # @param other [Entity]
+      #
+      # @return [boolean]
+      def ==(other)
+        return false unless other.is_a?(self.class)
+
+        @arguments == other.arguments && super
+      end
+
+      protected
+
+      sig do
+        params(arguments: ::T::Array[::CSVPlusPlus::Entities::Entity])
+          .returns(::T::Array[::CSVPlusPlus::Entities::Entity])
+      end
+      attr_writer :arguments
+
+      sig { params(runtime: ::CSVPlusPlus::Runtime::Runtime).returns(::T::Array[::String]) }
+      def evaluate_arguments(runtime)
+        @arguments.map { |arg| arg.evaluate(runtime) }
+      end
+    end
+  end
+end

data/lib/csv_plus_plus/entities/function.rb

@@ -0,0 +1,45 @@
+# typed: strict
+# frozen_string_literal: true
+
+module CSVPlusPlus
+  module Entities
+    # A function definition
+    #
+    # @attr_reader body [Entity] The body of the function.  +body+ can contain variable references
+    #   from +@arguments+
+    class Function < EntityWithArguments
+      extend ::T::Sig
+
+      sig { returns(::CSVPlusPlus::Entities::Entity) }
+      attr_reader :body
+
+      sig { params(id: ::Symbol, arguments: ::T::Array[::Symbol], body: ::CSVPlusPlus::Entities::Entity).void }
+      # @param id [Symbol] the name of the function - what it will be callable by
+      # @param arguments [Array<Symbol>]
+      # @param body [Entity]
+      def initialize(id, arguments, body)
+        super(::CSVPlusPlus::Entities::Type::Function, id:, arguments: arguments.map(&:to_sym))
+
+        @body = ::T.let(body, ::CSVPlusPlus::Entities::Entity)
+      end
+
+      sig { override.params(runtime: ::CSVPlusPlus::Runtime::Runtime).returns(::String) }
+      # @param runtime [Runtime]
+      #
+      # @return [::String]
+      def evaluate(runtime)
+        "def #{@id.to_s.upcase}(#{arguments.map(&:to_s).join(', ')}) #{@body.evaluate(runtime)}"
+      end
+
+      sig { override.params(other: ::CSVPlusPlus::Entities::Entity).returns(::T::Boolean) }
+      # @param other [Entity]
+      #
+      # @return [::T::Boolean]
+      def ==(other)
+        return false unless super
+
+        other.is_a?(self.class) && @body == other.body
+      end
+    end
+  end
+end

data/lib/csv_plus_plus/entities/function_call.rb

@@ -0,0 +1,50 @@
+# typed: strict
+# frozen_string_literal: true
+
+module CSVPlusPlus
+  module Entities
+    # A function call that can be either infix (A + B) or prefix (ADD(A, B))
+    #
+    # @attr_reader infix [boolean] Whether or not this function call is infix (X * Y, A + B, etc)
+    class FunctionCall < EntityWithArguments
+      extend ::T::Sig
+
+      sig { returns(::T::Boolean) }
+      attr_reader :infix
+
+      sig { params(id: ::Symbol, arguments: ::T::Array[::CSVPlusPlus::Entities::Entity], infix: ::T::Boolean).void }
+      # @param id [::String] The name of the function
+      # @param arguments [Array<Entity>] The arguments to the function
+      # @param infix [T::Boolean] Whether the function is infix
+      def initialize(id, arguments, infix: false)
+        super(::CSVPlusPlus::Entities::Type::FunctionCall, id:, arguments:)
+
+        @infix = infix
+      end
+
+      sig { override.params(runtime: ::CSVPlusPlus::Runtime::Runtime).returns(::String) }
+      # @param runtime [Runtime]
+      #
+      # @return [::String]
+      def evaluate(runtime)
+        evaluated_arguments = evaluate_arguments(runtime)
+
+        if @infix
+          "(#{evaluated_arguments.join(" #{@id} ")})"
+        else
+          "#{@id.to_s.upcase}(#{evaluated_arguments.join(', ')})"
+        end
+      end
+
+      sig { override.params(other: ::CSVPlusPlus::Entities::Entity).returns(::T::Boolean) }
+      # @param other [Entity]
+      #
+      # @return [boolean]
+      def ==(other)
+        return false unless super
+
+        other.is_a?(self.class) && @id == other.id && @infix == other.infix
+      end
+    end
+  end
+end

data/lib/csv_plus_plus/entities/number.rb

@@ -0,0 +1,48 @@
+# typed: strict
+# frozen_string_literal: true
+
+module CSVPlusPlus
+  module Entities
+    # A number value
+    #
+    # @attr_reader value [Numeric] The parsed number value
+    class Number < Entity
+      sig { returns(::Numeric) }
+      attr_reader :value
+
+      sig { params(value: ::T.any(::String, ::Numeric)).void }
+      # @param value [String, Numeric] Either a +String+ that looks like a number, or an already parsed Numeric
+      def initialize(value)
+        super(::CSVPlusPlus::Entities::Type::Number)
+
+        @value =
+          ::T.let(
+            (if value.is_a?(::String)
+               value.include?('.') ? Float(value) : Integer(value, 10)
+             else
+               value
+             end),
+            ::Numeric
+          )
+      end
+
+      sig { override.params(_runtime: ::CSVPlusPlus::Runtime::Runtime).returns(::String) }
+      # @param _runtime [Runtime]
+      #
+      # @return [::String]
+      def evaluate(_runtime)
+        @value.to_s
+      end
+
+      sig { override.params(other: ::CSVPlusPlus::Entities::Entity).returns(::T::Boolean) }
+      # @param other [Entity]
+      #
+      # @return [::T::Boolean]
+      def ==(other)
+        return false unless super
+
+        other.is_a?(self.class) && @value == other.value
+      end
+    end
+  end
+end

data/lib/csv_plus_plus/entities/runtime_value.rb

@@ -0,0 +1,43 @@
+# typed: strict
+# frozen_string_literal: true
+
+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
+      extend ::T::Sig
+
+      sig { returns(::T::Array[::T.untyped]) }
+      attr_reader :arguments
+
+      sig { returns(::T.proc.params(arg0: ::CSVPlusPlus::Runtime::Runtime).returns(::CSVPlusPlus::Entities::Entity)) }
+      attr_reader :resolve_fn
+
+      sig do
+        params(
+          resolve_fn: ::T.proc.params(arg0: ::CSVPlusPlus::Runtime::Runtime).returns(::CSVPlusPlus::Entities::Entity),
+          arguments: ::T::Array[::T.untyped]
+        ).void
+      end
+      # @param resolve_fn [lambda] A lambda that is called when the runtime value is resolved
+      # @param arguments [Any] Arguments to the runtime value call
+      def initialize(resolve_fn, arguments: [])
+        super(::CSVPlusPlus::Entities::Type::RuntimeValue)
+
+        @arguments = arguments
+        @resolve_fn = resolve_fn
+      end
+
+      sig { override.params(_runtime: ::CSVPlusPlus::Runtime::Runtime).returns(::String) }
+      # @param _runtime [Runtime]
+      #
+      # @return [String]
+      def evaluate(_runtime)
+        '(runtime value)'
+      end
+    end
+  end
+end

data/lib/csv_plus_plus/entities/string.rb

@@ -0,0 +1,42 @@
+# typed: strict
+# frozen_string_literal: true
+
+module CSVPlusPlus
+  module Entities
+    # A string value
+    #
+    # @attr_reader value [String]
+    class String < 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(::CSVPlusPlus::Entities::Type::String)
+
+        @value = ::T.let(value.gsub(/^"|"$/, ''), ::String)
+      end
+
+      sig { override.params(_runtime: ::CSVPlusPlus::Runtime::Runtime).returns(::String) }
+      # @param _runtime [Runtime]
+      #
+      # @return [::String]
+      def evaluate(_runtime)
+        "\"#{@value}\""
+      end
+
+      sig { override.params(other: ::CSVPlusPlus::Entities::Entity).returns(::T::Boolean) }
+      # @param other [Entity]
+      #
+      # @return [T::Boolean]
+      def ==(other)
+        return false unless super
+
+        other.is_a?(self.class) && @value == other.value
+      end
+    end
+  end
+end

data/lib/csv_plus_plus/entities/variable.rb

@@ -0,0 +1,37 @@
+# typed: strict
+# frozen_string_literal: true
+
+module CSVPlusPlus
+  module Entities
+    # TODO: get rid of this I think - everything will just be References
+    #
+    # A reference to a variable
+    class Variable < Entity
+      extend ::T::Sig
+
+      sig { params(id: ::Symbol).void }
+      # @param id [Symbol] The identifier of the variable
+      def initialize(id)
+        super(::CSVPlusPlus::Entities::Type::Variable, id:)
+      end
+
+      sig { override.params(_runtime: ::CSVPlusPlus::Runtime::Runtime).returns(::String) }
+      # @param _runtime [Runtime]
+      #
+      # @return [::String]
+      def evaluate(_runtime)
+        "$$#{@id}"
+      end
+
+      sig { override.params(other: ::CSVPlusPlus::Entities::Entity).returns(::T::Boolean) }
+      # @param other [Entity]
+      #
+      # @return [boolean]
+      def ==(other)
+        return false unless super
+
+        other.is_a?(self.class) && @id == other.id
+      end
+    end
+  end
+end

data/lib/csv_plus_plus/entities.rb

@@ -0,0 +1,40 @@
+# typed: strict
+# frozen_string_literal: true
+
+require_relative 'entities/entity'
+require_relative 'entities/entity_with_arguments'
+
+require_relative 'entities/boolean'
+require_relative 'entities/cell_reference'
+require_relative 'entities/date'
+require_relative 'entities/function'
+require_relative 'entities/function_call'
+require_relative 'entities/number'
+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
+    extend ::T::Sig
+
+    # A primitive type.  These all correspond to an implementation of the same name in the CSVPlusPlus::Entities module.
+    class Type < ::T::Enum
+      enums do
+        Boolean = new
+        CellReference = new
+        Date = new
+        Function = new
+        FunctionCall = new
+        Number = new
+        RuntimeValue = new
+        String = new
+        Variable = new
+      end
+    end
+  end
+end
+
+require_relative 'entities/ast_builder'
+require_relative 'entities/builtins'

data/lib/csv_plus_plus/error/error.rb

@@ -0,0 +1,20 @@
+# 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
+      extend ::T::Sig
+      extend ::T::Helpers
+
+      sig { returns(::String) }
+      # Return an error message for display to a command-line user.
+      #
+      # @return [::String]
+      def error_message
+        message
+      end
+    end
+  end
+end

data/lib/csv_plus_plus/error/formula_syntax_error.rb

@@ -0,0 +1,37 @@
+# typed: true
+# 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
+
+      # You must supply either a +choices+ or +message+
+      #
+      # @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)
+        @bad_input = bad_input
+        @message = message
+
+        super(runtime, wrapped_error:)
+      end
+
+      # Create a relevant error message given +@bad_input+ and +@message+.
+      #
+      # @return [::String]
+      def error_message
+        "#{@message}: \"#{@bad_input}\""
+      end
+    end
+  end
+end

data/lib/csv_plus_plus/error/modifier_syntax_error.rb

@@ -0,0 +1,75 @@
+# 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
+      extend ::T::Sig
+
+      sig { returns(::String) }
+      attr_reader :bad_input
+
+      sig { returns(::String) }
+      attr_reader :message
+
+      sig { returns(::T.nilable(::Symbol)) }
+      attr_reader :modifier
+
+      sig do
+        params(
+          runtime: ::CSVPlusPlus::Runtime::Runtime,
+          modifier_validation_error: ::CSVPlusPlus::Error::ModifierValidationError
+        ).returns(::CSVPlusPlus::Error::ModifierSyntaxError)
+      end
+      # Create a +ModifierSyntaxError+ given a +runtime+ and +ModifierValidationError+.
+      #
+      # @param runtime [Runtime]
+      # @param modifier_validation_error [ModifierValidationError]
+      #
+      # @return [ModifierSyntaxError]
+      def self.from_validation_error(runtime, modifier_validation_error)
+        new(
+          runtime,
+          modifier: modifier_validation_error.modifier,
+          bad_input: modifier_validation_error.bad_input,
+          message: modifier_validation_error.message,
+          wrapped_error: modifier_validation_error
+        )
+      end
+
+      sig do
+        params(
+          runtime: ::CSVPlusPlus::Runtime::Runtime,
+          bad_input: ::String,
+          message: ::String,
+          modifier: ::T.nilable(::Symbol),
+          wrapped_error: ::T.nilable(::StandardError)
+        ).void
+      end
+      # @param runtime [Runtime] The current runtime
+      # @param wrapped_error [ModifierValidationError] The validtion error that this is wrapping
+      def initialize(runtime, bad_input:, message:, modifier: nil, wrapped_error: nil)
+        @bad_input = bad_input
+        @modifier = modifier
+        @message = message
+
+        super(runtime, wrapped_error:)
+      end
+
+      sig { override.returns(::String) }
+      # 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/error/modifier_validation_error.rb

@@ -0,0 +1,69 @@
+# typed: strict
+# frozen_string_literal: true
+
+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
+      extend ::T::Sig
+
+      sig { returns(::String) }
+      attr_reader :bad_input
+
+      sig { returns(::T.nilable(::T.class_of(::T::Enum))) }
+      attr_reader :choices
+
+      sig { returns(::String) }
+      attr_reader :message
+
+      sig { returns(::Symbol) }
+      attr_reader :modifier
+
+      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
+      # rubocop:disable Metrics/MethodLength
+      def initialize(modifier, bad_input:, choices: nil, message: nil)
+        @bad_input = bad_input
+        @choices = choices
+        @modifier = modifier
+
+        @message = ::T.let(
+          if @choices
+            "must be one of (#{@choices.values.map(&:serialize).join(', ')})"
+          else
+            ::T.must(message)
+          end,
+          ::String
+        )
+
+        super(@message)
+      end
+      # rubocop:enable Metrics/MethodLength
+
+      sig { returns(::String) }
+      # A user-facing error message
+      #
+      # @return [::String]
+      def error_message
+        @message
+      end
+    end
+  end
+end

data/lib/csv_plus_plus/error/syntax_error.rb

@@ -0,0 +1,71 @@
+# typed: strict
+# frozen_string_literal: true
+
+module CSVPlusPlus
+  module Error
+    # An error that can be thrown for various syntax errors
+    class SyntaxError < ::CSVPlusPlus::Error::Error
+      extend ::T::Sig
+
+      sig { params(runtime: ::CSVPlusPlus::Runtime::Runtime, wrapped_error: ::T.nilable(::StandardError)).void }
+      # @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(runtime, wrapped_error: nil)
+        @runtime = runtime
+        @wrapped_error = wrapped_error
+
+        super()
+      end
+
+      sig { returns(::String) }
+      # @return [::String]
+      def to_s
+        to_trace
+      end
+
+      # TODO: clean up all these different string-formatting error classes
+      sig { override.returns(::String) }
+      # @return [::String]
+      def error_message
+        ''
+      end
+
+      sig { returns(::String) }
+      # Output a verbose user-helpful string that references the current runtime
+      def to_verbose_trace
+        warn(@wrapped_error.full_message) if @wrapped_error
+        warn((@wrapped_error.backtrace || []).join("\n")) if @wrapped_error&.backtrace
+        to_trace
+      end
+
+      sig { returns(::String) }
+      # Output a user-helpful string that references the runtime state
+      #
+      # @return [String]
+      def to_trace
+        "#{message_prefix}#{cell_index} #{error_message}"
+      end
+
+      private
+
+      sig { returns(::String) }
+      def cell_index
+        if @runtime.parsing_csv_section?
+          "[#{@runtime.row_index},#{@runtime.cell_index}]"
+        else
+          ''
+        end
+      end
+
+      sig { returns(::String) }
+      def message_prefix
+        line_number = @runtime.line_number
+        filename = @runtime.source_code.filename
+
+        line_str = ":#{line_number}"
+        "#{filename}#{line_str}"
+      end
+    end
+  end
+end

data/lib/csv_plus_plus/error/writer_error.rb

@@ -0,0 +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 template: #{message}"
+      end
+    end
+  end
+end

data/lib/csv_plus_plus/error.rb

@@ -1,7 +1,15 @@
+# typed: strict
 # 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