csv_plus_plus 0.1.3 → 0.2.1

data/lib/csv_plus_plus/cli_flag.rb

@@ -1,4 +1,4 @@
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
 module CSVPlusPlus
@@ -8,83 +8,90 @@ module CSVPlusPlus
   # @attr_reader long_flag [String] A definition of the long/word-based flag
   # @attr_reader description [String] A description of what the flag does
   # @attr_reader handler [Proc(Options, String)] A proc which is called to handle when this flag is seen
-  class CliFlag
-    attr_reader :short_flag, :long_flag, :description, :handler
+  class CLIFlag
+    extend ::T::Sig
 
+    sig { returns(::String) }
+    attr_reader :description
+
+    sig { returns(::String) }
+    attr_reader :long_flag
+
+    sig { returns(::String) }
+    attr_reader :short_flag
+
+    sig { params(short_flag: ::String, long_flag: ::String, description: ::String).void }
     # @param short_flag [String] A definition of the short/single-character flag
     # @param long_flag [String] A definition of the long/word-based flag
     # @param description [String] A description of what the flag does
-    # @param handler [Proc(Options, String)] A proc which is called to handle when this flag is seen
-    def initialize(short_flag, long_flag, description, handler)
+    def initialize(short_flag, long_flag, description)
       @short_flag = short_flag
       @long_flag = long_flag
       @description = description
-      @handler = handler
-    end
-
-    # @return [String]
-    def to_s
-      "#{@short_flag}, #{@long_flag}  #{@description}"
     end
   end
-end
 
