csv_plus_plus 0.1.3 → 0.2.0

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

data/lib/csv_plus_plus/entities/entity_with_arguments.rb

@@ -7,50 +7,37 @@ module CSVPlusPlus
     # are function calls and function definitions
     #
     # @attr_reader arguments [Array<Entity>] The arguments supplied to this entity.
-    class EntityWithArguments < Entity
+    class EntityWithArguments < ::CSVPlusPlus::Entities::Entity
       extend ::T::Sig
+      extend ::T::Helpers
+      extend ::T::Generic
 
       abstract!
 
-      sig { returns(::T::Array[::CSVPlusPlus::Entities::Entity]) }
+      ArgumentsType = type_member
+      public_constant :ArgumentsType
+
+      sig { returns(::T::Array[::CSVPlusPlus::Entities::EntityWithArguments::ArgumentsType]) }
       attr_reader :arguments
 
-      sig do
-        params(
-          type: ::CSVPlusPlus::Entities::Type,
-          id: ::T.nilable(::Symbol),
-          arguments: ::T::Array[::CSVPlusPlus::Entities::Entity]
-        ).void
-      end
-      # @param type [Entities::Type]
-      # @param id [::String]
-      # @param arguments [Array<Entity>]
-      def initialize(type, id: nil, arguments: [])
-        super(type, id:)
+      sig { params(arguments: ::T::Array[::CSVPlusPlus::Entities::EntityWithArguments::ArgumentsType]).void }
+      # @param arguments [Array<ArgumentsType>]
+      def initialize(arguments: [])
+        super()
         @arguments = arguments
       end
 
-      sig { override.params(other: ::CSVPlusPlus::Entities::Entity).returns(::T::Boolean) }
+      sig { override.params(other: ::BasicObject).returns(::T::Boolean) }
       # @param other [Entity]
       #
       # @return [boolean]
       def ==(other)
-        return false unless other.is_a?(self.class)
-
-        @arguments == other.arguments && super
-      end
-
-      protected
-
-      sig do
-        params(arguments: ::T::Array[::CSVPlusPlus::Entities::Entity])
-          .returns(::T::Array[::CSVPlusPlus::Entities::Entity])
-      end
-      attr_writer :arguments
-
-      sig { params(runtime: ::CSVPlusPlus::Runtime::Runtime).returns(::T::Array[::String]) }
-      def evaluate_arguments(runtime)
-        @arguments.map { |arg| arg.evaluate(runtime) }
+        case other
+        when self.class
+          @arguments == other.arguments
+        else
+          false
+        end
       end
     end
   end

data/lib/csv_plus_plus/entities/function.rb

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