csv_plus_plus 0.1.3 → 0.2.1

data/lib/csv_plus_plus/reader/rubyxl.rb

@@ -0,0 +1,37 @@
+# typed: strict
+# frozen_string_literal: true
+
+module CSVPlusPlus
+  module Reader
+    # Reads an Excel file
+    class RubyXL < ::CSVPlusPlus::Reader::Reader
+      extend ::T::Sig
+      extend ::T::Generic
+
+      CellValue = type_member { { fixed: ::RubyXL::Cell } }
+      public_constant :CellValue
+
+      sig { params(options: ::CSVPlusPlus::Options::FileOptions, worksheet: ::RubyXL::Worksheet).void }
+      # Open an excel outputter to the +output_filename+ specified by the +Options+
+      #
+      # @param options [Options] The supplied options.
+      # @param worksheet [RubyXL::Worksheet] The already-opened RubyXL worksheet
+      def initialize(options, worksheet)
+        super()
+
+        @options = options
+        @worksheet = worksheet
+      end
+
+      sig { override.params(cell: ::CSVPlusPlus::Cell).returns(::T.nilable(::CSVPlusPlus::Reader::RubyXL::CellValue)) }
+      # Get the current value at the +cell+'s position
+      #
+      # @param cell [Cell]
+      #
+      # @return [RubyXL::Cell, nil]
+      def value_at(cell)
+        @worksheet.sheet_data[cell.row_index]&.[](cell.index)
+      end
+    end
+  end
+end

data/lib/csv_plus_plus/reader.rb

@@ -0,0 +1,14 @@
+# typed: strict
+# frozen_string_literal: true
+
+module CSVPlusPlus
+  # Classes which can read spreadsheets in our various formats.
+  module Reader
+  end
+end
+
+require_relative './reader/reader'
+
+require_relative './reader/csv'
+require_relative './reader/google_sheets'
+require_relative './reader/rubyxl'

data/lib/csv_plus_plus/runtime/graph.rb

@@ -9,18 +9,18 @@ module CSVPlusPlus
     module Graph
       # Get a list of all variables references in a given +ast+
       # TODO: this is only used in one place - refactor it
-      def self.variable_references(ast, runtime, include_runtime_variables: false)
+      def self.variable_references(ast, include_runtime_variables: false)
         depth_first_search(ast) do |node|
-          next unless node.type == ::CSVPlusPlus::Entities::Type::Variable
+          next unless node.is_a?(::CSVPlusPlus::Entities::Reference)
 
-          node.id if !runtime.builtin_variable?(node.id) || include_runtime_variables
+          node.id if !::CSVPlusPlus::Entities::Builtins.builtin_variable?(node.id) || include_runtime_variables
         end
       end
 
       # Create a dependency graph of +variables+
-      def self.dependency_graph(variables, runtime)
+      def self.dependency_graph(variables)
         ::CSVPlusPlus::Runtime::Graph::DependencyGraph[
-          variables.map { |var_id, ast| [var_id, variable_references(ast, runtime)] }
+          variables.map { |var_id, ast| [var_id, variable_references(ast)] }
         ]
       end
 
@@ -47,7 +47,7 @@ module CSVPlusPlus
         ret = yield(node)
         accum << ret unless ret.nil?
 
-        return accum unless node.type == ::CSVPlusPlus::Entities::Type::FunctionCall
+        return accum unless node.is_a?(::CSVPlusPlus::Entities::FunctionCall)
 
         node.arguments.each { |n| depth_first_search(n, accum, &) }
         accum

data/lib/csv_plus_plus/runtime/{position_tracker.rb → position.rb}

@@ -3,9 +3,15 @@
 
 module CSVPlusPlus
   module Runtime
-    # Functions needed to track all of the runtime pointers: current line number, current row number, current cell, etc.
-    # rubocop:disable Metrics/ModuleLength
-    module PositionTracker
+    # 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)) }
@@ -20,6 +26,12 @@ module CSVPlusPlus
       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
       #
@@ -179,7 +191,6 @@ module CSVPlusPlus
       # 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
-        self.line_number = 1
 
         ret = block.call
         finish!
@@ -226,6 +237,6 @@ module CSVPlusPlus
         self.line_number += 1
       end
     end
-    # rubocop:enable Metrics/ModuleLength
+    # rubocop:enable Metrics/ClassLength
   end
 end

data/lib/csv_plus_plus/runtime/references.rb

@@ -7,79 +7,84 @@ module CSVPlusPlus
     #
     # @attr functions [Array<Entities::Function>] Functions references
     # @attr variables [Array<Entities::Variable>] Variable references
