csv_plus_plus 0.1.3 → 0.2.1

data/lib/csv_plus_plus/entities/entity_with_arguments.rb

@@ -7,50 +7,37 @@ module CSVPlusPlus
     # are function calls and function definitions
     #
     # @attr_reader arguments [Array<Entity>] The arguments supplied to this entity.
-    class EntityWithArguments < Entity
+    class EntityWithArguments < ::CSVPlusPlus::Entities::Entity
       extend ::T::Sig
+      extend ::T::Helpers
+      extend ::T::Generic
 
       abstract!
 
-      sig { returns(::T::Array[::CSVPlusPlus::Entities::Entity]) }
+      ArgumentsType = type_member
+      public_constant :ArgumentsType
+
+      sig { returns(::T::Array[::CSVPlusPlus::Entities::EntityWithArguments::ArgumentsType]) }
       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:)
+      sig { params(arguments: ::T::Array[::CSVPlusPlus::Entities::EntityWithArguments::ArgumentsType]).void }
+      # @param arguments [Array<ArgumentsType>]
+      def initialize(arguments: [])
+        super()
         @arguments = arguments
       end
 
-      sig { override.params(other: ::CSVPlusPlus::Entities::Entity).returns(::T::Boolean) }
+      sig { override.params(other: ::BasicObject).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) }
+        case other
+        when self.class
+          @arguments == other.arguments
+        else
+          false
+        end
       end
     end
   end

data/lib/csv_plus_plus/entities/function.rb

@@ -7,8 +7,15 @@ module CSVPlusPlus
     #
     # @attr_reader body [Entity] The body of the function.  +body+ can contain variable references
     #   from +@arguments+
-    class Function < EntityWithArguments
+    class Function < ::CSVPlusPlus::Entities::EntityWithArguments
       extend ::T::Sig
+      include ::CSVPlusPlus::Entities::HasIdentifier
+
+      ArgumentsType = type_member { { fixed: ::Symbol } }
+      public_constant :ArgumentsType
+
+      sig { returns(::Symbol) }
+      attr_reader :id
 
       sig { returns(::CSVPlusPlus::Entities::Entity) }
       attr_reader :body
@@ -18,27 +25,31 @@ module CSVPlusPlus
       # @param arguments [Array<Symbol>]
       # @param body [Entity]
       def initialize(id, arguments, body)
-        super(::CSVPlusPlus::Entities::Type::Function, id:, arguments: arguments.map(&:to_sym))
+        super(arguments: arguments.map(&:to_sym))
 
         @body = ::T.let(body, ::CSVPlusPlus::Entities::Entity)
+        @id = ::T.let(identifier(id), ::Symbol)
       end
 
-      sig { override.params(runtime: ::CSVPlusPlus::Runtime::Runtime).returns(::String) }
-      # @param runtime [Runtime]
+      sig { override.params(position: ::CSVPlusPlus::Runtime::Position).returns(::String) }
+      # @param position [Position]
       #
-      # @return [::String]
-      def evaluate(runtime)
-        "def #{@id.to_s.upcase}(#{arguments.map(&:to_s).join(', ')}) #{@body.evaluate(runtime)}"
+      # @return [String]
+      def evaluate(position)
+        "def #{@id.to_s.upcase}(#{arguments.map(&:to_s).join(', ')}) #{@body.evaluate(position)}"
       end
 
-      sig { override.params(other: ::CSVPlusPlus::Entities::Entity).returns(::T::Boolean) }
+      sig { override.params(other: ::BasicObject).returns(::T::Boolean) }
       # @param other [Entity]
       #
       # @return [::T::Boolean]
       def ==(other)
-        return false unless super
-
-        other.is_a?(self.class) && @body == other.body
+        case other
+        when self.class
+          @body == other.body && super
+        else
+          false
+        end
       end
     end
   end

data/lib/csv_plus_plus/entities/function_call.rb

@@ -8,26 +8,40 @@ module CSVPlusPlus
     # @attr_reader infix [boolean] Whether or not this function call is infix (X * Y, A + B, etc)
     class FunctionCall < EntityWithArguments
       extend ::T::Sig
+      include ::CSVPlusPlus::Entities::HasIdentifier
+
+      ArgumentsType = type_member { { fixed: ::CSVPlusPlus::Entities::Entity } }
+      public_constant :ArgumentsType
 
       sig { returns(::T::Boolean) }
       attr_reader :infix
 
-      sig { params(id: ::Symbol, arguments: ::T::Array[::CSVPlusPlus::Entities::Entity], infix: ::T::Boolean).void }
+      sig { returns(::Symbol) }
+      attr_reader :id
+
+      sig do
+        params(
+          id: ::Symbol,
+          arguments: ::T::Array[::CSVPlusPlus::Entities::FunctionCall::ArgumentsType],
+          infix: ::T::Boolean
+        ).void
+      end
       # @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:)
