csv_plus_plus 0.1.2 → 0.1.3

data/lib/csv_plus_plus/entities/cell_reference.rb

@@ -1,32 +1,69 @@
+# typed: strict
 # frozen_string_literal: true
 
-require_relative './ast_builder'
-require_relative './entity'
-
 module CSVPlusPlus
   module Entities
-    # A reference to a cell
+    # A reference to a cell. Internally it is represented by a simple +cell_index+ and +row_index+ but there are
+    # functions for converting to and from A1-style formats.  Supported formats are:
+    #
+    # * `1` - A reference to the entire first row
+    # * `A` - A reference to the entire first column
+    # * `A1` - A reference to the first cell (top left)
+    # * `A1:D10` - The range defined between A1 and D10
+    # * `Sheet1!B2` - Cell B2 on the sheet "Sheet1"
     #
-    # @attr_reader cell_reference [String] The cell reference in A1 format
+    # @attr sheet_name [String, nil] The name of the sheet reference
+    # @attr_reader cell_index [Integer, nil] The cell index of the cell being referenced
+    # @attr_reader row_index [Integer, nil] The row index of the cell being referenced
+    # @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.
+    # @attr_reader upper_cell_index [Integer, nil] If set, the cell reference is a range and this is the upper cell
+    #   index of it
+    # @attr_reader upper_row_index [Integer, nil] If set, the cell reference is a range and this is the upper row index
+    #   of it
+    # rubocop:disable Metrics/ClassLength
     class CellReference < Entity
-      attr_reader :cell_reference
+      extend ::T::Sig
 
