csv_plus_plus 0.1.2 → 0.2.0

data/lib/csv_plus_plus/cli_flag.rb

@@ -1,7 +1,6 @@
+# typed: strict
 # frozen_string_literal: true
 
-require_relative './google_options'
-
 module CSVPlusPlus
   # Individual CLI flags that a user can supply
   #
@@ -9,83 +8,84 @@ 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) },
+      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('-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

@@ -1,3 +1,4 @@
+# typed: strict
 # frozen_string_literal: true
 
 module CSVPlusPlus
@@ -7,25 +8,49 @@ module CSVPlusPlus
   # attr_reader green_hex [String] The green value in hex ("FF", "00", "AF", etc)
   # attr_reader red_hex [String] The red value in hex ("FF", "00", "AF", etc)
   class Color
-    attr_reader :red_hex, :green_hex, :blue_hex
+    extend ::T::Sig
+
+    sig { returns(::String) }
+    attr_reader :red_hex
+
+    sig { returns(::String) }
+    attr_reader :green_hex
+
+    sig { returns(::String) }
+    attr_reader :blue_hex
 
     HEX_STRING_REGEXP = /^#?([0-9a-f]{1,2})([0-9a-f]{1,2})([0-9a-f]{1,2})/i
     public_constant :HEX_STRING_REGEXP
 
+    sig { params(hex_string: ::String).returns(::T::Boolean) }
+    # Is +hex_string+ a valid hexadecimal color code? This function will accept input like the 6-digit format: #FF00FF,
+    # 00AABB and the shorter 3-digit format: #FFF, 0FA.
+    #
+    # @param hex_string [::String] The string to see if it's valid hex string
+    #
     # @return [boolean]
     def self.valid_hex_string?(hex_string)
       !(hex_string.strip =~ ::CSVPlusPlus::Color::HEX_STRING_REGEXP).nil?
     end
 
+    sig { params(hex_string: ::String).void }
     # Create an instance from a string like "#FFF" or "#FFFFFF"
     #
     # @param hex_string [String] The hex string input to parse
+    # rubocop:disable Metrics/CyclomaticComplexity
     def initialize(hex_string)
-      @red_hex, @green_hex, @blue_hex = hex_string.strip.match(::CSVPlusPlus::Color::HEX_STRING_REGEXP)
+      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::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)
+      @blue_hex = ::T.let(blue_hex, ::String)
     end
+    # rubocop:enable Metrics/CyclomaticComplexity
 
+    sig { returns(::Float) }
     # The percent (decimal between 0-1) of red
     #
     # @return [Numeric]
@@ -33,6 +58,7 @@ module CSVPlusPlus
       hex_to_percent(@red_hex)
     end
 
+    sig { returns(::Float) }
     # The percent (decimal between 0-1) of green
     #
     # @return [Numeric]
@@ -40,6 +66,7 @@ module CSVPlusPlus
       hex_to_percent(@green_hex)
     end
 
+    sig { returns(::Float) }
     # The percent (decimal between 0-1) of blue
     #
     # @return [Numeric]
@@ -47,6 +74,7 @@ module CSVPlusPlus
       hex_to_percent(@blue_hex)
     end
 
+    sig { returns(::String) }
     # Create a hex representation of the color (without a '#')
     #
     # @return [::String]
@@ -54,11 +82,7 @@ module CSVPlusPlus
       [@red_hex, @green_hex, @blue_hex].join
     end
 
-    # @return [::String]
-    def to_s
-      "Color(r: #{@red_hex}, g: #{@green_hex}, b: #{@blue_hex})"
-    end
-
+    sig { params(other: ::Object).returns(::T::Boolean) }
     # @return [boolean]
     def ==(other)
       other.is_a?(self.class) &&
@@ -69,6 +93,7 @@ module CSVPlusPlus
 
     private
 
+    sig { params(hex: ::String).returns(::Float) }
     def hex_to_percent(hex)
       hex.to_i(16) / 255.0
     end

data/lib/csv_plus_plus/compiler.rb

@@ -1,59 +1,69 @@
+# typed: strict
 # frozen_string_literal: true
 
