csv_plus_plus 0.1.2 → 0.2.0

data/lib/csv_plus_plus/entities/builtins.rb

@@ -1,44 +1,86 @@
+# typed: strict
 # frozen_string_literal: true
 
 module CSVPlusPlus
   module Entities
-    # Provides ASTs for builtin functions and variables
+    # Provides +RuntimeValue+s for builtin functions and variables
     module Builtins
+      extend ::T::Sig
+
       extend ::CSVPlusPlus::Entities::ASTBuilder
 
-      VARIABLES = {
-        # The number (integer) of the current cell. Starts at 1
-        cellnum: runtime_value(->(runtime) { number(runtime.cell_index + 1) }),
+      VARIABLES = ::T.let(
+        {
+          # The number (integer) of the current cell. Starts at 1
+          cellnum: runtime_value(->(p, _args) { number(p.cell_index + 1) }),
 
-        # A reference to the current cell
-        cellref: runtime_value(->(runtime) { ref(row_index: runtime.row_index, cell_index: runtime.cell_index) }),
+          # A reference to the current cell
+          cellref: runtime_value(->(p, _args) { cell_ref(p.row_index, p.cell_index) }),
 
-        # A reference to the row above
-        rowabove: runtime_value(->(runtime) { ref(row_index: [0, (runtime.row_index - 1)].max) }),
+          # A reference to the row above
+          rowabove: runtime_value(->(p, _args) { cell_ref([0, (p.row_index - 1)].max) }),
 
-        # A reference to the row below
-        rowbelow: runtime_value(->(runtime) { ref(row_index: runtime.row_index + 1) }),
+          # A reference to the row below
+          rowbelow: runtime_value(->(p, _args) { cell_ref(p.row_index + 1) }),
 
-        # The number (integer) of the current row.  Starts at 1
-        rownum: runtime_value(->(runtime) { number(runtime.rownum) }),
+          # The number (integer) of the current row.  Starts at 1
+          rownum: runtime_value(->(p, _args) { number(p.rownum) }),
 
-        # A reference to the current row
-        rowref: runtime_value(->(runtime) { ref(row_index: runtime.row_index) })
-      }.freeze
+          # A reference to the current row
+          rowref: runtime_value(->(p, _args) { cell_ref(p.row_index) })
+        }.freeze,
+        ::T::Hash[::Symbol, ::CSVPlusPlus::Entities::RuntimeValue]
+      )
       public_constant :VARIABLES
 
-      FUNCTIONS = {
-        # TODO: A reference to a cell in a given row?
-        # A reference to a cell above the current row
-        cellabove: runtime_value(->(runtime, args) { cell_reference([args[0], [1, (runtime.rownum - 1)].max].join) }),
+      # TODO: A reference to a cell in a given row?
+      # TODO: check types of the args and throw a more friendly error?
+      FUNCTIONS = ::T.let(
+        {
+          # A reference to a cell above the current row
+          cellabove: runtime_value(->(p, args) { cell_ref([0, (p.row_index - 1)].max, args[0].a1_ref.cell_index) }),
 
-        # A reference to a cell in the current row
-        celladjacent: runtime_value(->(runtime, args) { cell_reference([args[0], runtime.rownum].join) }),
+          # A reference to a cell in the current row
+          celladjacent: runtime_value(->(p, args) { cell_ref(p.row_index, args[0].a1_ref.cell_index) }),
 
-        # A reference to a cell below the current row
-        cellbelow: runtime_value(->(runtime, args) { cell_reference([args[0], runtime.rownum + 1].join) })
-      }.freeze
+          # A reference to a cell below the current row
+          cellbelow: runtime_value(->(p, args) { cell_ref(p.row_index + 1, args[0].a1_ref.cell_index) })
+        }.freeze,
+        ::T::Hash[::Symbol, ::CSVPlusPlus::Entities::RuntimeValue]
+      )
       public_constant :FUNCTIONS
+
+      sig { params(fn_id: ::Symbol).returns(::T::Boolean) }
+      # Is +fn_id+ a builtin function?
+      #
+      # @param fn_id [Symbol] The Function#id to check if it's a runtime variable
+      #
+      # @return [T::Boolean]
+      def self.builtin_function?(fn_id)
+        ::CSVPlusPlus::Entities::Builtins::FUNCTIONS.key?(fn_id)
+      end
+
+      sig { params(var_id: ::Symbol).returns(::T::Boolean) }
+      # Is +var_id+ a builtin variable?
+      #
+      # @param var_id [Symbol] The Variable#id to check if it's a runtime variable
+      #
+      # @return [Boolean]
+      def self.builtin_variable?(var_id)
+        ::CSVPlusPlus::Entities::Builtins::VARIABLES.key?(var_id)
+      end
+
+      sig do
+        params(row_index: ::Integer, cell_index: ::T.nilable(::Integer)).returns(::CSVPlusPlus::Entities::Reference)
+      end
+      # @param row_index [Integer]
+      # @param cell_index [Integer, nil]
+      #
+      # @return [Runtime::Reference]
+      def self.cell_ref(row_index, cell_index = nil)
+        ::CSVPlusPlus::Entities::Reference.new(a1_ref: ::CSVPlusPlus::A1Reference.new(row_index:, cell_index:))
+      end
+      private_class_method :cell_ref
     end
   end
 end

