csv_plus_plus 0.1.2 → 0.2.0

data/lib/csv_plus_plus/template.rb

@@ -1,62 +1,96 @@
+# typed: strict
 # frozen_string_literal: true
 
 module CSVPlusPlus
   # Contains the data from a parsed csvpp template.
   #
   # @attr_reader rows [Array<Row>] The +Row+s that comprise this +Template+
-  # @attr_reader scope [Scope] The +Scope+ containing all function and variable references
+  # @attr_reader runtime [Runtime] The +Runtime+ containing all function and variable references
   class Template
-    attr_reader :rows, :scope
+    extend ::T::Sig
 
+    sig { returns(::T::Array[::CSVPlusPlus::Row]) }
+    attr_reader :rows
+
+    sig { returns(::CSVPlusPlus::Runtime::Runtime) }
+    attr_reader :runtime
+
+    sig { params(rows: ::T::Array[::CSVPlusPlus::Row], runtime: ::CSVPlusPlus::Runtime::Runtime).void }
     # @param rows [Array<Row>] The +Row+s that comprise this +Template+
-    # @param scope [Scope] The +Scope+ containing all function and variable references
-    def initialize(rows:, scope:)
-      @scope = scope
+    # @param runtime [Runtime] The +Runtime+ containing all function and variable references
+    def initialize(rows:, runtime:)
       @rows = rows
+      @runtime = runtime
     end
 
-    # @return [String]
-    def to_s
-      "Template(rows: #{@rows}, scope: #{@scope})"
+    sig { params(runtime: ::CSVPlusPlus::Runtime::Runtime).void }
+    # Only run after expanding all rows, now we can bind all [[var=]] modifiers to a variable.  There are two distinct
+    # types of variable bindings here:
+    #
+    # * Binding to a cell: for this we just make an +A1Reference+ to the cell itself (A1, B4, etc)
+    # * Binding to a cell within an expand: the variable can only be resolved within that expand and needs to be
+    #   relative to it's row (it can't be an absolute cell reference like above)
+    #
+    # @param runtime [Runtime] The current runtime
+    # rubocop:disable Metrics/MethodLength
+    def bind_all_vars!(runtime)
+      runtime.position.map_rows(@rows) do |row|
+        # rubocop:disable Style/MissingElse
+        if row.unexpanded?
+          # rubocop:enable Style/MissingElse
+          raise(
+            ::CSVPlusPlus::Error::CompilerError,
+            'Template#expand_rows! must be called before Template#bind_all_vars!'
+          )
+        end
+
+        runtime.position.map_row(row.cells) do |cell|
+          bind_vars(cell, row.modifier.expand)
+        end
+      end
     end
+    # rubocop:enable Metrics/MethodLength
 
-    # Apply any expand= modifiers to the parsed template
+    sig { returns(::T::Array[::CSVPlusPlus::Row]) }
+    # Apply expand= (adding rows to the results) modifiers to the parsed template. This happens in towards the end of
+    # compilation because expanding rows will change the relative rownums as rows are added, and variables can't be
+    # bound until the rows have been assigned their final rownums.
     #
     # @return [Array<Row>]
     def expand_rows!
-      expanded_rows = []
-      row_index = 0
-      expand_rows(
-        lambda do |new_row|
-          new_row.index = row_index
-          expanded_rows << new_row
-          row_index += 1
+      # TODO: make it so that an infinite expand will not overwrite the rows below it, but instead merge with them
+      @rows =
+        rows.reduce([]) do |expanded_rows, row|
+          if row.modifier.expand
+            row.expand_rows(starts_at: expanded_rows.length, into: expanded_rows)
+          else
+            expanded_rows << row.tap { |r| r.index = expanded_rows.length }
+          end
         end
-      )
-
-      @rows = expanded_rows
     end
 
+    sig { void }
     # Make sure that the template has a valid amount of infinite expand modifiers
