csv_plus_plus 0.1.2 → 0.2.0

data/lib/csv_plus_plus/runtime/position.rb

@@ -0,0 +1,242 @@
+# typed: strict
+# frozen_string_literal: true
+
+module CSVPlusPlus
+  module Runtime
+    # Keeps track of the position in a file where the parser is.  The parser makes various passes over the input but
+    # it always needs to track the same things (line number, cell/row index, current cell)
+    #
+    # @attr cell [Cell] The current cell being processed
+    # @attr cell_index [Integer] The index of the current cell being processed (starts at 0)
+    # @attr row_index [Integer] The index of the current row being processed (starts at 0)
+    # @attr line_number [Integer] The line number of the original csvpp template (starts at 1)
+    # rubocop:disable Metrics/ClassLength
+    class Position
+      extend ::T::Sig
+
+      sig { params(cell: ::T.nilable(::CSVPlusPlus::Cell)).returns(::T.nilable(::CSVPlusPlus::Cell)) }
+      attr_writer :cell
+
+      sig { params(cell_index: ::T.nilable(::Integer)).returns(::T.nilable(::Integer)) }
+      attr_writer :cell_index
+
+      sig { params(line_number: ::T.nilable(::Integer)).returns(::T.nilable(::Integer)) }
+      attr_writer :line_number
+
+      sig { params(row_index: ::T.nilable(::Integer)).returns(::T.nilable(::Integer)) }
+      attr_writer :row_index
+
+      sig { params(input: ::String).void }
+      # @param input [String]
+      def initialize(input)
+        rewrite_input!(::CSVPlusPlus::Lexer.preprocess(input))
+      end
+
+      sig { returns(::CSVPlusPlus::Cell) }
+      # The current cell index.  This will only be set when processing the CSV section
+      #
+      # @return [Cell]
+      def cell
+        @cell ||= ::T.let(nil, ::T.nilable(::CSVPlusPlus::Cell))
+        assert_initted!(@cell)
+      end
+
+      sig { returns(::Integer) }
+      # The current CSV cell index.
+      #
+      # This will only be set when processing the CSV section and will throw an exception otherwise.  It is up to the
+      # caller (the compiler) to make sure it's called in the context of a compilation stage and/or a
+      # +#map_row+/+#map_rows+/+#map_lines+
+      #
+      # @return [Integer]
+      def cell_index
+        @cell_index ||= ::T.let(nil, ::T.nilable(::Integer))
+        assert_initted!(@cell_index)
+      end
+
+      sig { returns(::Integer) }
+      # The current CSV row index.  This will only be set when processing the CSV section
+      #
+      # This will only be set when processing the CSV section and will throw an exception otherwise.  It is up to the
+      # caller (the compiler) to make sure it's called in the context of a compilation stage and/or a
+      # +#map_row+/+#map_rows+/+#map_lines+
+      #
+      # @return [Integer]
+      def row_index
+        @row_index ||= ::T.let(nil, ::T.nilable(::Integer))
+        assert_initted!(@row_index)
+      end
+
+      sig { returns(::Integer) }
+      # The current line number being processed.  The line number is based on the entire file, irregardless of if it's
+      # parsing the code section or the CSV section
+      #
+      # This will only be set when processing the csvpp file and will throw an exception otherwise.  It is up to the
+      # caller (the compiler) to make sure it's called in the context of a compilation stage and/or a
+      # +#map_row+/+#map_rows+/+#map_lines+
+      #
+      # @return [Integer]
+      def line_number
+        @line_number ||= ::T.let(nil, ::T.nilable(::Integer))
+        assert_initted!(@line_number)
+      end
+
+      sig { void }
+      # Clean up the Tempfile we're using for parsing
+      def cleanup!
+        input&.close
+        input&.unlink
+      end
+
+      sig { returns(::T.nilable(::Tempfile)) }
+      # The currently available input for parsing.  The tmp state will be re-written
+      # between parsing the code section and the CSV section
+      #
+      # @return [::Tempfile]
+      def input
+        @input ||= ::T.let(::Tempfile.new, ::T.nilable(::Tempfile))
+      end
+
+      sig do
+        type_parameters(:I, :O).params(
+          lines: ::T::Enumerable[::T.type_parameter(:I)],
+          block: ::T.proc.params(args0: ::T.type_parameter(:I)).returns(::T.type_parameter(:O))
+        ).returns(::T::Array[::T.type_parameter(:O)])
+      end
+      # Map over a csvpp file and keep track of line_number and row_index
+      #
+      # @param lines [Array]
+      #
+      # @return [Array]
+      def map_lines(lines, &block)
+        self.line_number = 1
+        lines.map do |line|
+          ret = block.call(line)
+          next_line!
+          ret
+        end
+      end
+
+      sig do
+        type_parameters(:I, :O)
+          .params(
+            row: ::T::Enumerable[::T.all(::T.type_parameter(:I), ::Object)],
+            block: ::T.proc.params(
+              cell: ::T.all(::T.type_parameter(:I), ::Object),
+              index: ::Integer
+            ).returns(::T.type_parameter(:O))
+          )
+          .returns(::T::Array[::T.type_parameter(:O)])
+      end
+      # Map over a single row and keep track of the cell and it's index
+      #
+      # @param row [Array<Cell>] The row to map each cell over
+      #
+      # @return [Array]
+      def map_row(row, &block)
+        row.map.with_index do |cell, index|
+          self.cell_index = index
+          self.cell = cell if cell.is_a?(::CSVPlusPlus::Cell)
+          block.call(cell, index)
+        end
+      end
+
+      sig do
+        type_parameters(:O).params(
+          rows: ::T::Enumerable[::CSVPlusPlus::Row],
+          block: ::T.proc.params(row: ::CSVPlusPlus::Row).returns(::T.type_parameter(:O))
+        ).returns(::T::Array[::T.type_parameter(:O)])
+      end
+      # Map over all rows and keep track of row and line numbers
+      #
+      # @param rows [Array<Row>] The rows to map over (and keep track of indexes)
+      #
+      # @return [Array]
+      def map_rows(rows, &block)
+        self.row_index = 0
+        map_lines(rows) do |row|
+          block.call(row)
+        end
+      end
+
+      sig do
+        type_parameters(:R)
+          .params(rows: ::T::Enumerable[::CSVPlusPlus::Row],
+                  block: ::T.proc.params(cell: ::CSVPlusPlus::Cell, index: ::Integer).returns(::T.type_parameter(:R)))
+          .returns(::T::Array[::T::Array[::T.type_parameter(:R)]])
+      end
+      # Map over all +rows+ and over all of their +cells+, calling the +&block+ with each +Cell+
+      #
+      # @param rows [Array<Row>]
+      #
+      # @return [Array<Array>]
+      # rubocop:disable Naming/BlockForwarding
+      def map_all_cells(rows, &block)
+        self.row_index = 0
+        map_lines(rows) { |row| map_row(row.cells, &block) }
+      end
+      # rubocop:enable Naming/BlockForwarding
+
+      sig { returns(::Integer) }
+      # Return the current spreadsheet row number.  It parallels +@row_index+ but starts at 1.
+      #
+      # @return [Integer, nil]
+      def rownum
+        row_index + 1
+      end
+
+      sig do
+        type_parameters(:R).params(block: ::T.proc.returns(::T.type_parameter(:R))).returns(::T.type_parameter(:R))
+      end
+      # Each time we run a parse on the input, reset the runtime state starting at the beginning of the file
+      def start!(&block)
+        @row_index = @cell_index = 0
+
+        ret = block.call
+        finish!
+        ret
+      end
+
+      sig { params(data: ::String).void }
+      # We mutate the input over and over. It's ok because it's just a Tempfile
+      #
+      # @param data [::String] The data to rewrite our input file to
+      def rewrite_input!(data)
+        input&.truncate(0)
+        input&.write(data)
+        input&.rewind
+      end
+
+      private
+
+      sig do
+        type_parameters(:R).params(runtime_value: ::T.nilable(::T.type_parameter(:R))).returns(::T.type_parameter(:R))
+      end
+      def assert_initted!(runtime_value)
+        ::T.must_because(runtime_value) do
+          'Runtime value accessed without an initialized runtime.  Make sure you call Runtime#start! or ' \
+            'Runtime#start_at_csv! first.'
+        end
+      end
+
+      sig { void }
+      # Called to mark the trackers dirty.  It should be an error to use them outside of an initialized context.
+      def finish!
+        @line_number = nil
+        @row_index = nil
+        @cell_index = nil
+        @cell = nil
+      end
+
+      sig { returns(::Integer) }
+      # Increment state to the next line
+      #
+      # @return [Integer]
+      def next_line!
+        self.row_index += 1
+        self.line_number += 1
+      end
+    end
+    # rubocop:enable Metrics/ClassLength
+  end
+end