-require_relative 'benchmarked_compiler'
-require_relative 'entities'
-require_relative 'parser/code_section.tab'
-require_relative 'runtime'
-require_relative 'scope'
-
 module CSVPlusPlus
   # Encapsulates the parsing and building of objects (+Template+ -> +Row+ -> +Cell+). Variable resolution is delegated
   # to the +Scope+
   #
   # @attr_reader options [Options] The +Options+ to compile with
   # @attr_reader runtime [Runtime] The runtime execution
-  # @attr_reader scope [Scope] +Scope+ for variable resolution
+  # rubocop:disable Metrics/ClassLength
   class Compiler
-    attr_reader :options, :runtime, :scope
+    extend ::T::Sig
+
+    sig { returns(::CSVPlusPlus::Options::Options) }
+    attr_reader :options
 
+    sig { returns(::CSVPlusPlus::Runtime::Runtime) }
+    attr_reader :runtime
+
+    sig do
+      params(
+        options: ::CSVPlusPlus::Options::Options,
+        runtime: ::CSVPlusPlus::Runtime::Runtime,
+        block: ::T.proc.params(arg0: ::CSVPlusPlus::Compiler).void
+      ).void
+    end
     # Create a compiler and make sure it gets cleaned up
     #
-    # @param runtime [Runtime] The initial +Runtime+ for the compiler
     # @param options [Options]
-    def self.with_compiler(runtime:, options:, &block)
-      compiler = new(options:, runtime:)
+    # @param runtime [Runtime] The initial +Runtime+ for the compiler
+    def self.with_compiler(options:, runtime:, &block)
       if options.verbose
-        ::CSVPlusPlus::BenchmarkedCompiler.with_benchmarks(compiler) do |c|
+        ::CSVPlusPlus::BenchmarkedCompiler.with_benchmarks(options:, runtime:) do |c|
           block.call(c)
         end
       else
-        yield(compiler)
+        block.call(new(options:, runtime:))
       end
     ensure
-      runtime.cleanup!
+      runtime.position.cleanup!
     end
 
-    # @param runtime [Runtime]
+    sig { params(options: ::CSVPlusPlus::Options::Options, runtime: ::CSVPlusPlus::Runtime::Runtime).void }
     # @param options [Options]
-    # @param scope [Scope, nil]
-    def initialize(runtime:, options:, scope: nil)
+    # @param runtime [Runtime]
+    def initialize(options:, runtime:)
       @options = options
       @runtime = runtime
-      @scope = scope || ::CSVPlusPlus::Scope.new(runtime:)
 
       # TODO: infer a type
       # allow user-supplied key/values to override anything global or from the code section
-      @scope.def_variables(
+      @runtime.scope.def_variables(
         options.key_values.transform_values { |v| ::CSVPlusPlus::Entities::String.new(v.to_s) }
       )
     end
 
-    # Write the compiled results
-    def outputting!
-      @runtime.start_at_csv!
-      yield
+    sig { params(benchmark: ::Benchmark::Report).void }
+    # Attach a +Benchmark+ and a place to store timings to the compiler class.
+    #
+    # @param benchmark [Benchmark] A +Benchmark+ instance
+    def benchmark=(benchmark)
+      @benchmark = ::T.let(benchmark, ::T.nilable(::Benchmark::Report))
+      @timings = ::T.let([], ::T.nilable(::T::Array[::Benchmark::Tms]))
     end
 
+    sig { returns(::CSVPlusPlus::Template) }
     # Compile a template and return a +::CSVPlusPlus::Template+ instance ready to be written with a +Writer+
     #
     # @return [Template]
@@ -61,96 +71,118 @@ module CSVPlusPlus
       parse_code_section!
       rows = parse_csv_section!
 
-      ::CSVPlusPlus::Template.new(rows:, scope: @scope).tap do |t|
-        t.validate_infinite_expands(@runtime)
-        expanding { t.expand_rows! }
+      ::CSVPlusPlus::Template.new(rows:, runtime: @runtime).tap do |t|
+        t.validate_infinite_expands
+        expanding! { t.expand_rows! }
+        bind_all_vars! { t.bind_all_vars!(@runtime) }
         resolve_all_cells!(t)
       end
     end
 
-    # @return [String]
-    def to_s
-      "Compiler(options: #{@options}, runtime: #{@runtime}, scope: #{@scope})"
+    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.position) }
     end
 
     protected
 