-SUPPORTED_CSVPP_FLAGS = [
-  ::CSVPlusPlus::CliFlag.new(
-    '-b',
-    '--backup',
-    'Create a backup of the spreadsheet before applying changes.',
-    ->(options, _v) { options.backup = true }
-  ),
-  ::CSVPlusPlus::CliFlag.new(
-    '-c',
-    '--create',
-    "Create the sheet if it doesn't exist.  It will use --sheet-name if specified",
-    ->(options, _v) { options.create_if_not_exists = true }
-  ),
-  ::CSVPlusPlus::CliFlag.new(
-    '-g SHEET_ID',
-    '--google-sheet-id SHEET_ID',
-    'The id of the sheet - you can extract this from the URL: ' \
-    'https://docs.google.com/spreadsheets/d/< ... SHEET_ID ... >/edit#gid=0',
-    ->(options, v) { options.google_sheet_id = v }
-  ),
-  ::CSVPlusPlus::CliFlag.new(
-    '-k',
-    '--key-values KEY_VALUES',
-    'A comma-separated list of key=values which will be made available to the template',
-    lambda do |options, v|
-      options.key_values =
-        begin
-          [v.split('=')].to_h
-        rescue ::StandardError
-          {}
-        end
-    end
-  ),
-  ::CSVPlusPlus::CliFlag.new(
-    '-n SHEET_NAME',
-    '--sheet-name SHEET_NAME',
-    'The name of the sheet to apply the template to',
-    ->(options, v) { options.sheet_name = v }
-  ),
-  ::CSVPlusPlus::CliFlag.new(
-    '-o OUTPUT_FILE',
-    '--output OUTPUT_FILE',
-    'The file to write to (must be .csv, .ods, .xls)',
-    ->(options, v) { options.output_filename = v }
-  ),
-  ::CSVPlusPlus::CliFlag.new('-v', '--verbose', 'Enable verbose output', ->(options, _v) { options.verbose = true }),
-  ::CSVPlusPlus::CliFlag.new(
-    '-x OFFSET',
-    '--offset-columns OFFSET',
-    'Apply the template offset by OFFSET cells',
-    ->(options, v) { options.offset[0] = v }
-  ),
-  ::CSVPlusPlus::CliFlag.new(
-    '-y OFFSET',
-    '--offset-rows OFFSET',
-    'Apply the template offset by OFFSET rows',
-    ->(options, v) { options.offset[1] = v }
+  FLAG_HANDLERS = ::T.let(
+    {
+      backup: ->(options, _v) { options.backup = true },
+      create: ->(options, _v) { options.create_if_not_exists = true },
+      'key-values': lambda { |options, v|
+                      options.key_values =
+                        begin
+                          [v.split('=')].to_h
+                        rescue ::StandardError
+                          {}
+                        end
+                    },
+      'offset-columns': ->(options, v) { options.offset[0] = v },
+      'offset-rows': ->(options, v) { options.offset[1] = v },
+      output: ->(options, v) { options.output_filename = ::Pathname.new(v) },
+      safe: ->(options, _v) { options.overwrite_values = false },
+      verbose: ->(options, _v) { options.verbose = true }
+    },
+    ::T::Hash[::Symbol, ::T.proc.params(options: ::CSVPlusPlus::Options::Options, v: ::String).void]
   )
-].freeze
+  public_constant :FLAG_HANDLERS
+
+  SUPPORTED_CSVPP_FLAGS = ::T.let(
+    [
+      ::CSVPlusPlus::CLIFlag.new('-b', '--backup', 'Create a backup of the spreadsheet before applying changes.'),
+      ::CSVPlusPlus::CLIFlag.new(
+        '-c',
+        '--create',
+        "Create the sheet if it doesn't exist.  It will use --sheet-name if specified"
+      ),
+      ::CSVPlusPlus::CLIFlag.new(
+        '-g SHEET_ID',
+        '--google-sheet-id SHEET_ID',
+        'The id of the sheet - you can extract this from the URL: ' \
+        'https://docs.google.com/spreadsheets/d/< ... SHEET_ID ... >/edit#gid=0'
+      ),
+      ::CSVPlusPlus::CLIFlag.new(
+        '-k',
+        '--key-values KEY_VALUES',
+        'A comma-separated list of key=values which will be made available to the template'
+      ),
+      ::CSVPlusPlus::CLIFlag.new(
+        '-n SHEET_NAME',
+        '--sheet-name SHEET_NAME',
+        'The name of the sheet to apply the template to'
+      ),
+      ::CSVPlusPlus::CLIFlag.new(
+        '-o OUTPUT_FILE',
+        '--output OUTPUT_FILE',
+        'The file to write to (must be .csv, .ods, .xls)'
+      ),
+      ::CSVPlusPlus::CLIFlag.new(
+        '-s',
+        '--safe',
+        'Do not overwrite values in the spreadsheet being written to. The default is to overwrite'
+      ),
+      ::CSVPlusPlus::CLIFlag.new('-v', '--verbose', 'Enable verbose output'),
+      ::CSVPlusPlus::CLIFlag.new('-x OFFSET', '--offset-columns OFFSET', 'Apply the template offset by OFFSET cells'),
+      ::CSVPlusPlus::CLIFlag.new('-y OFFSET', '--offset-rows OFFSET', 'Apply the template offset by OFFSET rows')
+    ].freeze,
+    ::T::Array[::CSVPlusPlus::CLIFlag]
+  )
+  public_constant :SUPPORTED_CSVPP_FLAGS
+end

data/lib/csv_plus_plus/color.rb

@@ -42,7 +42,7 @@ module CSVPlusPlus
       red_hex, green_hex, blue_hex = hex_string.strip.match(::CSVPlusPlus::Color::HEX_STRING_REGEXP)
                                         &.captures
                                         &.map { |s| s.length == 1 ? s + s : s }
-      raise(::CSVPlusPlus::Error::Error, "Invalid color: #{hex_string}") unless red_hex && green_hex && blue_hex
+      raise(::CSVPlusPlus::Error::CompilerError, "Invalid color: #{hex_string}") unless red_hex && green_hex && blue_hex
 
       @red_hex = ::T.let(red_hex, ::String)
       @green_hex = ::T.let(green_hex, ::String)

data/lib/csv_plus_plus/compiler.rb

@@ -11,7 +11,7 @@ module CSVPlusPlus
   class Compiler
     extend ::T::Sig
 
-    sig { returns(::CSVPlusPlus::Options) }
+    sig { returns(::CSVPlusPlus::Options::Options) }
     attr_reader :options
 
     sig { returns(::CSVPlusPlus::Runtime::Runtime) }
@@ -19,7 +19,7 @@ module CSVPlusPlus
 
     sig do
       params(
-        options: ::CSVPlusPlus::Options,
+        options: ::CSVPlusPlus::Options::Options,
         runtime: ::CSVPlusPlus::Runtime::Runtime,
         block: ::T.proc.params(arg0: ::CSVPlusPlus::Compiler).void
       ).void
@@ -37,10 +37,10 @@ module CSVPlusPlus
         block.call(new(options:, runtime:))
       end
     ensure
-      runtime.cleanup!
+      runtime.position.cleanup!
     end
 
-    sig { params(options: ::CSVPlusPlus::Options, runtime: ::CSVPlusPlus::Runtime::Runtime).void }
+    sig { params(options: ::CSVPlusPlus::Options::Options, runtime: ::CSVPlusPlus::Runtime::Runtime).void }
     # @param options [Options]
     # @param runtime [Runtime]
     def initialize(options:, runtime:)
@@ -49,7 +49,7 @@ module CSVPlusPlus
 
       # TODO: infer a type
       # allow user-supplied key/values to override anything global or from the code section
-      @runtime.def_variables(
+      @runtime.scope.def_variables(
         options.key_values.transform_values { |v| ::CSVPlusPlus::Entities::String.new(v.to_s) }
       )
     end
@@ -72,17 +72,17 @@ module CSVPlusPlus
       rows = parse_csv_section!
 
       ::CSVPlusPlus::Template.new(rows:, runtime: @runtime).tap do |t|
-        t.validate_infinite_expands(@runtime)
+        t.validate_infinite_expands
         expanding! { t.expand_rows! }
         bind_all_vars! { t.bind_all_vars!(@runtime) }
         resolve_all_cells!(t)
       end
     end
 
-    sig { params(block: ::T.proc.params(runtime: ::CSVPlusPlus::Runtime::Runtime).void).void }
+    sig { params(block: ::T.proc.params(position: ::CSVPlusPlus::Runtime::Position).void).void }
     # Write the compiled results
     def outputting!(&block)
-      @runtime.start_at_csv! { block.call(@runtime) }
+      @runtime.start_at_csv! { block.call(@runtime.position) }
     end
 
     protected
@@ -94,7 +94,7 @@ module CSVPlusPlus
         # TODO: this flow can probably be refactored, it used to have more needs back when we had to
         # parse and save the code_section
         parsing_code_section do |input|
-          csv_section = ::CSVPlusPlus::Parser::CodeSection.new.parse(input, @runtime)
+          csv_section = ::CSVPlusPlus::Parser::CodeSection.new(@runtime.scope).parse(input)
 
           # return the csv_section to the caller because they're gonna re-write input with it
           next csv_section
@@ -108,16 +108,19 @@ module CSVPlusPlus
     # @return [Array<Row>]
     def parse_csv_section!
       @runtime.start_at_csv! do
-        @runtime.map_lines(::CSV.new(::T.unsafe(@runtime.input))) do |csv_row|
+        @runtime.position.map_lines(::CSV.new(::T.unsafe(@runtime.position.input))) do |csv_row|
           parse_row(::T.cast(csv_row, ::T::Array[::String]))
         end
       end
     ensure
       # we're done with the file and everything is in memory
-      @runtime.cleanup!
+      @runtime.position.cleanup!
     end
 
-    sig { params(template: ::CSVPlusPlus::Template).returns(::T::Array[::T::Array[::CSVPlusPlus::Entities::Entity]]) }
+    sig do
+      params(template: ::CSVPlusPlus::Template)
+        .returns(::T::Array[::T::Array[::T.nilable(::CSVPlusPlus::Entities::Entity)]])
+    end
     # Iterates through each cell of each row and resolves it's variable and function references.
     #
     # @param template [Template]
@@ -125,8 +128,8 @@ module CSVPlusPlus
     # @return [Array<Entity>]
     def resolve_all_cells!(template)
       @runtime.start_at_csv! do
-        @runtime.map_all_cells(template.rows) do |cell|
-          cell.ast = @runtime.resolve_cell_value if cell.ast
+        @runtime.position.map_all_cells(template.rows) do |cell|
+          cell.ast = @runtime.resolve_cell_value(::T.must(cell.ast)) if cell.ast
         end
       end
     end
@@ -147,8 +150,8 @@ module CSVPlusPlus
 
     sig { params(block: ::T.proc.params(arg0: ::String).returns(::String)).void }
     def parsing_code_section(&block)
-      csv_section = block.call(::T.must(::T.must(@runtime.input).read))
-      @runtime.rewrite_input!(csv_section)
+      csv_section = block.call(::T.must(::T.must(@runtime.position.input).read))
+      @runtime.position.rewrite_input!(csv_section)
     end
 
     sig { params(csv_row: ::T::Array[::T.nilable(::String)]).returns(::CSVPlusPlus::Row) }
@@ -161,17 +164,24 @@ module CSVPlusPlus
     def parse_row(csv_row)
       row_modifier = ::CSVPlusPlus::Modifier.new(@options, row_level: true)
 
-      cells = @runtime.map_row(csv_row) { |value, _cell_index| parse_cell(value || '', row_modifier) }
+      cells = @runtime.position.map_row(csv_row) { |value, _cell_index| parse_cell(value || '', row_modifier) }
 
-      ::CSVPlusPlus::Row.new(cells:, index: @runtime.row_index, modifier: row_modifier)
+      ::CSVPlusPlus::Row.new(cells:, index: @runtime.position.row_index, modifier: row_modifier)
     end
 
     sig { params(value: ::String, row_modifier: ::CSVPlusPlus::Modifier::Modifier).returns(::CSVPlusPlus::Cell) }
     def parse_cell(value, row_modifier)
       cell_modifier = ::CSVPlusPlus::Modifier.new(@options)
-      parsed_value = ::CSVPlusPlus::Parser::Modifier.new(cell_modifier:, row_modifier:).parse(value, @runtime)
-
-      ::CSVPlusPlus::Cell.parse(parsed_value, runtime:, modifier: cell_modifier)
+      parsed_value = ::CSVPlusPlus::Parser::Modifier.new(cell_modifier:, row_modifier:).parse(value)
+
+      ::CSVPlusPlus::Cell.new(
+        value: parsed_value,
+        row_index: @runtime.position.row_index,
+        index: @runtime.position.cell_index,
+        modifier: cell_modifier
+      ).tap do |c|
+        c.ast = ::CSVPlusPlus::Parser::CellValue.new.parse(parsed_value) unless parsed_value.nil?
+      end
     end
   end
   # rubocop:enable Metrics/ClassLength

data/lib/csv_plus_plus/entities/ast_builder.rb

@@ -25,8 +25,7 @@ module CSVPlusPlus
       # @return [Entity, #super]
       # rubocop:disable Naming/BlockForwarding
       def method_missing(method_name, *args, **kwargs, &block)
-        entity_class_name = method_name.to_s.split('_').map(&:capitalize).join.to_sym
-        ::CSVPlusPlus::Entities.const_get(entity_class_name).new(*args, **kwargs, &block)
+        ::CSVPlusPlus::Entities.const_get(snake_case_to_class_name(method_name)).new(*args, **kwargs, &block)
       rescue ::NameError
         super
       end
@@ -41,10 +40,18 @@ module CSVPlusPlus
       #
       # @return [::T::Boolean, #super]
       def respond_to_missing?(method_name, *_args)
-        !::CSVPlusPlus::Entities::Type.deserialize(method_name.to_s.gsub('_', '')).nil?
-      rescue ::KeyError
+        ::CSVPlusPlus::Entities.const_get(snake_case_to_class_name(method_name))
+        true
+      rescue ::NameError
         super
       end
+
+      private
+
+      sig { params(method_name: ::Symbol).returns(::Symbol) }
+      def snake_case_to_class_name(method_name)
+        method_name.to_s.split('_').map(&:capitalize).join.to_sym
+      end
     end
   end
 end

data/lib/csv_plus_plus/entities/boolean.rb

@@ -6,34 +6,41 @@ module CSVPlusPlus
     # A boolean value
     #
     # @attr_reader value [true, false]
-    class Boolean < Entity
+    class Boolean < ::CSVPlusPlus::Entities::Entity
+      extend ::T::Sig
+
       sig { returns(::T::Boolean) }
       attr_reader :value
 
       sig { params(value: ::T.any(::String, ::T::Boolean)).void }
       # @param value [::String, boolean]
       def initialize(value)
-        super(::CSVPlusPlus::Entities::Type::Boolean)
+        super()
         # TODO: probably can do a lot better in general on type validation
         @value = ::T.let(value.is_a?(::String) ? (value.downcase == 'true') : value, ::T::Boolean)
       end
 
-      sig { override.params(_runtime: ::CSVPlusPlus::Runtime::Runtime).returns(::String) }
-      # @param _runtime [Runtime]
+      sig do
+        override.params(_position: ::CSVPlusPlus::Runtime::Position).returns(::String)
+      end
+      # @param _position [Position]
       #
       # @return [::String]
-      def evaluate(_runtime)
+      def evaluate(_position)
         @value.to_s.upcase
       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) && value == other.value
+        case other
+        when self.class
+          value == other.value
+        else
+          false
+        end
       end
     end
   end

data/lib/csv_plus_plus/entities/builtins.rb

@@ -1,58 +1,86 @@
-# typed: false
+# 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(->(r) { number(r.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(->(r) { cell_reference(row_index: r.row_index, cell_index: r.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(->(r) { cell_reference(row_index: [0, (r.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(->(r) { cell_reference(row_index: r.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(->(r) { number(r.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(->(r) { cell_reference(row_index: r.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(->(r, args) { cell_reference(ref: [args[0], [1, (r.rownum - 1)].max].join) }),
-        cellabove: runtime_value(
-          lambda { |r, args|
-            cell_reference(cell_index: args[0].cell_index, row_index: [0, (r.row_index - 1)].max)
-          }
-        ),
-
-        # A reference to a cell in the current row
-        celladjacent: runtime_value(
-          lambda { |r, args|
-            cell_reference(cell_index: args[0].cell_index, row_index: r.row_index)
-          }
-        ),
-
-        # A reference to a cell below the current row
-        cellbelow: runtime_value(
-          lambda { |r, args|
-            cell_reference(cell_index: args[0].cell_index, row_index: r.row_index + 1)
-          }
-        )
-      }.freeze
+      # 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(->(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(->(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