-    #
-    # @param runtime [Runtime] The compiler's current runtime
-    def validate_infinite_expands(runtime)
+    def validate_infinite_expands
       infinite_expand_rows = @rows.filter { |r| r.modifier.expand&.infinite? }
       return unless infinite_expand_rows.length > 1
 
-      runtime.raise_formula_syntax_error(
-        'You can only have one infinite expand= (on all others you must specify an amount)',
-        infinite_expand_rows[1]
+      raise(
+        ::CSVPlusPlus::Error::ModifierSyntaxError.new(
+          'You can only have one infinite expand= (on all others you must specify an amount)',
+          bad_input: infinite_expand_rows[1].to_s
+        )
       )
     end
 
-    # Provide a summary of the state of the template (and it's +@scope+)
+    sig { returns(::String) }
+    # Provide a summary of the state of the template (and it's +@runtime+)
     #
-    # @return [String]
+    # @return [::String]
     def verbose_summary
       # TODO: we can probably include way more stats in here
       <<~SUMMARY
-        #{@scope.verbose_summary}
+        #{@runtime.scope.verbose_summary}
 
         > #{@rows.length} rows to be written
       SUMMARY
@@ -64,17 +98,15 @@ module CSVPlusPlus
 
     private
 
-    def expand_rows(push_row_fn)
-      # TODO: make it so that an infinite expand will not overwrite the rows below it, but
-      # instead merge with them
-      rows.each do |row|
-        if row.modifier.expand
-          row.expand_amount.times do
-            push_row_fn.call(row.deep_clone)
-          end
-        else
-          push_row_fn.call(row)
-        end
+    sig { params(cell: ::CSVPlusPlus::Cell, expand: ::T.nilable(::CSVPlusPlus::Modifier::Expand)).void }
+    def bind_vars(cell, expand)
+      var = cell.modifier.var
+      return unless var
+
+      if expand
+        @runtime.bind_variable_in_expand(var, expand)
+      else
+        @runtime.bind_variable_to_cell(var)
       end
     end
   end

data/lib/csv_plus_plus/version.rb

@@ -1,6 +1,7 @@
+# typed: strict
 # frozen_string_literal: true
 
 module CSVPlusPlus
-  VERSION = '0.1.2'
+  VERSION = '0.2.0'
   public_constant :VERSION
 end

data/lib/csv_plus_plus/writer/csv.rb

@@ -1,3 +1,4 @@
+# typed: strict
 # frozen_string_literal: true
 
 require_relative './file_backer_upper'
@@ -5,29 +6,57 @@ require_relative './file_backer_upper'
 module CSVPlusPlus
   module Writer
     # A class that can output a +Template+ to CSV
-    class CSV < ::CSVPlusPlus::Writer::BaseWriter
+    class CSV < ::CSVPlusPlus::Writer::Writer
+      extend ::T::Sig
       include ::CSVPlusPlus::Writer::FileBackerUpper
+      include ::CSVPlusPlus::Writer::Merger
 
-      # write a +template+ to CSV
+      sig { params(options: ::CSVPlusPlus::Options::FileOptions, position: ::CSVPlusPlus::Runtime::Position).void }
+      # @param options [Options::FileOptions]
+      # @param position [Runtime::Position]
+      def initialize(options, position)
+        super(position)
+
+        @reader = ::T.let(::CSVPlusPlus::Reader::CSV.new(options), ::CSVPlusPlus::Reader::CSV)
+        @options = options
+      end
+
+      sig { override.params(template: ::CSVPlusPlus::Template).void }
+      # Write a +template+ to CSV
+      #
+      # @param template [Template] The template to use as input to be written.  It should have been compiled by calling
+      #   Compiler#compile_template
       def write(template)
-        # TODO: also read it and merge the results
         ::CSV.open(@options.output_filename, 'wb') do |csv|
-          template.rows.each do |row|
+          @position.map_rows(template.rows) do |row|
             csv << build_row(row)
           end
         end
       end
 
-      protected
+      sig { override.void }
+      # Write a backup of the current spreadsheet.
+      def write_backup
+        backup_file(@options)
+      end
 
-      def load_requires
-        require('csv')
+      sig { params(cell: ::CSVPlusPlus::Cell).returns(::T.nilable(::String)) }
+      # Turn the cell into a CSV-
+      def evaluate_cell(cell)
+        if (ast = cell.ast)
+          "=#{ast.evaluate(@position)}"
+        else
+          cell.value
+        end
       end
 
       private
 
+      sig { params(row: ::CSVPlusPlus::Row).returns(::T::Array[::T.nilable(::String)]) }
       def build_row(row)
-        row.cells.map(&:to_csv)
+        @position.map_row(row.cells) do |cell, _i|
+          merge_cell_value(existing_value: @reader.value_at(cell), new_value: evaluate_cell(cell), options: @options)
+        end
       end
     end
   end

data/lib/csv_plus_plus/writer/excel.rb

@@ -1,3 +1,4 @@
+# typed: strict
 # frozen_string_literal: true
 
 require_relative './file_backer_upper'
@@ -6,17 +7,36 @@ require_relative './rubyxl_builder'
 module CSVPlusPlus
   module Writer
     # A class that can output a +Template+ to an Excel file
-    class Excel < ::CSVPlusPlus::Writer::BaseWriter
+    class Excel < ::CSVPlusPlus::Writer::Writer
+      extend ::T::Sig
       include ::CSVPlusPlus::Writer::FileBackerUpper
 
-      # write the +template+ to an Excel file
+      sig { params(options: ::CSVPlusPlus::Options::FileOptions, position: ::CSVPlusPlus::Runtime::Position).void }
+      # @param options [Options::FileOptions]
+      # @param position [Runtime::Position]
+      def initialize(options, position)
+        super(position)
+
+        @options = options
+      end
+
+      sig { override.params(template: ::CSVPlusPlus::Template).void }
+      # Write the +template+ to an Excel file
+      #
+      # @param template [Template] The template to write
       def write(template)
         ::CSVPlusPlus::Writer::RubyXLBuilder.new(
-          input_filename: @options.output_filename,
-          rows: template.rows,
-          sheet_name: @options.sheet_name
+          options: @options,
+          position: @position,
+          rows: template.rows
         ).build_workbook.write(@options.output_filename)
       end
+
+      sig { override.void }
+      # Write a backup of the current spreadsheet.
+      def write_backup
+        backup_file(@options)
+      end
     end
   end
 end

data/lib/csv_plus_plus/writer/file_backer_upper.rb

@@ -1,3 +1,4 @@
+# typed: strict
 # frozen_string_literal: true
 
 module CSVPlusPlus
@@ -5,32 +6,44 @@ module CSVPlusPlus
     # A module that can be mixed into any Writer that needs to back up it's @output_filename (all of them except Google
     # Sheets)
     module FileBackerUpper
+      include ::Kernel
+      extend ::T::Sig
+
       # I don't want to include a bunch of second/millisecond stuff in the filename  unless we
       # really need to. so try a less specifically formatted filename then get more specific
-      DESIRED_BACKUP_FORMATS = [%(%Y_%m_%d-%I_%M%p), %(%Y_%m_%d-%I_%M_%S%p), %(%Y_%m_%d-%I_%M_%S_%L%p)].freeze
+      DESIRED_BACKUP_FORMATS = ::T.let(
+        [
+          %(%Y_%m_%d-%I_%M%p),
+          %(%Y_%m_%d-%I_%M_%S%p),
+          %(%Y_%m_%d-%I_%M_%S_%L%p)
+        ].freeze,
+        ::T::Array[::String]
+      )
       private_constant :DESIRED_BACKUP_FORMATS
 
+      sig { params(options: ::CSVPlusPlus::Options::FileOptions).returns(::T.nilable(::Pathname)) }
       # Assuming the underlying spreadsheet is file-based, create a backup of it
-      def write_backup
-        return unless ::File.exist?(@options.output_filename)
+      def backup_file(options)
+        return unless ::File.exist?(options.output_filename)
 
         # TODO: also don't do anything if the current backups contents haven't changed (do a md5sum or something)
 
-        attempt_backups.tap do |backed_up_to|
-          warn("Backed up #{@options.output_filename} to #{backed_up_to}") if @options.verbose
+        attempt_backups(options).tap do |backed_up_to|
+          puts("Backed up #{options.output_filename} to #{backed_up_to}") if options.verbose
         end
       end
 
       private
 
+      sig { params(options: ::CSVPlusPlus::Options::FileOptions).returns(::Pathname) }
       # rubocop:disable Metrics/MethodLength
-      def attempt_backups
+      def attempt_backups(options)
         attempted =
           # rubocop:disable Lint/ConstantResolution
           DESIRED_BACKUP_FORMATS.map do |file_format|
             # rubocop:enable Lint/ConstantResolution
-            filename = format_backup_filename(file_format)
-            backed_up_to = backup(filename)
+            filename = format_backup_filename(file_format, options.output_filename)
+            backed_up_to = backup(filename, options.output_filename)
 
             next filename unless backed_up_to
 
@@ -44,16 +57,17 @@ module CSVPlusPlus
       end
       # rubocop:enable Metrics/MethodLength
 
-      def backup(filename)
+      sig { params(filename: ::Pathname, output_filename: ::Pathname).returns(::T.nilable(::Pathname)) }
+      def backup(filename, output_filename)
         return if ::File.exist?(filename)
 
-        ::FileUtils.cp(@options.output_filename, filename)
+        ::FileUtils.cp(output_filename, filename)
         filename
       end
 
-      def format_backup_filename(file_format)
-        pn = ::Pathname.new(@options.output_filename)
-        pn.sub_ext("-#{::Time.now.strftime(file_format)}" + pn.extname)
+      sig { params(file_format: ::String, output_filename: ::Pathname).returns(::Pathname) }
+      def format_backup_filename(file_format, output_filename)
+        output_filename.sub_ext("-#{::Time.now.strftime(file_format)}" + output_filename.extname)
       end
     end
   end

data/lib/csv_plus_plus/writer/google_sheets.rb

@@ -1,118 +1,62 @@
+# typed: strict
 # frozen_string_literal: true
 
-require_relative '../google_api_client'
-require_relative 'base_writer'
-require_relative 'google_sheet_builder'
-
 module CSVPlusPlus
   module Writer
     # A class that can write a +Template+ to Google Sheets (via their API)
-    class GoogleSheets < ::CSVPlusPlus::Writer::BaseWriter
-      # TODO: it would be nice to raise this but we shouldn't expand out more than necessary for our data
-      SPREADSHEET_INFINITY = 1000
-      public_constant :SPREADSHEET_INFINITY
+    class GoogleSheets < ::CSVPlusPlus::Writer::Writer
+      extend ::T::Sig
+      include ::CSVPlusPlus::GoogleApiClient
 
-      # @param options [Options]
-      def initialize(options)
-        super(options)
+      sig do
+        params(options: ::CSVPlusPlus::Options::GoogleSheetsOptions, position: ::CSVPlusPlus::Runtime::Position).void
+      end
+      # @param options [Options::GoogleSheetsOptions]
+      # @param position [Runtime::Position]
+      def initialize(options, position)
+        super(position)
 
-        @sheet_id = options.google.sheet_id
-        @sheet_name = options.sheet_name
+        @options = ::T.let(options, ::CSVPlusPlus::Options::GoogleSheetsOptions)
+        @reader = ::T.let(::CSVPlusPlus::Reader::GoogleSheets.new(options), ::CSVPlusPlus::Reader::GoogleSheets)
       end
 
-      # write a +template+ to Google Sheets
+      sig { override.params(template: ::CSVPlusPlus::Template).void }
+      # Write a +template+ to Google Sheets
       #
       # @param template [Template]
       def write(template)
-        @sheets_client = ::CSVPlusPlus::GoogleApiClient.sheets_client
-
-        fetch_spreadsheet!
-        fetch_spreadsheet_values!
-
         create_sheet! if @options.create_if_not_exists
 
         update_cells!(template)
       end
 
-      # write a backup of the google sheet
+      sig { override.void }
+      # Write a backup of the Google Sheet that is about to be written
       def write_backup
-        drive_client = ::CSVPlusPlus::GoogleApiClient.drive_client
-        drive_client.copy_file(@sheet_id)
+        drive_client.copy_file(@options.sheet_id)
       end
 
       private
 
-      def format_range(range)
-        @sheet_name ? "'#{@sheet_name}'!#{range}" : range
-      end
-
-      def full_range
-        format_range('A1:Z1000')
-      end
-
-      def fetch_spreadsheet_values!
-        formatted_values = get_all_spreadsheet_values('FORMATTED_VALUE')
-        formula_values = get_all_spreadsheet_values('FORMULA')
-
-        return if formula_values.values.nil? || formatted_values.values.nil?
-
-        @current_values = extract_current_values(formatted_values, formula_values)
-      end
-
-      def extract_current_values(formatted_values, formula_values)
-        formatted_values.values.map.each_with_index do |row, x|
-          row.map.each_with_index do |_cell, y|
-            formula_value = formula_values.values[x][y]
-            if formula_value.is_a?(::String) && formula_value.start_with?('=')
-              formula_value
-            else
-              strip_to_nil(formatted_values.values[x][y])
-            end
-          end
-        end
-      end
-
-      def strip_to_nil(str)
-        str.strip.empty? ? nil : str
-      end
-
-      def get_all_spreadsheet_values(render_option)
-        @sheets_client.get_spreadsheet_values(@sheet_id, full_range, value_render_option: render_option)
-      end
-
-      def sheet
-        return unless @sheet_name
-
-        @spreadsheet.sheets.find { |s| s.properties.title.strip == @sheet_name.strip }
-      end
-
-      def fetch_spreadsheet!
-        @spreadsheet = @sheets_client.get_spreadsheet(@sheet_id)
-
-        return unless @sheet_name.nil?
-
-        @sheet_name = @spreadsheet.sheets&.first&.properties&.title
-      end
-
+      sig { void }
       def create_sheet!
-        return if sheet
+        return if @reader.sheet
 
-        @sheets_client.create_spreadsheet(@sheet_name)
-        fetch_spreadsheet!
-        @sheet_name = @spreadsheet.sheets.last.properties.title
+        sheets_client.create_spreadsheet(@options.sheet_name)
       end
 
+      sig { params(template: ::CSVPlusPlus::Template).void }
       def update_cells!(template)
-        @sheets_client.batch_update_spreadsheet(@sheet_id, builder(template).batch_update_spreadsheet_request)
+        sheets_client.batch_update_spreadsheet(@options.sheet_id, builder(template).batch_update_spreadsheet_request)
       end
 
+      sig { params(template: ::CSVPlusPlus::Template).returns(::CSVPlusPlus::Writer::GoogleSheetsBuilder) }
       def builder(template)
-        ::CSVPlusPlus::Writer::GoogleSheetBuilder.new(
-          rows: template.rows,
-          sheet_id: sheet&.properties&.sheet_id,
-          column_index: @options.offset[1],
-          row_index: @options.offset[0],
-          current_sheet_values: @current_values
+        ::CSVPlusPlus::Writer::GoogleSheetsBuilder.new(
+          options: @options,
+          position: @position,
+          reader: @reader,
+          rows: template.rows
         )
       end
     end