data/lib/csv_plus_plus/entities/date.rb

@@ -1,3 +1,4 @@
+# typed: strict
 # frozen_string_literal: true
 
 module CSVPlusPlus
@@ -5,25 +6,60 @@ module CSVPlusPlus
     # A date value
     #
     # @attr_reader value [Date] The parsed date
-    class Date < Entity
+    class Date < ::CSVPlusPlus::Entities::Entity
+      extend ::T::Sig
+
+      sig { returns(::Date) }
       attr_reader :value
 
-      # TODO: support time?
+      # TODO: support time granularity?
       DATE_STRING_REGEXP = %r{^\d{1,2}[/-]\d{1,2}[/-]\d{1,4}?$}
       public_constant :DATE_STRING_REGEXP
 
+      sig { params(date_string: ::String).returns(::T::Boolean) }
       # Is the given string a valid date?
       #
       # @param date_string [::String]
       def self.valid_date?(date_string)
-        !(date_string.strip =~ ::CSVPlusPlus::Entities::Date::DATE_STRING_REGEXP).nil?
+        new(date_string)
+        true
+      rescue ::Date::Error
+        false
       end
 
-      # @param value [String] The user-inputted date value
+      sig { params(value: ::String).void }
+      # @param value [::String] The user-inputted date value
       def initialize(value)
-        super(:date)
+        super()
+
+        parsed =
+          begin
+            ::Date.parse(value)
+          rescue ::Date::Error
+            ::Date.strptime(value, '%d/%m/%yyyy')
+          end
+        @value = ::T.let(parsed, ::Date)
+      end
 
-        @value = ::Date.parse(value)
+      sig { override.params(_position: ::CSVPlusPlus::Runtime::Position).returns(::String) }
+      # @param _position [Position]
+      #
+      # @return [::String]
+      def evaluate(_position)
+        @value.strftime('%m/%d/%y')
+      end
+
+      sig { override.params(other: ::BasicObject).returns(::T::Boolean) }
+      # @param other [BasicObject]
+      #
+      # @return [Boolean]
+      def ==(other)
+        case other
+        when self.class
+          other.value == @value
+        else
+          false
+        end
       end
     end
   end

data/lib/csv_plus_plus/entities/entity.rb

@@ -1,84 +1,32 @@
+# typed: strict
 # frozen_string_literal: true
 
-require_relative '../entities'
-
 module CSVPlusPlus
   module Entities
-    # A basic building block of the abstract syntax tree (AST)
-    #
-    # @attr_reader id [Symbol] The identifier of the entity.  For functions this is the function name,
-    #   for variables it's the variable name
-    # @attr_reader type [Symbol] The type of the entity.  Valid values are defined in +::CSVPlusPlus::Entities::TYPES+
+    # All classes that are a part of an AST must implement this interface
     class Entity
-      attr_reader :id, :type
-
-      # @param type [::String, Symbol]
-      # @param id [::String, nil]
-      def initialize(type, id: nil)
-        @type = type.to_sym
-        @id = id.downcase.to_sym if id
-      end
-
-      # @return [boolean]
-      def ==(other)
-        self.class == other.class && @type == other.type && @id == other.id
-      end
+      extend ::T::Sig
+      extend ::T::Helpers
 
-      # Respond to predicates that correspond to types like #boolean?, #string?, etc
-      #
-      # @param method_name [Symbol] The +method_name+ to respond to
-      def method_missing(method_name, *_arguments)
-        if method_name =~ /^(\w+)\?$/
-          t = ::Regexp.last_match(1)
-          a_type?(t) && @type == t.to_sym
-        else
-          super
-        end
-      end
+      abstract!
 
-      # Respond to predicates by type (entity.boolean?, entity.string?, etc)
+      sig { abstract.params(other: ::BasicObject).returns(::T::Boolean) }
+      # Each node in the AST needs to implement #== so we can compare entities for equality
       #
-      # @param method_name [Symbol] The +method_name+ to respond to
+      # @param other [Entity]
       #
       # @return [boolean]
-      def respond_to_missing?(method_name, *_arguments)
-        (method_name =~ /^(\w+)\?$/ && a_type?(::Regexp.last_match(1))) || super
-      end
+      def ==(other); end
 
-      private
-
-      def a_type?(str)
-        ::CSVPlusPlus::Entities::TYPES.include?(str.to_sym)
-      end
-    end
-
-    # 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
-      attr_reader :arguments
-
-      # @param type [::String, Symbol]
-      # @param id [::String]
-      # @param arguments [Array<Entity>]
-      def initialize(type, id: nil, arguments: [])
-        super(type, id:)
-        @arguments = arguments
-      end
-
-      # @return [boolean]
-      def ==(other)
-        super && @arguments == other.arguments
-      end
-
-      protected
-
-      attr_writer :arguments
-
-      def arguments_to_s
-        @arguments.join(', ')
+      sig do
+        abstract.params(position: ::CSVPlusPlus::Runtime::Position).returns(::String)
       end