-      A1_NOTATION_REGEXP = /(['\w]+!)?\w+:\w+/
-      public_constant :A1_NOTATION_REGEXP
+      sig { returns(::T.nilable(::String)) }
+      attr_accessor :sheet_name
 
-      # Create a +CellReference+ to the given indexes
-      #
-      # @param cell_index [Integer] The current cell index
-      # @param row_index [Integer] The current row index
-      #
-      # @return [CellReference]
-      def self.from_index(cell_index:, row_index:)
-        return unless row_index || cell_index
+      sig { returns(::T.nilable(::Integer)) }
+      attr_reader :cell_index
 
-        # I can't just extend this class due to circular references :(
-        ::Class.new.extend(::CSVPlusPlus::Entities::ASTBuilder).ref(cell_index:, row_index:)
-      end
+      sig { returns(::T.nilable(::Integer)) }
+      attr_reader :row_index
+
+      sig { returns(::T.nilable(::CSVPlusPlus::Modifier::Expand)) }
+      attr_reader :scoped_to_expand
 
+      sig { returns(::T.nilable(::Integer)) }
+      attr_reader :upper_cell_index
+
+      sig { returns(::T.nilable(::Integer)) }
+      attr_reader :upper_row_index
+
+      # TODO: this is getting gross, maybe define an actual parser
+      A1_NOTATION_REGEXP = /
+        ^
+          (?:
+            (?:
+              (?:'([^'\\]|\\.)*') # allow for a single-quoted sheet name
+              |
+              (\w+)               # or if it's not quoted, just allow \w+
+            )
+            !                     # if a sheet name is specified, it's always followed by a !
+          )?
+          ([a-zA-Z0-9]+)          # the only part required - something alphanumeric
+          (?: :([a-zA-Z0-9]+))?   # and they might make it a range
+        $
+      /x
+      public_constant :A1_NOTATION_REGEXP
+
+      ALPHA = ::T.let(('A'..'Z').to_a.freeze, ::T::Array[::String])
+      private_constant :ALPHA
+
+      sig { params(cell_reference_string: ::String).returns(::T::Boolean) }
       # Does the given +cell_reference_string+ conform to a valid cell reference?
       #
       # {https://developers.google.com/sheets/api/guides/concepts}
@@ -34,27 +71,161 @@ module CSVPlusPlus
       # @param cell_reference_string [::String] The string to check if it is a valid cell reference (we assume it's in
       #   A1 notation but maybe can support R1C1)
       #
-      # @return [boolean]
+      # @return [::T::Boolean]
       def self.valid_cell_reference?(cell_reference_string)
         !(cell_reference_string =~ ::CSVPlusPlus::Entities::CellReference::A1_NOTATION_REGEXP).nil?
       end
 
-      # @param cell_reference [String] The cell reference in A1 format
-      def initialize(cell_reference)
-        super(:cell_reference)
+      sig do
+        params(
+          cell_index: ::T.nilable(::Integer),
+          ref: ::T.nilable(::String),
+          row_index: ::T.nilable(::Integer),
+          scoped_to_expand: ::T.nilable(::CSVPlusPlus::Modifier::Expand)
+        ).void
+      end
+      # Either +ref+, +cell_index+ or +row_index+ must be specified.
+      #
+      # @param cell_index [Integer, nil] The index of the cell being referenced.
+      # @param ref [Integer, nil] An A1-style cell reference (that will be parsed into it's row/cell indexes).
+      # @param row_index [Integer, nil] The index of the row being referenced.
+      # @param scoped_to_expand [Expand] The [[expand]] that this cell reference will be scoped to. In other words, it
+      #   will only be able to be resolved if the runtime is within the bounds of the expand (it can't be referenced
+      #   outside of the expand.)
+      # rubocop:disable Metrics/MethodLength
+      def initialize(cell_index: nil, ref: nil, row_index: nil, scoped_to_expand: nil)
+        raise(::ArgumentError, 'Must specify :ref, :cell_index or :row_index') unless ref || cell_index || row_index
+
+        super(::CSVPlusPlus::Entities::Type::CellReference)
+
+        if ref
+          from_a1_ref!(ref)
+        else
+          @cell_index = ::T.let(cell_index, ::T.nilable(::Integer))
+          @row_index = ::T.let(row_index, ::T.nilable(::Integer))
+
+          @upper_cell_index = ::T.let(nil, ::T.nilable(::Integer))
+          @upper_row_index = ::T.let(nil, ::T.nilable(::Integer))
+        end
 
-        @cell_reference = cell_reference
+        @scoped_to_expand = scoped_to_expand
       end
+      # rubocop:enable Metrics/MethodLength
+
+      sig { override.params(other: ::CSVPlusPlus::Entities::Entity).returns(::T::Boolean) }
+      # @param other [Entity]
+      #
+      # @return [boolean]
+      # rubocop:disable Metrics/CyclomaticComplexity
+      def ==(other)
+        return false unless super
+
+        other.is_a?(self.class) && @cell_index == other.cell_index && @row_index == other.row_index \
+          && @sheet_name == other.sheet_name && @scoped_to_expand == other.scoped_to_expand \
+          && @upper_cell_index == other.upper_cell_index && @upper_row_index == other.upper_row_index
+      end
+      # rubocop:enable Metrics/CyclomaticComplexity
+
+      sig { override.params(runtime: ::CSVPlusPlus::Runtime::Runtime).returns(::String) }
+      # Get the A1-style cell reference
+      #
+      # @param runtime [Runtime] The current runtime
+      #
+      # @return [::String] An A1-style reference
+      def evaluate(runtime)
+        # unless in_scope?(runtime)
+        #   runtime.raise_modifier_syntax_error(message: 'Reference is out of scope', bad_input: runtime.cell.value)
+        # end
 
+        to_a1_ref(runtime) || ''
+      end
+
+      sig { returns(::T::Boolean) }
+      # Is the cell_reference a range? - something like A1:D10
+      #
+      # @return [boolean]
+      def range?
+        !upper_row_index.nil? || !upper_cell_index.nil?
+      end
+
+      private
+
+      sig { params(runtime: ::CSVPlusPlus::Runtime::Runtime).returns(::T.nilable(::String)) }
+      # Turns index-based/X,Y coordinates into a A1 format
+      #
+      # @param runtime [Runtime]
+      #
+      # @return [::String, nil]
+      def to_a1_ref(runtime)
+        row_index = runtime_row_index(runtime)
+        return unless row_index || @cell_index
+
+        rowref = row_index ? (row_index + 1).to_s : ''
+        cellref = @cell_index ? to_a1_cell_ref : ''
+        [cellref, rowref].join
+      end
+
+      sig { params(runtime: ::CSVPlusPlus::Runtime::Runtime).returns(::T.nilable(::Integer)) }
+      def runtime_row_index(runtime)
+        @scoped_to_expand ? runtime.row_index : @row_index
+      end
+
+      sig { returns(::String) }
+      # Turns a cell index into an A1 reference (just the "A" part - for example 0 == 'A', 1 == 'B', 2 == 'C', etc.)
+      #
       # @return [::String]
-      def to_s
-        @cell_reference
+      def to_a1_cell_ref
+        c = @cell_index.dup
+        ref = ''
+
+        while c >= 0
+          # rubocop:disable Lint/ConstantResolution
+          ref += ::T.must(ALPHA[c % 26])
+          # rubocop:enable Lint/ConstantResolution
+          c = (c / 26).floor - 1
+        end
+
+        ref.reverse
       end
 
-      # @return [Boolean]
-      def ==(other)
-        super && @cell_reference == other.cell_reference
+      sig { params(ref: ::String).void }
+      def from_a1_ref!(ref)
+        quoted_sheet_name, unquoted_sheet_name, lower_range, upper_range = ::T.must(
+          ref.strip.match(
+            ::CSVPlusPlus::Entities::CellReference::A1_NOTATION_REGEXP
+          )
+        ).captures
+
+        @sheet_name = quoted_sheet_name || unquoted_sheet_name
+
+        parse_lower_range!(lower_range) if lower_range
+        parse_upper_range!(upper_range) if upper_range
+      end
+
+      sig { params(lower_range: ::String).void }
+      def parse_lower_range!(lower_range)
+        cell_ref, row_ref = ::T.must(lower_range.match(/^([a-zA-Z]+)?(\d+)?$/)).captures
+        @cell_index = from_a1_cell_ref!(cell_ref) if cell_ref
+        @row_index = Integer(row_ref, 10) - 1 if row_ref
+      end
+
+      sig { params(upper_range: ::String).void }
+      # TODO: make this less redundant with the above function
+      def parse_upper_range!(upper_range)
+        cell_ref, row_ref = ::T.must(upper_range.match(/^([a-zA-Z]+)?(\d+)?$/)).captures
+        @upper_cell_index = from_a1_cell_ref!(cell_ref) if cell_ref
+        @upper_row_index = Integer(row_ref, 10) - 1 if row_ref
+      end
+
+      sig { params(cell_ref: ::String).returns(::Integer) }
+      def from_a1_cell_ref!(cell_ref)
+        (cell_ref.upcase.chars.reduce(0) do |cell_index, letter|
+          # rubocop:disable Lint/ConstantResolution
+          (cell_index * 26) + ::T.must(ALPHA.find_index(letter)) + 1
+          # rubocop:enable Lint/ConstantResolution
+        end) - 1
       end
     end
+    # rubocop:enable Metrics/ClassLength
   end
 end

data/lib/csv_plus_plus/entities/date.rb

@@ -1,3 +1,4 @@
+# typed: strict
 # frozen_string_literal: true
 
 module CSVPlusPlus
@@ -6,24 +7,56 @@ module CSVPlusPlus
     #
     # @attr_reader value [Date] The parsed date
     class Date < 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(::CSVPlusPlus::Entities::Type::Date)
+
+        parsed =
+          begin
+            ::Date.parse(value)
+          rescue ::Date::Error
+            ::Date.strptime(value, '%d/%m/%yyyy')
+          end
+        @value = ::T.let(parsed, ::Date)
+      end
+
+      sig { override.params(_runtime: ::CSVPlusPlus::Runtime::Runtime).returns(::String) }
+      # @param _runtime [Runtime]
+      #
+      # @return [::String]
+      def evaluate(_runtime)
+        @value.strftime('%m/%d/%y')
+      end
+
+      sig { override.params(other: ::CSVPlusPlus::Entities::Entity).returns(::T::Boolean) }
+      # @param other [Entity]
+      #
+      # @return [T::Boolean]
+      def ==(other)
+        return false unless super
 
-        @value = ::Date.parse(value)
+        other.is_a?(self.class) && other.value == @value
       end
     end
   end

data/lib/csv_plus_plus/entities/entity.rb

@@ -1,84 +1,50 @@
+# 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+
+    # @attr_reader type [Entities::Type] The type of the entity. Each type should have a corresponding class definition
+    #   in CSVPlusPlus::Entities
     class Entity
-      attr_reader :id, :type
+      extend ::T::Sig
+      extend ::T::Helpers
+
+      abstract!
+
+      sig { returns(::T.nilable(::Symbol)) }
+      attr_reader :id
+
+      sig { returns(::CSVPlusPlus::Entities::Type) }
+      attr_reader :type
 
-      # @param type [::String, Symbol]
-      # @param id [::String, nil]
+      sig { params(type: ::CSVPlusPlus::Entities::Type, id: ::T.nilable(::Symbol)).void }
+      # @param type [Entities::Type]
+      # @param id [Symbol, nil]
       def initialize(type, id: nil)
-        @type = type.to_sym
-        @id = id.downcase.to_sym if id
+        @type = type
+        @id = ::T.let(id&.downcase&.to_sym || nil, ::T.nilable(::Symbol))
       end
 
+      sig { overridable.params(other: ::CSVPlusPlus::Entities::Entity).returns(::T::Boolean) }
+      # Each class should define it's own version of #==
+      # @param other [Entity]
+      #
       # @return [boolean]
       def ==(other)
         self.class == other.class && @type == other.type && @id == other.id
       end
 
-      # Respond to predicates that correspond to types like #boolean?, #string?, etc
+      sig { abstract.params(_runtime: ::CSVPlusPlus::Runtime::Runtime).returns(::String) }
+      # Uses the given +runtime+ to evaluate itself in the current context
       #
-      # @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
-
-      # Respond to predicates by type (entity.boolean?, entity.string?, etc)
+      # @param _runtime [Runtime] The current runtime
       #
-      # @param method_name [Symbol] The +method_name+ to respond to
-      #
-      # @return [boolean]
-      def respond_to_missing?(method_name, *_arguments)
-        (method_name =~ /^(\w+)\?$/ && a_type?(::Regexp.last_match(1))) || super
-      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(', ')
-      end
+      # @return [::String]
+      def evaluate(_runtime); end
     end
   end
 end

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

@@ -1,32 +1,44 @@
+# 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+
+    #   from +@arguments+
     class Function < EntityWithArguments
+      extend ::T::Sig
+
+      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(::CSVPlusPlus::Entities::Type::Function, id:, arguments: arguments.map(&:to_sym))
+
+        @body = ::T.let(body, ::CSVPlusPlus::Entities::Entity)
       end
 
-      # @return [String]
-      def to_s
-        "def #{@id.to_s.upcase}(#{arguments_to_s}) #{@body}"
+      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
 
-      # @return [boolean]
+      sig { override.params(other: ::CSVPlusPlus::Entities::Entity).returns(::T::Boolean) }
+      # @param other [Entity]
+      #
+      # @return [::T::Boolean]
       def ==(other)
-        super && @body == other.body
+        return false unless super
+
+        other.is_a?(self.class) && @body == other.body
       end
     end
   end

data/lib/csv_plus_plus/entities/function_call.rb

@@ -1,34 +1,49 @@
+# 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
+
+      sig { returns(::T::Boolean) }
       attr_reader :infix
 
-      # @param id [String] The name of the function
+      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 [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(::CSVPlusPlus::Entities::Type::FunctionCall, id:, arguments:)
 
         @infix = infix
       end
 
-      # @return [String]
-      def to_s
+      sig { override.params(runtime: ::CSVPlusPlus::Runtime::Runtime).returns(::String) }
+      # @param runtime [Runtime]
+      #
+      # @return [::String]
+      def evaluate(runtime)
+        evaluated_arguments = evaluate_arguments(runtime)
+
         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
 
+      sig { override.params(other: ::CSVPlusPlus::Entities::Entity).returns(::T::Boolean) }
+      # @param other [Entity]
+      #
       # @return [boolean]
       def ==(other)
-        super && @id == other.id
+        return false unless super
+
+        other.is_a?(self.class) && @id == other.id && @infix == other.infix
       end
     end
   end

data/lib/csv_plus_plus/entities/number.rb

@@ -1,3 +1,4 @@
+# typed: strict
 # frozen_string_literal: true
 
 module CSVPlusPlus
@@ -6,28 +7,41 @@ module CSVPlusPlus
     #
     # @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(:number)
+        super(::CSVPlusPlus::Entities::Type::Number)
 
         @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(_runtime: ::CSVPlusPlus::Runtime::Runtime).returns(::String) }
+      # @param _runtime [Runtime]
+      #
+      # @return [::String]
+      def evaluate(_runtime)
         @value.to_s
       end
 
-      # @return [boolean]
+      sig { override.params(other: ::CSVPlusPlus::Entities::Entity).returns(::T::Boolean) }
+      # @param other [Entity]
+      #
+      # @return [::T::Boolean]
       def ==(other)
-        super && value == other.value
+        return false unless super
+
+        other.is_a?(self.class) && @value == other.value
       end
     end
   end