csv_plus_plus 0.1.2 → 0.1.3

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) }
+    attr_reader :options
+
+    sig { returns(::CSVPlusPlus::Runtime::Runtime) }
+    attr_reader :runtime
 
+    sig do
+      params(
+        options: ::CSVPlusPlus::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!
     end
 
-    # @param runtime [Runtime]
+    sig { params(options: ::CSVPlusPlus::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.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,108 @@ module CSVPlusPlus
       parse_code_section!
       rows = parse_csv_section!
 
-      ::CSVPlusPlus::Template.new(rows:, scope: @scope).tap do |t|
+      ::CSVPlusPlus::Template.new(rows:, runtime: @runtime).tap do |t|
         t.validate_infinite_expands(@runtime)
-        expanding { t.expand_rows! }
+        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(runtime: ::CSVPlusPlus::Runtime::Runtime).void).void }
+    # Write the compiled results
+    def outputting!(&block)
+      @runtime.start_at_csv! { block.call(@runtime) }
     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.parse(input, @runtime)
+
+          # 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.map_lines(::CSV.new(::T.unsafe(@runtime.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!
     end
 
+    sig { params(template: ::CSVPlusPlus::Template).returns(::T::Array[::T::Array[::CSVPlusPlus::Entities::Entity]]) }
     # 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.map_all_cells(template.rows) do |cell|
+          cell.ast = @runtime.resolve_cell_value 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)
+    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)
     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.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.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
-      )
+      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)
     end
   end
+  # rubocop:enable Metrics/ClassLength
 end

data/lib/csv_plus_plus/entities/ast_builder.rb

@@ -1,65 +1,49 @@
+# 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)
+        entity_class_name = method_name.to_s.split('_').map(&:capitalize).join.to_sym
+        ::CSVPlusPlus::Entities.const_get(entity_class_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
+      # @param _args [::T.Untyped] 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 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)
-      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
+      # @return [::T::Boolean, #super]
+      def respond_to_missing?(method_name, *_args)
+        !::CSVPlusPlus::Entities::Type.deserialize(method_name.to_s.gsub('_', '')).nil?
+      rescue ::KeyError
+        super
       end
     end
   end

data/lib/csv_plus_plus/entities/boolean.rb

@@ -1,30 +1,39 @@
+# typed: strict
 # frozen_string_literal: true
 
-require_relative './entity'
-
 module CSVPlusPlus
   module Entities
     # A boolean value
     #
     # @attr_reader value [true, false]
     class Boolean < Entity
+      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(::CSVPlusPlus::Entities::Type::Boolean)
         # 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 { override.params(_runtime: ::CSVPlusPlus::Runtime::Runtime).returns(::String) }
+      # @param _runtime [Runtime]
+      #
+      # @return [::String]
+      def evaluate(_runtime)
         @value.to_s.upcase
       end
 
-      # @return [boolean]
+      sig { override.params(other: ::CSVPlusPlus::Entities::Entity).returns(::T::Boolean) }
+      # @param other [Entity]
+      #
+      # @return [::T::Boolean]
       def ==(other)
-        super && value == other.value
+        return false unless super
+
+        other.is_a?(self.class) && value == other.value
       end
     end
   end

data/lib/csv_plus_plus/entities/builtins.rb

@@ -1,3 +1,4 @@
+# typed: false
 # frozen_string_literal: true
 
 module CSVPlusPlus
@@ -8,35 +9,48 @@ module CSVPlusPlus
 
       VARIABLES = {
         # The number (integer) of the current cell. Starts at 1
-        cellnum: runtime_value(->(runtime) { number(runtime.cell_index + 1) }),
+        cellnum: runtime_value(->(r) { number(r.cell_index + 1) }),
 
         # A reference to the current cell
-        cellref: runtime_value(->(runtime) { ref(row_index: runtime.row_index, cell_index: runtime.cell_index) }),
+        cellref: runtime_value(->(r) { cell_reference(row_index: r.row_index, cell_index: r.cell_index) }),
 
         # A reference to the row above
-        rowabove: runtime_value(->(runtime) { ref(row_index: [0, (runtime.row_index - 1)].max) }),
+        rowabove: runtime_value(->(r) { cell_reference(row_index: [0, (r.row_index - 1)].max) }),
 
         # A reference to the row below
-        rowbelow: runtime_value(->(runtime) { ref(row_index: runtime.row_index + 1) }),
+        rowbelow: runtime_value(->(r) { cell_reference(row_index: r.row_index + 1) }),
 
         # The number (integer) of the current row.  Starts at 1
-        rownum: runtime_value(->(runtime) { number(runtime.rownum) }),
+        rownum: runtime_value(->(r) { number(r.rownum) }),
 
         # A reference to the current row
-        rowref: runtime_value(->(runtime) { ref(row_index: runtime.row_index) })
+        rowref: runtime_value(->(r) { cell_reference(row_index: r.row_index) })
       }.freeze
       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(->(runtime, args) { cell_reference([args[0], [1, (runtime.rownum - 1)].max].join) }),
+        # 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(->(runtime, args) { cell_reference([args[0], runtime.rownum].join) }),
+        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(->(runtime, args) { cell_reference([args[0], runtime.rownum + 1].join) })
+        cellbelow: runtime_value(
+          lambda { |r, args|
+            cell_reference(cell_index: args[0].cell_index, row_index: r.row_index + 1)
+          }
+        )
       }.freeze
       public_constant :FUNCTIONS
     end