csv_plus_plus 0.0.2

data/lib/csv_plus_plus/options.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require_relative './google_options'
+
+module CSVPlusPlus
+  # The options a user can supply
+  class Options
+    attr_accessor :backup, :create_if_not_exists, :key_values, :offset, :output_filename, :sheet_name, :verbose
+    attr_reader :google
+
+    # initialize
+    def initialize
+      @offset = [0, 0]
+      @create_if_not_exists = false
+      @key_values = {}
+      @verbose = false
+      # TODO: switch to true? probably a safer choice
+      @backup = false
+    end
+
+    # Set the Google Sheet ID
+    def google_sheet_id=(sheet_id)
+      @google = ::CSVPlusPlus::GoogleOptions.new(sheet_id)
+    end
+
+    # Returns an error string or nil if there are no validation problems
+    def validate
+      return if @google || @output_filename
+
+      'You must supply either a Google Sheet ID or an output file'
+    end
+
+    # Return a string with a verbose description of what we're doing with the options
+    def verbose_summary
+      <<~SUMMARY
+        #{summary_divider}
+
+        # csv++ Command Options
+
+        > Input filename                      | #{@filename}
+        > Sheet name                          | #{@sheet_name}
+        > Create sheet if it does not exist?  | #{@create_if_not_exists}
+        > Spreadsheet row-offset              | #{@offset[0]}
+        > Spreadsheet cell-offset             | #{@offset[1]}
+        > User-supplied key-values            | #{@key_values}
+        > Verbose                             | #{@verbose}
+
+        ## Output Options
+
+        > Backup                              | #{@backup}
+        > Output filename                     | #{@output_filename}
+
+        #{@google&.verbose_summary || ''}
+        #{summary_divider}
+      SUMMARY
+    end
+
+    # to_s
+    def to_s
+      "Options(create_if_not_exists: #{@create_if_not_exists}, google: #{@google}, key_values: #{@key_values}, " \
+        "offset: #{@offset}, sheet_name: #{@sheet_name}, verbose: #{@verbose})"
+    end
+
+    private
+
+    def summary_divider
+      '========================================================================='
+    end
+  end
+end

data/lib/csv_plus_plus/row.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require_relative 'cell'
+require_relative 'modifier.tab'
+
+module CSVPlusPlus
+  ##
+  # A row of a template
+  class Row
+    attr_reader :cells, :index, :modifier
+
+    # initialize
+    def initialize(index, cells, modifier)
+      @cells = cells
+      @modifier = modifier
+      @index = index
+    end
+
+    # Set the row index. And update the index of all affected cells
+    def index=(index)
+      @index = index
+      @cells.each { |cell| cell.row_index = index }
+    end
+
+    # How much this row will expand itself, if at all (0)
+    def expand_amount
+      return 0 unless @modifier.expand
+
+      @modifier.expand.repetitions || (1000 - @index)
+    end
+
+    # to_s
+    def to_s
+      "Row(index: #{index}, modifier: #{modifier}, cells: #{cells})"
+    end
+
+    # Return a deep copy of this row
+    def deep_clone
+      ::Marshal.load(::Marshal.dump(self))
+    end
+  end
+end

data/lib/csv_plus_plus/template.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module CSVPlusPlus
+  # Contains the flow and data from a code section and CSV section
+  class Template
+    attr_reader :rows, :scope
+
+    # initialize
+    def initialize(rows:, scope:)
+      @rows = rows
+      @scope = scope
+    end
+
+    # to_s
+    def to_s
+      "Template(rows: #{@rows}, scope: #{@scope})"
+    end
+
+    # Apply any expand= modifiers to the parsed template
+    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
+        end
+      )
+
+      @rows = expanded_rows
+    end
+
+    # Make sure that the template has a valid amount of infinite expand modifiers
+    def validate_infinite_expands(runtime)
+      infinite_expand_rows = @rows.filter { |r| r.modifier.expand&.infinite? }
+      return unless infinite_expand_rows.length > 1
+
+      runtime.raise_syntax_error(
+        'You can only have one infinite expand= (on all others you must specify an amount)',
+        infinite_expand_rows[1]
+      )
+    end
+
+    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
+      end
+    end
+  end
+end