+      # Uses the given +position+ to evaluate itself in the current context
+      #
+      # @param position [Position] The current runtime
+      #
+      # @return [::String]
+      def evaluate(position); end
     end
   end
 end

data/lib/csv_plus_plus/entities/entity_with_arguments.rb

@@ -0,0 +1,44 @@
+# 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 < ::CSVPlusPlus::Entities::Entity
+      extend ::T::Sig
+      extend ::T::Helpers
+      extend ::T::Generic
+
+      abstract!
+
+      ArgumentsType = type_member
+      public_constant :ArgumentsType
+
+      sig { returns(::T::Array[::CSVPlusPlus::Entities::EntityWithArguments::ArgumentsType]) }
+      attr_reader :arguments
+
+      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: ::BasicObject).returns(::T::Boolean) }
+      # @param other [Entity]
+      #
+      # @return [boolean]
+      def ==(other)
+        case other
+        when self.class
+          @arguments == other.arguments
+        else
+          false
+        end
+      end
+    end
+  end
+end

data/lib/csv_plus_plus/entities/function.rb

@@ -1,32 +1,55 @@
+# typed: strict
 # frozen_string_literal: true
 
-require_relative './entity'
-
 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
+    #   from +@arguments+
+    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
 
-      # @param id [Symbool, String] the name of the function - what it will be callable by
+      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(:function, id:, arguments: arguments.map(&:to_sym))
-        @body = body
+        super(arguments: arguments.map(&:to_sym))
+
+        @body = ::T.let(body, ::CSVPlusPlus::Entities::Entity)
+        @id = ::T.let(identifier(id), ::Symbol)
       end
 
+      sig { override.params(position: ::CSVPlusPlus::Runtime::Position).returns(::String) }
+      # @param position [Position]
+      #
       # @return [String]
-      def to_s
-        "def #{@id.to_s.upcase}(#{arguments_to_s}) #{@body}"
+      def evaluate(position)
+        "def #{@id.to_s.upcase}(#{arguments.map(&:to_s).join(', ')}) #{@body.evaluate(position)}"
       end
 
-      # @return [boolean]
+      sig { override.params(other: ::BasicObject).returns(::T::Boolean) }
+      # @param other [Entity]
+      #
+      # @return [::T::Boolean]
       def ==(other)
-        super && @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

@@ -1,34 +1,73 @@
+# typed: strict
 # frozen_string_literal: true
 
 module CSVPlusPlus
   module Entities
-    # A function call
+    # 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
+      include ::CSVPlusPlus::Entities::HasIdentifier
+
+      ArgumentsType = type_member { { fixed: ::CSVPlusPlus::Entities::Entity } }
+      public_constant :ArgumentsType
+
+      sig { returns(::T::Boolean) }
       attr_reader :infix
 
-      # @param id [String] The name of the function
+      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 [boolean] Whether the function is infix
+      # @param infix [T::Boolean] Whether the function is infix
       def initialize(id, arguments, infix: false)
-        super(:function_call, id:, arguments:)
+        super(arguments:)
 
+        @id = ::T.let(identifier(id), ::Symbol)
         @infix = infix
       end
 
-      # @return [String]
-      def to_s
+      sig { override.params(position: ::CSVPlusPlus::Runtime::Position).returns(::String) }
+      # @param position [Position]
+      #
+      # @return [::String]
+      def evaluate(position)
+        evaluated_arguments = evaluate_arguments(position)
+
         if @infix
-          "(#{arguments.join(" #{@id} ")})"
+          "(#{evaluated_arguments.join(" #{@id} ")})"
         else
-          "#{@id.to_s.upcase}(#{arguments_to_s})"
+          "#{@id.to_s.upcase}(#{evaluated_arguments.join(', ')})"
         end
       end
 
-      # @return [boolean]
+      sig { override.params(other: ::BasicObject).returns(::T::Boolean) }
+      # @param other [BasicObject]
+      #
+      # @return [Boolean]
       def ==(other)
-        super && @id == other.id
+        case other
+        when self.class
+          @id == other.id && @infix == other.infix
+        else
+          false
+        end
+      end
+
+      private
+
+      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

@@ -1,3 +1,4 @@
+# typed: strict
 # frozen_string_literal: true
 
 module CSVPlusPlus
@@ -5,29 +6,47 @@ 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(:number)
+        super()
 
         @value =
-          if value.instance_of?(::String)
-            value.include?('.') ? Float(value) : Integer(value, 10)
-          else
-            value
-          end
+          ::T.let(
+            (if value.is_a?(::String)
+               value.include?('.') ? Float(value) : Integer(value, 10)
+             else
+               value
+             end),
+            ::Numeric
+          )
       end
 
-      # @return [String]
-      def to_s
+      sig { override.params(_position: ::CSVPlusPlus::Runtime::Position).returns(::String) }
+      # @param _position [Position]
+      #
+      # @return [::String]
+      def evaluate(_position)
         @value.to_s
       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/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