data/lib/csv_plus_plus/runtime/references.rb

@@ -0,0 +1,115 @@
+# typed: strict
+# frozen_string_literal: true
+
+module CSVPlusPlus
+  module Runtime
+    # References in an AST that need to be resolved
+    #
+    # @attr functions [Array<Entities::Function>] Functions references
+    # @attr variables [Array<Entities::Variable>] Variable references
+    class References
+      extend ::T::Sig
+
+      sig { returns(::T::Array[::CSVPlusPlus::Entities::FunctionCall]) }
+      attr_accessor :functions
+
+      sig { returns(::T::Array[::CSVPlusPlus::Entities::Reference]) }
+      attr_accessor :variables
+
+      sig do
+        params(
+          ast: ::CSVPlusPlus::Entities::Entity,
+          position: ::CSVPlusPlus::Runtime::Position,
+          scope: ::CSVPlusPlus::Runtime::Scope
+        ).returns(::CSVPlusPlus::Runtime::References)
+      end
+      # Extract references from an AST and return them in a new +References+ object
+      #
+      # @param ast [Entity] An +Entity+ to do a depth first search on for references.  Entities can be
+      #   infinitely deep because they can contain other function calls as params to a function call
+      # @param scope [Scope] The current scope
+      #
+      # @return [References]
+      def self.extract(ast, position, scope)
+        new.tap do |refs|
+          ::CSVPlusPlus::Runtime::Graph.depth_first_search(ast) do |node|
+            unless node.is_a?(::CSVPlusPlus::Entities::FunctionCall) || node.is_a?(::CSVPlusPlus::Entities::Reference)
+              next
+            end
+
+            refs.functions << node if function_reference?(node, scope)
+            refs.variables << node if variable_reference?(node, position, scope)
+          end
+        end
+      end
+
+      sig do
+        params(
+          node: ::CSVPlusPlus::Entities::Entity,
+          position: ::CSVPlusPlus::Runtime::Position,
+          scope: ::CSVPlusPlus::Runtime::Scope
+        ).returns(::T::Boolean)
+      end
+      # Is the node a resolvable variable reference?
+      #
+      # @param node [Entity] The node to check if it's resolvable
+      # @param scope [Scope] The current scope
+      #
+      # @return [boolean]
+      def self.variable_reference?(node, position, scope)
+        return false unless node.is_a?(::CSVPlusPlus::Entities::Reference)
+
+        id = node.id
+        return false unless id && scope.variables.key?(id)
+
+        return true if scope.in_scope?(id, position)
+
+        raise(
+          ::CSVPlusPlus::Error::ModifierSyntaxError.new(
+            "Reference #{node.ref} can only be referenced within the ![[expand]] where it was defined.",
+            bad_input: node.ref.to_s
+          )
+        )
+      end
+      private_class_method :variable_reference?
+
+      sig do
+        params(node: ::CSVPlusPlus::Entities::Entity, scope: ::CSVPlusPlus::Runtime::Scope).returns(::T::Boolean)
+      end
+      # Is the node a resolvable function reference?
+      #
+      # @param node [Entity] The node to check if it's resolvable
+      # @param scope [Scope] The current scope
+      #
+      # @return [boolean]
+      def self.function_reference?(node, scope)
+        node.is_a?(::CSVPlusPlus::Entities::FunctionCall) \
+          && (scope.functions.key?(node.id) || ::CSVPlusPlus::Entities::Builtins.builtin_function?(node.id))
+      end
+      private_class_method :function_reference?
+
+      sig { void }
+      # Create an object with empty references.  The caller will build them up as it depth-first-searches
+      def initialize
+        @functions = ::T.let([], ::T::Array[::CSVPlusPlus::Entities::FunctionCall])
+        @variables = ::T.let([], ::T::Array[::CSVPlusPlus::Entities::Reference])
+      end
+
+      sig { params(other: ::CSVPlusPlus::Runtime::References).returns(::T::Boolean) }
+      # @param other [References]
+      #
+      # @return [boolean]
+      def ==(other)
+        @functions == other.functions && @variables == other.variables
+      end
+
+      sig { returns(::T::Boolean) }
+      # Are there any references to be resolved?
+      #
+      # @return [::T::Boolean]
+      def empty?
+        @functions.empty? && @variables.empty?
+      end
+    end
+  end
+end