data/lib/csv_plus_plus/version.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module CSVPlusPlus
+  VERSION = '0.0.2'
+  public_constant :VERSION
+end

data/lib/csv_plus_plus/writer/base_writer.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module CSVPlusPlus
+  module Writer
+    ##
+    # Some shared functionality that all Writers should build on
+    class BaseWriter
+      attr_accessor :options
+
+      protected
+
+      # Open a CSV outputter to +filename+
+      def initialize(options)
+        @options = options
+        load_requires
+      end
+
+      def load_requires; end
+    end
+  end
+end

data/lib/csv_plus_plus/writer/csv.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module CSVPlusPlus
+  module Writer
+    ##
+    # A class that can output a +Template+ to CSV
+    class CSV < ::CSVPlusPlus::Writer::BaseWriter
+      # write a +template+ to CSV
+      def write(template)
+        # TODO: also read it and merge the results
+        ::CSV.open(@options.output_filename, 'wb') do |csv|
+          template.rows.each do |row|
+            csv << build_row(row)
+          end
+        end
+      end
+
+      protected
+
+      def load_requires
+        require('csv')
+      end
+
+      private
+
+      def build_row(row)
+        row.cells.map(&:to_csv)
+      end
+    end
+  end
+end

data/lib/csv_plus_plus/writer/excel.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module CSVPlusPlus
+  module Writer
+    # A class that can output a +Template+ to an Excel file
+    class Excel < ::CSVPlusPlus::Writer::BaseWriter
+      # write a +template+ to an Excel file
+      def write(template)
+        # TODO
+      end
+    end
+  end
+end

data/lib/csv_plus_plus/writer/google_sheet_builder.rb