+        super(arguments:)
 
+        @id = ::T.let(identifier(id), ::Symbol)
         @infix = infix
       end
 
-      sig { override.params(runtime: ::CSVPlusPlus::Runtime::Runtime).returns(::String) }
-      # @param runtime [Runtime]
+      sig { override.params(position: ::CSVPlusPlus::Runtime::Position).returns(::String) }
+      # @param position [Position]
       #
       # @return [::String]
-      def evaluate(runtime)
-        evaluated_arguments = evaluate_arguments(runtime)
+      def evaluate(position)
+        evaluated_arguments = evaluate_arguments(position)
 
         if @infix
           "(#{evaluated_arguments.join(" #{@id} ")})"
@@ -36,14 +50,24 @@ module CSVPlusPlus
         end
       end
 
-      sig { override.params(other: ::CSVPlusPlus::Entities::Entity).returns(::T::Boolean) }
-      # @param other [Entity]
+      sig { override.params(other: ::BasicObject).returns(::T::Boolean) }
+      # @param other [BasicObject]
       #
-      # @return [boolean]
+      # @return [Boolean]
       def ==(other)
-        return false unless super
+        case other
+        when self.class
+          @id == other.id && @infix == other.infix
+        else
+          false
+        end
+      end
+
+      private
 
-        other.is_a?(self.class) && @id == other.id && @infix == other.infix
+      sig { params(position: ::CSVPlusPlus::Runtime::Position).returns(::T::Array[::String]) }
+      def evaluate_arguments(position)
+        @arguments.map { |arg| arg.evaluate(position) }
       end
     end
   end

data/lib/csv_plus_plus/entities/has_identifier.rb

@@ -0,0 +1,19 @@
+# typed: strict
+# frozen_string_literal: true
+
+module CSVPlusPlus
+  module Entities
+    # Can be included on any class that has a comparable id
+    module HasIdentifier
+      extend ::T::Sig
+
+      sig { params(symbol: ::Symbol).returns(::Symbol) }
+      # Variables and functions are case insensitive. I hate it but it's how excel is
+      #
+      # @param symbol [Symbol]
+      def identifier(symbol)
+        symbol.downcase
+      end
+    end
+  end
+end

data/lib/csv_plus_plus/entities/number.rb

@@ -6,14 +6,16 @@ module CSVPlusPlus
     # A number value
     #
     # @attr_reader value [Numeric] The parsed number value
-    class Number < Entity
+    class Number < ::CSVPlusPlus::Entities::Entity
+      extend ::T::Sig
+
       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)
+        super()
 
         @value =
           ::T.let(
@@ -26,22 +28,25 @@ module CSVPlusPlus
           )
       end
 
-      sig { override.params(_runtime: ::CSVPlusPlus::Runtime::Runtime).returns(::String) }
-      # @param _runtime [Runtime]
+      sig { override.params(_position: ::CSVPlusPlus::Runtime::Position).returns(::String) }
+      # @param _position [Position]
       #
       # @return [::String]
-      def evaluate(_runtime)
+      def evaluate(_position)
         @value.to_s
       end
 
-      sig { override.params(other: ::CSVPlusPlus::Entities::Entity).returns(::T::Boolean) }
-      # @param other [Entity]
+      sig { override.params(other: ::BasicObject).returns(::T::Boolean) }
+      # @param other [BasicObject]
       #
       # @return [::T::Boolean]
       def ==(other)
-        return false unless super
-
-        other.is_a?(self.class) && @value == other.value
+        case other
+        when self.class
+          @value == other.value
+        else
+          false
+        end
       end
     end
   end

data/lib/csv_plus_plus/entities/reference.rb