data/lib/csv_plus_plus/runtime/runtime.rb

@@ -0,0 +1,132 @@
+# typed: strict
+# frozen_string_literal: true
+
+module CSVPlusPlus
+  module Runtime
+    # The runtime state of the compiler (the current +line_number+/+row_index+, +cell+ being processed, etc) for parsing
+    # a given file.  We take multiple runs through the input file for parsing so it's really convenient to have a
+    # central place for these things to be managed.
+    #
+    # @attr_reader position [Runtime::Position]
+    # @attr_reader scope [Runtime::Scope]
+    # @attr_reader source_code [SourceCode]
+    class Runtime
+      extend ::T::Sig
+
+      sig { returns(::CSVPlusPlus::Runtime::Position) }
+      attr_reader :position
+
+      sig { returns(::CSVPlusPlus::Runtime::Scope) }
+      attr_reader :scope
+
+      sig { returns(::CSVPlusPlus::SourceCode) }
+      attr_reader :source_code
+
+      sig do
+        params(
+          source_code: ::CSVPlusPlus::SourceCode,
+          position: ::T.nilable(::CSVPlusPlus::Runtime::Position),
+          scope: ::T.nilable(::CSVPlusPlus::Runtime::Scope)
+        ).void
+      end
+      # @param position [Position, nil] The (optional) position to start at
+      # @param source_code [SourceCode] The source code being compiled
+      # @param scope [Runtime::Scope, nil] The (optional) scope if it already exists
+      def initialize(source_code:, position: nil, scope: nil)
+        @source_code = source_code
+        @scope = ::T.let(scope || ::CSVPlusPlus::Runtime::Scope.new, ::CSVPlusPlus::Runtime::Scope)
+        @position = ::T.let(
+          position || ::CSVPlusPlus::Runtime::Position.new(source_code.input),
+          ::CSVPlusPlus::Runtime::Position
+        )
+      end
+
+      sig { params(var_id: ::Symbol).returns(::CSVPlusPlus::Entities::Reference) }
+      # Bind +var_id+ to the current cell
+      #
+      # @param var_id [Symbol] The name of the variable to bind the cell reference to
+      #
+      # @return [Entities::Reference]
+      def bind_variable_to_cell(var_id)
+        ::CSVPlusPlus::Entities::Reference.new(
+          a1_ref: ::CSVPlusPlus::A1Reference.new(cell_index: position.cell_index, row_index: position.row_index)
+        ).tap do |var|
+          scope.def_variable(var_id, var)
+        end
+      end
+
+      sig do
+        params(var_id: ::Symbol, expand: ::CSVPlusPlus::Modifier::Expand).returns(::CSVPlusPlus::Entities::Reference)
+      end
+      # Bind +var_id+ relative to a cell relative to an ![[expand]] modifier.  The variable can only be referenced
+      # inside rows of that expand.
+      #
+      # @param var_id [Symbol] The name of the variable to bind the cell reference to
+      # @param expand [Expand] The expand where the variable is accessible (where it will be bound relative to)
+      #
+      # @return [Entities::Reference]
+      def bind_variable_in_expand(var_id, expand)
+        ::CSVPlusPlus::Entities::Reference.new(
+          a1_ref: ::CSVPlusPlus::A1Reference.new(scoped_to_expand: expand, cell_index: position.cell_index)
+        ).tap do |var|
+          scope.def_variable(var_id, var)
+        end
+      end
+
+      sig { returns(::T::Boolean) }
+      # Is the parser currently inside of the CSV section?
+      #
+      # @return [T::Boolean]
+      def parsing_csv_section?
+        source_code.in_csv_section?(position.line_number)
+      end
+
+      sig { params(ast: ::CSVPlusPlus::Entities::Entity).returns(::CSVPlusPlus::Entities::Entity) }
+      # Resolve all values in the ast of the current cell being processed
+      #
+      # @param ast [Entities::Entity] The AST to replace references within
+      #
+      # @return [Entity] The AST with all references replaced
+      # rubocop:disable Metrics/MethodLength
+      def resolve_cell_value(ast)
+        last_round = nil
+        ::Kernel.loop do
+          refs = ::CSVPlusPlus::Runtime::References.extract(ast, position, scope)
+          return ast if refs.empty?
+
+          # TODO: throw a +CompilerError+ here instead I think - basically we did a round and didn't make progress
+          return ast if last_round == refs
+
+          ast = scope.resolve_functions(
+            position,
+            scope.resolve_variables(position, ast, refs.variables),
+            refs.functions
+          )
+        end
+      end
+      # rubocop:enable Metrics/MethodLength
+
+      sig do
+        type_parameters(:R).params(block: ::T.proc.returns(::T.type_parameter(:R))).returns(::T.type_parameter(:R))
+      end
+      # Each time we run a parse on the input, reset the runtime state starting at the beginning of the file
+      # rubocop:disable Naming/BlockForwarding
+      def start!(&block)
+        position.line_number = 1
+        position.start!(&block)
+      end
+      # rubocop:enable Naming/BlockForwarding
+
+      sig do
+        type_parameters(:R).params(block: ::T.proc.returns(::T.type_parameter(:R))).returns(::T.type_parameter(:R))
+      end
+      # Reset the runtime state starting at the CSV section
+      # rubocop:disable Naming/BlockForwarding
+      def start_at_csv!(&block)
+        position.line_number = source_code.length_of_code_section + 1
+        position.start!(&block)
+      end
+      # rubocop:enable Naming/BlockForwarding
+    end
+  end
+end