@@ -0,0 +1,173 @@
+# frozen_string_literal: true
+
+module CSVPlusPlus
+  module Writer
+    ##
+    # Given +rows+ from a +Template+, build requests compatible with Google Sheets Ruby API
+    # rubocop:disable Metrics/ClassLength
+    class GoogleSheetBuilder
+      # initialize
+      def initialize(current_sheet_values:, sheet_id:, rows:, column_index: 0, row_index: 0)
+        @current_sheet_values = current_sheet_values
+        @sheet_id = sheet_id
+        @rows = rows
+        @column_index = column_index
+        @row_index = row_index
+      end
+
+      # Build a Google::Apis::SheetsV4::BatchUpdateSpreadsheetRequest
+      def batch_update_spreadsheet_request
+        build_batch_request(@rows)
+      end
+
+      private
+
+      def sheets_ns
+        ::Google::Apis::SheetsV4
+      end
+
+      def sheets_color(color)
+        sheets_ns::Color.new(red: color.red, green: color.green, blue: color.blue)
+      end
+
+      def set_extended_value_type!(extended_value, value)
+        v = value || ''
+        if v.start_with?('=')
+          extended_value.formula_value = value
+        elsif v.match(/^-?[\d.]+$/)
+          extended_value.number_value = value
+        elsif v.downcase == 'true' || v.downcase == 'false'
+          extended_value.boolean_value = value
+        else
+          extended_value.string_value = value
+        end
+      end
+
+      def build_text_format(mod)
+        sheets_ns::TextFormat.new(
+          bold: mod.formatted?('bold') || nil,
+          italic: mod.formatted?('italic') || nil,
+          strikethrough: mod.formatted?('strikethrough') || nil,
+          underline: mod.formatted?('underline') || nil,
+
+          font_family: mod.fontfamily,
+          font_size: mod.fontsize,
+
+          foreground_color: mod.fontcolor ? sheets_color(mod.fontcolor) : nil
+        )
+      end
+
+      # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity
+      def build_cell_format(mod)
+        sheets_ns::CellFormat.new.tap do |cf|
+          cf.text_format = build_text_format(mod)
+
+          # TODO: are these not overwriting each other?
+          cf.horizontal_alignment = 'LEFT' if mod.aligned?('left')
+          cf.horizontal_alignment = 'RIGHT' if mod.aligned?('right')
+          cf.horizontal_alignment = 'CENTER' if mod.aligned?('center')
+          cf.vertical_alignment = 'TOP' if mod.aligned?('top')
+          cf.vertical_alignment = 'BOTTOM' if mod.aligned?('bottom')
+
+          cf.background_color = sheets_color(mod.color) if mod.color
+
+          cf.number_format = sheets_ns::NumberFormat.new(type: mod.numberformat) if mod.numberformat
+        end
+      end
+      # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity
+
+      def grid_range_for_cell(cell)
+        sheets_ns::GridRange.new(
+          sheet_id: @sheet_id,
+          start_column_index: cell.index,
+          end_column_index: cell.index + 1,
+          start_row_index: cell.row_index,
+          end_row_index: cell.row_index + 1
+        )
+      end
+
+      def current_value(row_index, cell_index)
+        @current_values[row_index][cell_index]
+      rescue ::StandardError
+        nil
+      end
+
+      def build_cell_value(cell)
+        sheets_ns::ExtendedValue.new.tap do |xv|
+          value =
+            if cell.value.nil?
+              current_value(cell.row_index, cell.index)
+            else
+              cell.to_csv
+            end
+
+          set_extended_value_type!(xv, value)
+        end
+      end
+
+      def build_cell_data(cell)
+        mod = cell.modifier
+
+        sheets_ns::CellData.new.tap do |cd|
+          cd.user_entered_format = build_cell_format(cell.modifier)
+          cd.note = mod.note if mod.note
+
+          # XXX apply data validation
+          cd.user_entered_value = build_cell_value(cell)
+        end
+      end
+
+      def build_row_data(row)
+        sheets_ns::RowData.new(values: row.cells.map { |cell| build_cell_data(cell) })
+      end
+
+      def build_update_cells_request(rows)
+        sheets_ns::UpdateCellsRequest.new(
+          fields: '*',
+          start: sheets_ns::GridCoordinate.new(
+            sheet_id: @sheet_id,
+            column_index: @column_index,
+            row_index: @row_index
+          ),
+          rows: rows.map { |row| build_row_data(row) }
+        )
+      end
+
+      def build_border(cell)
+        mod = cell.modifier
+        # TODO: allow different border styles per side
+        border = sheets_ns::Border.new(color: mod.bordercolor || '#000000', style: mod.borderstyle || 'solid')
+        sheets_ns::UpdateBordersRequest.new(
+          top: mod.border_along?('top') ? border : nil,
+          right: mod.border_along?('right') ? border : nil,
+          left: mod.border_along?('left') ? border : nil,
+          bottom: mod.border_along?('bottom') ? border : nil,
+          range: grid_range_for_cell(cell)
+        )
+      end
+
+      def build_update_borders_request(cell)
+        sheets_ns::Request.new(update_borders: build_border(cell))
+      end
+
+      # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+      def build_batch_request(rows)
+        sheets_ns::BatchUpdateSpreadsheetRequest.new.tap do |bu|
+          bu.requests =
+            rows.each_slice(1000).to_a.map do |chunked_rows|
+              sheets_ns::Request.new(update_cells: build_update_cells_request(chunked_rows))
+            end
+
+          rows.each do |row|
+            row.cells.filter { |c| c.modifier.any_border? }
+               .each do |cell|
+                 bu.requests << build_update_borders_request(cell)
+               end
+          end
+        end
+      end
+      # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
+    end
+    # rubocop:enable Metrics/ClassLength
+  end
+end

data/lib/csv_plus_plus/writer/google_sheets.rb