@@ -0,0 +1,77 @@
+# typed: strict
+# frozen_string_literal: true
+
+module CSVPlusPlus
+  module Entities
+    # A reference to something - this is typically either a cell reference (handled by +A1Reference+) or a reference
+    # to a variable.
+    #
+    # One sticking point with the design of this class is that we don't know if a reference is a variable reference
+    # unless we look at currently defined variables and see if there is one by that name.  Since all cell references
+    # can be a valid variable name, we can't be sure which is which.  So we delegate that decision as late as possible
+    # - in #evaluate
+    #
+    # @attr_reader scoped_to_expand [Expand, nil] If set, the expand in which this variable is scoped to. It cannot be
+    #   resolved outside of the given expand.
+    class Reference < ::CSVPlusPlus::Entities::Entity
+      extend ::T::Sig
+      include ::CSVPlusPlus::Entities::HasIdentifier
+
+      sig { returns(::T.nilable(::String)) }
+      attr_reader :ref
+
+      # sig { returns(::T.nilable(::CSVPlusPlus::A1Reference)) }
+      # attr_reader :a1_ref
+
+      sig { params(ref: ::T.nilable(::String), a1_ref: ::T.nilable(::CSVPlusPlus::A1Reference)).void }
+      # Either +ref+, +cell_index+ or +row_index+ must be specified.
+      #
+      # @param ref [Integer, nil] An A1-style cell reference (that will be parsed into it's row/cell indexes).
+      # @param a1_ref [Integer, nil] An A1-style cell reference (that will be parsed into it's row/cell indexes).
+      def initialize(ref: nil, a1_ref: nil)
+        super()
+
+        raise(::ArgumentError, 'Must specify :ref or :a1_ref') unless ref || a1_ref
+
+        @ref = ref
+        @a1_ref = a1_ref
+      end
+
+      sig { override.params(other: ::BasicObject).returns(::T::Boolean) }
+      # @param other [BasicObject]
+      #
+      # @return [boolean]
+      def ==(other)
+        case other
+        when self.class
+          a1_ref == other.a1_ref
+        else
+          false
+        end
+      end
+
+      sig { returns(::CSVPlusPlus::A1Reference) }
+      # @return [A1Reference]
+      def a1_ref
+        @a1_ref ||= ::CSVPlusPlus::A1Reference.new(ref: ::T.must(ref))
+      end
+
+      sig { override.params(position: ::CSVPlusPlus::Runtime::Position).returns(::String) }
+      # Get the A1-style cell reference
+      #
+      # @param position [Position] The current position
+      #
+      # @return [::String] An A1-style reference
+      def evaluate(position)
+        # TODO: ugh make to_a1_ref not return a nil
+        ref || a1_ref.to_a1_ref(position) || ''
+      end
+
+      sig { returns(::T.nilable(::Symbol)) }
+      # @return [Symbol]
+      def id
+        ref && identifier(::T.must(ref).to_sym)
+      end
+    end
+  end
+end

data/lib/csv_plus_plus/entities/runtime_value.rb

@@ -1,41 +1,54 @@
 # 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
+    # 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
 
-      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
+      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
 
       sig do
-        params(
-          resolve_fn: ::T.proc.params(arg0: ::CSVPlusPlus::Runtime::Runtime).returns(::CSVPlusPlus::Entities::Entity),
-          arguments: ::T::Array[::T.untyped]
-        ).void
+        params(resolve_fn: ::CSVPlusPlus::Entities::RuntimeValue::ResolveFn).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
+      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
 
-      sig { override.params(_runtime: ::CSVPlusPlus::Runtime::Runtime).returns(::String) }
-      # @param _runtime [Runtime]
+      sig { override.params(_position: ::CSVPlusPlus::Runtime::Position).returns(::String) }
+      # Given the current runtime, call +@resolve_fn+ to produce a value
+      #
+      # @param _position [Position]
       #
-      # @return [String]
-      def evaluate(_runtime)
+      # @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

data/lib/csv_plus_plus/entities/string.rb

@@ -6,7 +6,7 @@ module CSVPlusPlus
     # A string value
     #
     # @attr_reader value [String]
-    class String < Entity
+    class String < ::CSVPlusPlus::Entities::Entity
       extend ::T::Sig
 
       sig { returns(::String) }
@@ -15,27 +15,30 @@ module CSVPlusPlus
       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)
+        super()
 
         @value = ::T.let(value.gsub(/^"|"$/, ''), ::String)
       end
 
-      sig { override.params(_runtime: ::CSVPlusPlus::Runtime::Runtime).returns(::String) }
-      # @param _runtime [Runtime]
+      sig { override.params(_position: ::CSVPlusPlus::Runtime::Position).returns(::String) }
+      # @param _position [Position]
       #
       # @return [::String]
-      def evaluate(_runtime)
+      def evaluate(_position)
         "\"#{@value}\""
       end
 
-      sig { override.params(other: ::CSVPlusPlus::Entities::Entity).returns(::T::Boolean) }
-      # @param other [Entity]
+      sig { override.params(other: ::BasicObject).returns(::T::Boolean) }
+      # @param other [BasicObject]
       #
       # @return [T::Boolean]
       def ==(other)
-        return false unless super
-
-        other.is_a?(self.class) && @value == other.value
+        case other
+        when self.class
+          @value == other.value
+        else
+          false
+        end
       end
     end
   end

data/lib/csv_plus_plus/entities.rb

@@ -3,36 +3,20 @@
 
 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/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
-    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
 

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

@@ -4,17 +4,30 @@
 module CSVPlusPlus
   module Error
     # An error thrown by our code (generally to be handled at the top level bin/ command)
-    class Error < StandardError
+    class Error < ::StandardError
       extend ::T::Sig
       extend ::T::Helpers
 
-      sig { returns(::String) }
+      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
-        message
-      end
+      def error_message; end
     end
   end
 end

data/lib/csv_plus_plus/error/formula_syntax_error.rb

@@ -1,36 +1,35 @@
-# typed: true
+# 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