-    # Parses the input file and returns a +CodeSection+
-    #
-    # @return [CodeSection]
+    sig { void }
+    # Parses the input file and sets variables on +@runtime+ as necessary
     def parse_code_section!
-      @runtime.start!
-
-      # 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(@scope).parse(input, @runtime)
-        # TODO: call scope.resolve_static_variables?? or maybe it doesn't matter
-
-        # return the csv_section to the caller because they're gonna re-write input with it
-        next csv_section
+      @runtime.start! do
+        # 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(@runtime.scope).parse(input)
+
+          # return the csv_section to the caller because they're gonna re-write input with it
+          next csv_section
+        end
       end
-      # @scope.code_section
     end
 
+    sig { returns(::T::Array[::CSVPlusPlus::Row]) }
     # Parse the CSV section and return an array of +Row+s
     #
     # @return [Array<Row>]
     def parse_csv_section!
-      @runtime.start_at_csv!
-      @runtime.map_rows(::CSV.new(runtime.input)) do |csv_row|
-        parse_row(csv_row)
+      @runtime.start_at_csv! do
+        @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 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]
+    #
     # @return [Array<Entity>]
     def resolve_all_cells!(template)
-      @runtime.start_at_csv!
-      @runtime.map_rows(template.rows, cells_too: true) do |cell|
-        cell.ast = @scope.resolve_cell_value if cell.ast
+      @runtime.start_at_csv! do
+        @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
 
+    sig { params(block: ::T.proc.void).void }
     # Expanding rows
-    def expanding
-      @runtime.start_at_csv!
-      yield
+    def expanding!(&block)
+      @runtime.start_at_csv! { block.call }
+    end
+
+    sig { params(block: ::T.proc.void).void }
+    # Binding all [[var=]] directives
+    def bind_all_vars!(&block)
+      @runtime.start_at_csv! { block.call }
     end
 
     private
 
-    def parsing_code_section
-      csv_section = yield(@runtime.input.read)
-      @runtime.rewrite_input!(csv_section)
+    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.position.input).read))
+      @runtime.position.rewrite_input!(csv_section)
     end
 
+    sig { params(csv_row: ::T::Array[::T.nilable(::String)]).returns(::CSVPlusPlus::Row) }
     # Using the current +@runtime+ and the given +csv_row+ parse it into a +Row+ of +Cell+s
     # +csv_row+ should have already been run through a CSV parser and is an array of strings
     #
     # @param csv_row [Array<Array<String>>]
+    #
     # @return [Row]
     def parse_row(csv_row)