@@ -0,0 +1,139 @@
+# frozen_string_literal: true
+
+require_relative 'base_writer'
+require_relative 'google_sheet_builder'
+
+AUTH_SCOPES = ['https://www.googleapis.com/auth/spreadsheets'].freeze
+FULL_RANGE = 'A1:Z1000'
+
+module CSVPlusPlus
+  module Writer
+    # A class that can output a +Template+ to Google Sheets (via their API)
+    class GoogleSheets < ::CSVPlusPlus::Writer::BaseWriter
+      # XXX 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
+
+      # initialize
+      def initialize(options)
+        super(options)
+
+        @sheet_id = options.google.sheet_id
+        @sheet_name = options.sheet_name
+      end
+
+      # write a +template+ to Google Sheets
+      def write(template)
+        auth!
+
+        save_spreadsheet!
+        save_spreadsheet_values!
+
+        create_sheet! if @options.create_if_not_exists
+
+        update_cells!(template)
+      rescue ::Google::Apis::ClientError => e
+        handle_google_error(e)
+      end
+
+      protected
+
+      def load_requires
+        require('google/apis/sheets_v4')
+        require('googleauth')
+      end
+
+      private
+
+      def format_range(range)
+        @sheet_name ? "'#{@sheet_name}'!#{range}" : range
+      end
+
+      def full_range
+        format_range(::FULL_RANGE)
+      end
+
+      def auth!
+        @gs ||= sheets_ns::SheetsService.new
+        @gs.authorization = ::Google::Auth.get_application_default(::AUTH_SCOPES)
+      end
+
+      def save_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)
+        @gs.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 save_spreadsheet!
+        @spreadsheet = @gs.get_spreadsheet(@sheet_id)
+
+        return unless @sheet_name.nil?
+
+        @sheet_name = @spreadsheet.sheets&.first&.properties&.title
+      end
+
+      def create_sheet!
+        return if sheet
+
+        @gs.create_spreadsheet(@sheet_name)
+        get_spreadsheet!
+        @sheet_name = @spreadsheet.sheets.last.properties.title
+      end
+
+      def update_cells!(template)
+        builder = ::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_sheet_values
+        )
+        @gs.batch_update_spreadsheet(@sheet_id, builder.batch_update_spreadsheet_request)
+      rescue ::Google::Apis::ClientError => e
+        handle_google_error(e)
+      end
+
+      def sheets_ns
+        ::Google::Apis::SheetsV4
+      end
+
+      def handle_google_error(error)
+        if @options.verbose
+          warn("#{error.status_code} Error making Google Sheets API request [#{error.message}]: #{error.body}")
+        else
+          warn("Error making Google Sheets API request: #{error.message}")
+        end
+      end
+    end
+  end
+end

data/lib/csv_plus_plus/writer/open_document.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module CSVPlusPlus
+  module Writer
+    ##
+    # A class that can output a +Template+ to an Excel file
+    class OpenDocument < ::CSVPlusPlus::Writer::BaseWriter
+      # write a +template+ to an OpenDocument file
+      def write(template)
+        # TODO
+      end
+    end
+  end
+end

data/lib/csv_plus_plus/writer.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require_relative './writer/base_writer'
+require_relative './writer/csv'
+require_relative './writer/excel'
+require_relative './writer/google_sheets'
+require_relative './writer/open_document'
+
+module CSVPlusPlus
+  ##
+  # Various strategies for writing to various formats (excel, google sheets, CSV, OpenDocument)
+  module Writer
+    # Return an instance of a writer depending on the given +options+
+    def self.writer(options)
+      return ::CSVPlusPlus::Writer::GoogleSheets.new(options) if options.google
+
+      case options.output_filename
+      when /\.csv$/ then ::CSVPlusPlus::Writer::CSV.new(options)
+      when /\.ods$/ then ::CSVPlusPlus::Writer::OpenDocument.new(options)
+      when /\.xls$/ then ::CSVPlusPlus::Writer::Excel.new(options)
+      else raise(::StandardError, "Unsupported extension: #{options.output_filename}")
+      end
+    end
+  end
+end

data/lib/csv_plus_plus.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require_relative 'csv_plus_plus/language/compiler'
+require_relative 'csv_plus_plus/options'
+require_relative 'csv_plus_plus/writer'
+
+# A language for writing rich CSV data
+module CSVPlusPlus
+  # Parse the input into a +Template+ and write it to the desired format
+  def self.apply_template_to_sheet!(input, filename, options)
+    warn(options.verbose_summary) if options.verbose
+
+    ::CSVPlusPlus::Language::Compiler.with_compiler(input:, filename:, options:) do |c|
+      template = c.parse_template
+
+      output = ::CSVPlusPlus::Writer.writer(options)
+      c.outputting! { output.write(template) }
+    end
+  end
+end