-    # TODO: turn this into a CanExtractReferences?
     class References
       extend ::T::Sig
 
       sig { returns(::T::Array[::CSVPlusPlus::Entities::FunctionCall]) }
       attr_accessor :functions
 
-      sig { returns(::T::Array[::CSVPlusPlus::Entities::Variable]) }
+      sig { returns(::T::Array[::CSVPlusPlus::Entities::Reference]) }
       attr_accessor :variables
 
       sig do
         params(
           ast: ::CSVPlusPlus::Entities::Entity,
-          runtime: ::CSVPlusPlus::Runtime::Runtime
+          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 runtime [Runtime] The current runtime
+      # @param scope [Scope] The current scope
       #
       # @return [References]
-      def self.extract(ast, runtime)
+      def self.extract(ast, position, scope)
         new.tap do |refs|
           ::CSVPlusPlus::Runtime::Graph.depth_first_search(ast) do |node|
-            unless node.type == ::CSVPlusPlus::Entities::Type::FunctionCall \
-                || node.type == ::CSVPlusPlus::Entities::Type::Variable
-
+            unless node.is_a?(::CSVPlusPlus::Entities::FunctionCall) || node.is_a?(::CSVPlusPlus::Entities::Reference)
               next
             end
 
-            refs.functions << node if function_reference?(node, runtime)
-            refs.variables << node if variable_reference?(node, runtime)
+            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, runtime: ::CSVPlusPlus::Runtime::Runtime).returns(::T::Boolean)
+        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 runtime [Runtime] The current runtime
+      # @param scope [Scope] The current scope
       #
       # @return [boolean]
-      def self.variable_reference?(node, runtime)
-        return false unless node.type == ::CSVPlusPlus::Entities::Type::Variable
+      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)
 
-        if runtime.in_scope?(node.id)
-          true
-        else
-          runtime.raise_modifier_syntax_error(
-            "#{node.id} can only be referenced within the ![[expand]] where it was defined.",
-            node.id.to_s
+        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
+        )
       end
       private_class_method :variable_reference?
 
       sig do
-        params(node: ::CSVPlusPlus::Entities::Entity, runtime: ::CSVPlusPlus::Runtime::Runtime).returns(::T::Boolean)
+        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 runtime [Runtime] The current runtime
+      # @param scope [Scope] The current scope
       #
       # @return [boolean]
-      def self.function_reference?(node, runtime)
-        node.type == ::CSVPlusPlus::Entities::Type::FunctionCall \
-          && (runtime.defined_function?(node.id) || runtime.builtin_function?(::T.must(node.id)))
+      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?
 
@@ -87,7 +92,7 @@ module CSVPlusPlus
       # 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::Variable])
+        @variables = ::T.let([], ::T::Array[::CSVPlusPlus::Entities::Reference])
       end
 
       sig { params(other: ::CSVPlusPlus::Runtime::References).returns(::T::Boolean) }

data/lib/csv_plus_plus/runtime/runtime.rb

@@ -7,25 +7,17 @@ module CSVPlusPlus
     # 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 filename [String, nil] The filename that the input came from (mostly used for debugging since
-    #   +filename+ can be +nil+ if it's read from stdin.
-    #
-    # @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)
+    # @attr_reader position [Runtime::Position]
+    # @attr_reader scope [Runtime::Scope]
+    # @attr_reader source_code [SourceCode]
     class Runtime
       extend ::T::Sig
 
-      include ::CSVPlusPlus::Runtime::CanDefineReferences
-      include ::CSVPlusPlus::Runtime::CanResolveReferences
-      include ::CSVPlusPlus::Runtime::PositionTracker
-
-      sig { returns(::T::Hash[::Symbol, ::CSVPlusPlus::Entities::Function]) }
-      attr_reader :functions
+      sig { returns(::CSVPlusPlus::Runtime::Position) }
+      attr_reader :position
 
-      sig { returns(::T::Hash[::Symbol, ::CSVPlusPlus::Entities::Entity]) }
-      attr_reader :variables
+      sig { returns(::CSVPlusPlus::Runtime::Scope) }
+      attr_reader :scope
 
       sig { returns(::CSVPlusPlus::SourceCode) }
       attr_reader :source_code