-      row_modifier = ::CSVPlusPlus::ValidatedModifier.new(row_level: true)
+      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(@runtime.row_index, cells, 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::ValidatedModifier.new
-      parsed_value = ::CSVPlusPlus::Parser::Modifier.new(cell_modifier:, row_modifier:, scope: @scope).parse(
-        value,
-        @runtime
-      )
-
-      ::CSVPlusPlus::Cell.parse(parsed_value, runtime:, modifier: cell_modifier)
+      cell_modifier = ::CSVPlusPlus::Modifier.new(@options)
+      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
 end

data/lib/csv_plus_plus/entities/ast_builder.rb

@@ -1,65 +1,56 @@
+# typed: strict
 # frozen_string_literal: true
 
 module CSVPlusPlus
   module Entities
     # Some helpful functions that can be mixed into a class to help building ASTs
     module ASTBuilder
+      extend ::T::Sig
+
+      sig do
+        params(
+          method_name: ::Symbol,
+          args: ::T.untyped,
+          kwargs: ::T.untyped,
+          block: ::T.untyped
+        ).returns(::CSVPlusPlus::Entities::Entity)
+      end
       # Let the current class have functions which can build a given entity by calling it's type.  For example
       # +number(1)+, +variable(:foo)+
       #
       # @param method_name [Symbol] The +method_name+ to respond to
-      # @param arguments [] The arguments to create the entity with
+      # @param args [Array] The arguments to create the entity with
+      # @param kwargs [Hash] The arguments to create the entity with
       #
       # @return [Entity, #super]
-      def method_missing(method_name, *args, **kwargs, &)
-        entity_class = ::CSVPlusPlus::Entities::TYPES[method_name.to_sym]
-        return super unless entity_class
-
-        entity_class.new(*args, **kwargs, &)
+      # rubocop:disable Naming/BlockForwarding
+      def method_missing(method_name, *args, **kwargs, &block)
+        ::CSVPlusPlus::Entities.const_get(snake_case_to_class_name(method_name)).new(*args, **kwargs, &block)
+      rescue ::NameError
+        super
       end
+      # rubocop:enable Naming/BlockForwarding
 
+      sig { params(method_name: ::Symbol, _args: ::T.untyped).returns(::T::Boolean) }
       # Let the current class have functions which can build a given entity by calling it's type.  For example
       # +number(1)+, +variable(:foo)+
       #
       # @param method_name [Symbol] The +method_name+ to respond to
-      # @param arguments [] The arguments to create the entity with
-      #
-      # @return [Boolean, #super]
-      def respond_to_missing?(method_name, *_arguments)
-        ::CSVPlusPlus::Entities::TYPES.include?(method_name.to_sym) || super
-      end
-
-      # Turns index-based/X,Y coordinates into a A1 format
+      # @param _args [::T.Untyped] The arguments to create the entity with
       #
-      # @param row_index [Integer]
-      # @param cell_index [Integer]
-      #
-      # @return [String]
-      def ref(row_index: nil, cell_index: nil)
-        return unless row_index || cell_index
-
-        rowref = row_index ? (row_index + 1).to_s : ''
-        cellref = cell_index ? cell_ref(cell_index) : ''
-        cell_reference([cellref, rowref].join)
+      # @return [::T::Boolean, #super]
+      def respond_to_missing?(method_name, *_args)
+        ::CSVPlusPlus::Entities.const_get(snake_case_to_class_name(method_name))
+        true
+      rescue ::NameError
+        super
       end
 
       private
 
-      ALPHA = ('A'..'Z').to_a.freeze
-      private_constant :ALPHA
-
-      def cell_ref(cell_index)
-        c = cell_index.dup
-        ref = ''
-
-        while c >= 0
-          # rubocop:disable Lint/ConstantResolution
-          ref += ALPHA[c % 26]
-          # rubocop:enable Lint/ConstantResolution
-          c = (c / 26).floor - 1
-        end
-
-        ref.reverse
+      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

data/lib/csv_plus_plus/entities/boolean.rb

@@ -1,30 +1,46 @@
+# typed: strict
 # frozen_string_literal: true
 
-require_relative './entity'
-
 module CSVPlusPlus
   module Entities
     # 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
 
-      # @param value [String, Boolean]
+      sig { params(value: ::T.any(::String, ::T::Boolean)).void }
+      # @param value [::String, boolean]
       def initialize(value)
-        super(:boolean)
+        super()
         # TODO: probably can do a lot better in general on type validation
-        @value = value.is_a?(::String) ? (value.downcase == 'true') : value
+        @value = ::T.let(value.is_a?(::String) ? (value.downcase == 'true') : value, ::T::Boolean)
       end
 
-      # @return [String]
-      def to_s
+      sig do
+        override.params(_position: ::CSVPlusPlus::Runtime::Position).returns(::String)
+      end
+      # @param _position [Position]
+      #
+      # @return [::String]
+      def evaluate(_position)
         @value.to_s.upcase
       end
 
-      # @return [boolean]
+      sig { override.params(other: ::BasicObject).returns(::T::Boolean) }
+      # @param other [Entity]
+      #
+      # @return [::T::Boolean]
       def ==(other)
-        super && value == other.value
+        case other
+        when self.class
+          value == other.value
+        else
+          false
+        end
       end
     end
   end