@@ -6,7 +6,7 @@ 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) }
@@ -30,7 +30,7 @@ module CSVPlusPlus
       sig { params(value: ::String).void }
       # @param value [::String] The user-inputted date value
       def initialize(value)
-        super(::CSVPlusPlus::Entities::Type::Date)
+        super()
 
         parsed =
           begin
@@ -41,22 +41,25 @@ module CSVPlusPlus
         @value = ::T.let(parsed, ::Date)
       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.strftime('%m/%d/%y')
       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]
+      # @return [Boolean]
       def ==(other)
-        return false unless super
-
-        other.is_a?(self.class) && other.value == @value
+        case other
+        when self.class
+          other.value == @value
+        else
+          false
+        end
       end
     end
   end

data/lib/csv_plus_plus/entities/entity.rb

@@ -3,48 +3,30 @@
 
 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 [Entities::Type] The type of the entity. Each type should have a corresponding class definition
-    #   in CSVPlusPlus::Entities
+    # All classes that are a part of an AST must implement this interface
     class Entity
       extend ::T::Sig
       extend ::T::Helpers
 
       abstract!
 
-      sig { returns(::T.nilable(::Symbol)) }
-      attr_reader :id
-
-      sig { returns(::CSVPlusPlus::Entities::Type) }
-      attr_reader :type
-
-      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
-        @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 #==
+      sig { abstract.params(other: ::BasicObject).returns(::T::Boolean) }
+      # Each node in the AST needs to implement #== so we can compare entities for equality
+      #
       # @param other [Entity]
       #
       # @return [boolean]
-      def ==(other)
-        self.class == other.class && @type == other.type && @id == other.id
-      end
+      def ==(other); end
 
-      sig { abstract.params(_runtime: ::CSVPlusPlus::Runtime::Runtime).returns(::String) }
-      # Uses the given +runtime+ to evaluate itself in the current context
+      sig do
+        abstract.params(position: ::CSVPlusPlus::Runtime::Position).returns(::String)
+      end
+      # Uses the given +position+ to evaluate itself in the current context
       #
-      # @param _runtime [Runtime] The current runtime
+      # @param position [Position] The current runtime
       #
       # @return [::String]
-      def evaluate(_runtime); end
+      def evaluate(position); end
     end
   end
 end