@@ -33,47 +25,52 @@ module CSVPlusPlus
       sig do
         params(
           source_code: ::CSVPlusPlus::SourceCode,
-          functions: ::T::Hash[::Symbol, ::CSVPlusPlus::Entities::Function],
-          variables: ::T::Hash[::Symbol, ::CSVPlusPlus::Entities::Entity]
+          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 functions [Hash<Symbol, Function>] Pre-defined functions
-      # @param variables [Hash<Symbol, Entity>] Pre-defined variables
-      def initialize(source_code:, functions: {}, variables: {})
-        @functions = functions
-        @variables = variables
+      # @param scope [Runtime::Scope, nil] The (optional) scope if it already exists
+      def initialize(source_code:, position: nil, scope: nil)
         @source_code = source_code
-
-        rewrite_input!(source_code.input)
+        @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(fn_id: ::Symbol).returns(::T::Boolean) }
-      # Is +fn_id+ a builtin function?
+      sig { params(var_id: ::Symbol).returns(::CSVPlusPlus::Entities::Reference) }
+      # Bind +var_id+ to the current cell
       #
-      # @param fn_id [Symbol] The Function#id to check if it's a runtime variable
+      # @param var_id [Symbol] The name of the variable to bind the cell reference to
       #
-      # @return [T::Boolean]
-      def builtin_function?(fn_id)
-        ::CSVPlusPlus::Entities::Builtins::FUNCTIONS.key?(fn_id)
+      # @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 { 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 [T::Boolean]
-      def builtin_variable?(var_id)
-        ::CSVPlusPlus::Entities::Builtins::VARIABLES.key?(var_id)
+      sig do
+        params(var_id: ::Symbol, expand: ::CSVPlusPlus::Modifier::Expand).returns(::CSVPlusPlus::Entities::Reference)
       end
-
-      sig { returns(::T::Boolean) }
-      # Is the parser currently inside of the code section? (includes the `---`)
+      # Bind +var_id+ relative to a cell relative to an ![[expand]] modifier.  The variable can only be referenced
+      # inside rows of that expand.
       #
-      # @return [T::Boolean]
-      def parsing_code_section?
-        source_code.in_code_section?(line_number)
+      # @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) }
@@ -81,35 +78,44 @@ module CSVPlusPlus
       #
       # @return [T::Boolean]
       def parsing_csv_section?
-        source_code.in_csv_section?(line_number)
+        source_code.in_csv_section?(position.line_number)
       end
 
-      sig do
-        params(message: ::String, bad_input: ::String, wrapped_error: ::T.nilable(::StandardError))
-          .returns(::T.noreturn)
-      end
-      # Called when an error is encoutered during parsing formulas (whether in the code section or a cell).  It will
-      # construct a useful error with the current +@row/@cell_index+, +@line_number+ and +@filename+
+      sig { params(ast: ::CSVPlusPlus::Entities::Entity).returns(::CSVPlusPlus::Entities::Entity) }
+      # Resolve all values in the ast of the current cell being processed
       #
-      # @param message [::String] A message relevant to why this error is being raised.
-      # @param bad_input [::String] The offending input that caused this error to be thrown.
-      # @param wrapped_error [StandardError, nil] The underlying error that was raised (if it's not from our own logic)
-      def raise_formula_syntax_error(message, bad_input, wrapped_error: nil)
-        raise(::CSVPlusPlus::Error::FormulaSyntaxError.new(message, bad_input, self, wrapped_error:))
+      # @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
-        params(message: ::String, bad_input: ::String, wrapped_error: ::T.nilable(::StandardError))
-          .returns(::T.noreturn)
+        type_parameters(:R).params(block: ::T.proc.returns(::T.type_parameter(:R))).returns(::T.type_parameter(:R))
       end
-      # Called when an error is encountered while parsing a modifier.
-      #
-      # @param message [::String] A message relevant to why this error is being raised.
-      # @param bad_input [::String] The offending input that caused this error to be thrown.
-      # @param wrapped_error [StandardError, nil] The underlying error that was raised (if it's not from our own logic)
-      def raise_modifier_syntax_error(message, bad_input, wrapped_error: nil)
-        raise(::CSVPlusPlus::Error::ModifierSyntaxError.new(self, bad_input:, message:, wrapped_error:))
+      # 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))
@@ -117,8 +123,8 @@ module CSVPlusPlus
       # Reset the runtime state starting at the CSV section
       # rubocop:disable Naming/BlockForwarding
       def start_at_csv!(&block)
-        self.line_number = source_code.length_of_code_section + 1
-        start!(&block)
+        position.line_number = source_code.length_of_code_section + 1
+        position.start!(&block)
       end
       # rubocop:enable Naming/BlockForwarding
     end