csv_plus_plus 0.1.2 → 0.2.0

data/lib/csv_plus_plus/parser/modifier.tab.rb

@@ -7,32 +7,32 @@
 require 'racc/parser.rb'
 
 
-require_relative '../expand'
-require_relative '../lexer'
+require_relative '../lexer/racc_lexer'
 
 module CSVPlusPlus
   module Parser
     class Modifier < Racc::Parser
 
-module_eval(<<'...end modifier.y/module_eval...', 'modifier.y', 61)
-  attr_reader :return_value
+module_eval(<<'...end modifier.y/module_eval...', 'modifier.y', 60)
+  extend ::T::Sig
+  extend ::T::Generic
+  include ::CSVPlusPlus::Lexer::RaccLexer
 
-  include ::CSVPlusPlus::Lexer
+  ReturnType = type_member {{ fixed: ::T.nilable(::String) }}
 
   # @param cell_modifier [Modifier]
   # @param row_modifier [Modifier]
-  # @param scope [Scope]
-  def initialize(cell_modifier:, row_modifier:, scope:)
+  def initialize(cell_modifier:, row_modifier:)
     super()
 
     @parsing_row = false
-    @cell_modifier = cell_modifier
-    @row_modifier = row_modifier
-    @scope = scope
+    @cell_modifier = ::CSVPlusPlus::Modifier::ModifierValidator.new(cell_modifier)
+    @row_modifier = ::CSVPlusPlus::Modifier::ModifierValidator.new(row_modifier)
   end
 
   protected
 
+  sig { override.params(input: ::String).returns(::T::Boolean) }
   def anything_to_parse?(input)
     @modifiers_to_parse = input.scan(/!?\[\[/).count
 
@@ -44,10 +44,18 @@ module_eval(<<'...end modifier.y/module_eval...', 'modifier.y', 61)
     @modifiers_to_parse > 0
   end
 
+  sig { override.returns(::String) }
   def parse_subject
     'modifier'
   end
 
+  sig { override.returns(ReturnType) }
+  # The output of the parser
+  def return_value
+    @return_value
+  end
+
+  sig { override.returns(::CSVPlusPlus::Lexer::Tokenizer) }
   def tokenizer
     ::CSVPlusPlus::Lexer::Tokenizer.new(
       ignore: /\s+/,
@@ -61,42 +69,43 @@ module_eval(<<'...end modifier.y/module_eval...', 'modifier.y', 61)
         @modifiers_to_parse == 0
       end,
       tokens: [
-        [/\bborder\b/, 'border'],
-        [/\bbordercolor\b/, 'bordercolor'],
-        [/\bborderstyle\b/, 'borderstyle'],
-        [/\bcolor\b/, 'color'],
-        [/\bexpand\b/, 'expand'],
-        [/\bfontcolor\b/, 'fontcolor'],
-        [/\bfontfamily\b/, 'fontfamily'],
-        [/\bfontsize\b/, 'fontsize'],
-        [/\bformat\b/, 'format'],
-        [/\bfreeze\b/, 'freeze'],
-        [/\bhalign\b/, 'halign'],
-        [/\bnote\b/, 'note'],
-        [/\bnumberformat\b/, 'numberformat'],
-        [/\bvalidate\b/, 'validate'],
-        [/\bvalign\b/, 'valign'],
-        [/\bvar\b/, 'var'],
-        [/-?[\d.]+/, :NUMBER],
-        TOKEN_LIBRARY[:HEX_COLOR],
-        [
-          /
+        ::CSVPlusPlus::Lexer::Token.new(regexp: /\bborder\b/, token: 'border'),
+        ::CSVPlusPlus::Lexer::Token.new(regexp: /\bbordercolor\b/, token: 'bordercolor'),
+        ::CSVPlusPlus::Lexer::Token.new(regexp: /\bborderstyle\b/, token: 'borderstyle'),
+        ::CSVPlusPlus::Lexer::Token.new(regexp: /\bcolor\b/, token: 'color'),
+        ::CSVPlusPlus::Lexer::Token.new(regexp: /\bexpand\b/, token: 'expand'),
+        ::CSVPlusPlus::Lexer::Token.new(regexp: /\bfontcolor\b/, token: 'fontcolor'),
+        ::CSVPlusPlus::Lexer::Token.new(regexp: /\bfontfamily\b/, token: 'fontfamily'),
+        ::CSVPlusPlus::Lexer::Token.new(regexp: /\bfontsize\b/, token: 'fontsize'),
+        ::CSVPlusPlus::Lexer::Token.new(regexp: /\bformat\b/, token: 'format'),
+        ::CSVPlusPlus::Lexer::Token.new(regexp: /\bfreeze\b/, token: 'freeze'),
+        ::CSVPlusPlus::Lexer::Token.new(regexp: /\bhalign\b/, token: 'halign'),
+        ::CSVPlusPlus::Lexer::Token.new(regexp: /\bnote\b/, token: 'note'),
+        ::CSVPlusPlus::Lexer::Token.new(regexp: /\bnumberformat\b/, token: 'numberformat'),
+        ::CSVPlusPlus::Lexer::Token.new(regexp: /\bvalidate\b/, token: 'validate'),
+        ::CSVPlusPlus::Lexer::Token.new(regexp: /\bvalign\b/, token: 'valign'),
+        ::CSVPlusPlus::Lexer::Token.new(regexp: /\bvar\b/, token: 'var'),
+        ::CSVPlusPlus::Lexer::Token.new(regexp: /-?[1-9][\d.]*/, token: :NUMBER),
+        ::CSVPlusPlus::Lexer::Token.new(
+          regexp: /
             (?:
-              [\w,_:-]            # something that accepts most basic input if it doesn't need to be quoted
-              [\w\s,_:-]+         # same thing but allow spaces in the middle
-              [\w,_:-]            # no spaces at the end
-            )
-              |                   # - or -
+              \w+\s*:\s*'([^'\\]|\\.)*')    # allow for a single-quoted string which can accept any input and also allow 
+                                            # for escaping via backslash (i.e., 'ain\\'t won\\'t something' is valid)
+              |                             # - or -
+            (?:'([^'\\]|\\.)*')             # allow for a single-quoted string which can accept any input and also allow 
+              |
             (?:
-              '([^'\\]|\\.)*')    # allow for a single-quoted string which can accept any input and also allow 
-                                  # for escaping via backslash (i.e., 'ain\\'t won\\'t something' is valid)
+              [\w,_:-]                      # something that accepts most basic input if it doesn't need to be quoted
+              [\w\s,_:-]+                   # same thing but allow spaces in the middle
+              [\w,_:-]                      # no spaces at the end
+            )
           /x,
-          :RIGHT_SIDE,
-        ],
-        [/\[\[/, :START_CELL_MODIFIERS],
-        [/!\[\[/, :START_ROW_MODIFIERS],
-        [/\//, :MODIFIER_SEPARATOR],
-        [/=/, :EQ],
+          token: :RIGHT_SIDE,
+        ),
+        ::CSVPlusPlus::Lexer::Token.new(regexp: /\[\[/, token: :START_CELL_MODIFIERS),
+        ::CSVPlusPlus::Lexer::Token.new(regexp: /!\[\[/, token: :START_ROW_MODIFIERS),
+        ::CSVPlusPlus::Lexer::Token.new(regexp: /\//, token: :MODIFIER_SEPARATOR),
+        ::CSVPlusPlus::Lexer::Token.new(regexp: /=/, token: :EQ),
       ],
       alter_matches: {
         STRING: ->(s) { s.gsub(/^'|'$/, '') }
@@ -107,7 +116,7 @@ module_eval(<<'...end modifier.y/module_eval...', 'modifier.y', 61)
   private
 
   def assign_defaults!
-    @cell_modifier.take_defaults_from!(@row_modifier)
+    @cell_modifier.modifier.take_defaults_from!(@row_modifier.modifier)
   end
 
   def parsing_row!
@@ -123,11 +132,6 @@ module_eval(<<'...end modifier.y/module_eval...', 'modifier.y', 61)
     assign_defaults!
   end
 
-  def define_var(var_id)
-    @scope.bind_variable_to_cell(var_id)
-    modifier.var = var_id.to_sym
-  end
-
   def modifier
     @parsing_row ? @row_modifier : @cell_modifier
   end
@@ -160,7 +164,7 @@ racc_action_pointer = [
     36,    52,    41,   nil,   nil,   nil,    56,   nil,   -17,    -1,
    nil,    41,   nil,    49,    50,    51,    52,    53,    54,    55,
     56,    57,   nil,    58,    59,    60,    61,    62,    63,    42,
-   nil,    15,    59,    64,    61,    66,    66,    68,    65,    69,
+   nil,    15,    59,    60,    61,    62,    66,    64,    65,    69,
     67,    68,    69,    70,    71,    72,    73,   nil,   nil,   nil,
    nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,
    nil,   nil,   nil,   nil ]
@@ -393,7 +397,7 @@ module_eval(<<'.,.,', 'modifier.y', 39)
 
 module_eval(<<'.,.,', 'modifier.y', 40)
   def _reduce_15(val, _values, result)
-     modifier.expand!
+     modifier.infinite_expand!
     result
   end
 .,.,
@@ -456,7 +460,7 @@ module_eval(<<'.,.,', 'modifier.y', 48)
 
 module_eval(<<'.,.,', 'modifier.y', 49)
   def _reduce_24(val, _values, result)
-     modifier.validation = val[2]
+     modifier.validate = val[2]
     result
   end
 .,.,
@@ -470,7 +474,7 @@ module_eval(<<'.,.,', 'modifier.y', 50)
 
 module_eval(<<'.,.,', 'modifier.y', 51)
   def _reduce_26(val, _values, result)
-     define_var(val[2])
+     modifier.var = val[2]
     result
   end
 .,.,

data/lib/csv_plus_plus/reader/csv.rb

@@ -0,0 +1,50 @@
+# typed: strict
+# frozen_string_literal: true
+
+module CSVPlusPlus
+  module Reader
+    # Reads a CSV file
+    class CSV < ::CSVPlusPlus::Reader::Reader
+      extend ::T::Sig
+      extend ::T::Generic
+
+      CellValue = type_member { { fixed: ::String } }
+      public_constant :CellValue
+
+      sig { params(options: ::CSVPlusPlus::Options::FileOptions).void }
+      # Open a CSV outputter to the +output_filename+ specified by the +Options+
+      #
+      # @param options [Options] The supplied options.
+      def initialize(options)
+        super()
+
+        @options = options
+        @cell_values = ::T.let(
+          read_csv(@options.output_filename),
+          ::T::Array[::T::Array[::T.nilable(::CSVPlusPlus::Reader::CSV::CellValue)]]
+        )
+      end
+
+      sig { override.params(cell: ::CSVPlusPlus::Cell).returns(::T.nilable(::CSVPlusPlus::Reader::CSV::CellValue)) }
+      # Get the current value at the +cell+'s location.
+      #
+      # @param cell [Cell]
+      #
+      # @return [CellValue, nil]
+      def value_at(cell)
+        @cell_values[cell.row_index]&.[](cell.index)
+      end
+
+      protected
+
+      sig do
+        params(filename: ::Pathname).returns(::T::Array[::T::Array[::T.nilable(::CSVPlusPlus::Reader::CSV::CellValue)]])
+      end
+      def read_csv(filename)
+        return [[]] unless ::File.exist?(filename)
+
+        ::CSV.read(filename.to_s)
+      end
+    end
+  end
+end

data/lib/csv_plus_plus/reader/google_sheets.rb

@@ -0,0 +1,129 @@
+# typed: strict
+# frozen_string_literal: true
+
+module CSVPlusPlus
+  module Reader
+    # A class that can read an existing Google Sheets spreadsheet
+    class GoogleSheets < ::CSVPlusPlus::Reader::Reader
+      extend ::T::Sig
+      extend ::T::Generic
+      include ::CSVPlusPlus::GoogleApiClient
+
+      CellValue = type_member { { fixed: ::String } }
+      public_constant :CellValue
+
+      sig { params(options: ::CSVPlusPlus::Options::GoogleSheetsOptions).void }
+      # Open a CSV outputter to the +output_filename+ specified by the +Options+
+      #
+      # @param options [Options::GoogleSheetsOptions] The supplied options.
+      def initialize(options)
+        super()
+
+        @options = options
+        @cell_values = ::T.let(nil, ::T.nilable(::T::Array[::T::Array[::T.nilable(::String)]]))
+      end
+
+      sig do
+        override.params(cell: ::CSVPlusPlus::Cell).returns(::T.nilable(::CSVPlusPlus::Reader::GoogleSheets::CellValue))
+      end
+      # Get the current value at the +cell+'s location.
+      #
+      # @param cell [Cell]
+      #
+      # @return [CellValue, nil]
+      def value_at(cell)
+        cell_values[cell.row_index]&.[](cell.index)
+      end
+
+      sig { returns(::T.nilable(::Google::Apis::SheetsV4::Sheet)) }
+      # @return [Google::Apis::SheetsV4::Sheet, nil]
+      def sheet
+        spreadsheet.sheets.find { |s| s.properties.title.strip == @options.sheet_name.strip }
+      end
+
+      sig { returns(::Google::Apis::SheetsV4::Spreadsheet) }
+      # @return [Google::Apis::SheetsV4::Spreadsheet]
+      def spreadsheet
+        @spreadsheet ||= ::T.let(
+          sheets_client.get_spreadsheet(@options.sheet_id),
+          ::T.nilable(::Google::Apis::SheetsV4::Spreadsheet)
+        )
+
+        unless @spreadsheet
+          raise(::CSVPlusPlus::Error::WriterError, "Unable to connect to google spreadsheet #{@options.sheet_id}")
+        end
+
+        @spreadsheet
+      end
+
+      private
+
+      sig { returns(::T::Array[::T::Array[::T.nilable(::String)]]) }
+      # rubocop:disable Metrics/MethodLength
+      def cell_values
+        return @cell_values if @cell_values
+
+        formatted_values = get_all_spreadsheet_values('FORMATTED_VALUE')
+        formula_values = get_all_spreadsheet_values('FORMULA')
+
+        @cell_values =
+          ::T.must(
+            ::T.let(
+              if formula_values&.values.nil? || formatted_values&.values.nil?
+                []
+              else
+                extract_current_values(::T.must(formatted_values), ::T.must(formula_values))
+              end,
+              ::T.nilable(::T::Array[::T::Array[::T.nilable(::String)]])
+            )
+          )
+      end
+      # rubocop:enable Metrics/MethodLength
+
+      sig { params(render_option: ::String).returns(::T.nilable(::Google::Apis::SheetsV4::ValueRange)) }
+      def get_all_spreadsheet_values(render_option)
+        sheets_client.get_spreadsheet_values(@options.sheet_id, full_range, value_render_option: render_option)
+      rescue ::Google::Apis::ClientError => e
+        return if e.status_code == 404
+
+        raise
+      end
+
+      sig do
+        params(
+          formatted_values: ::Google::Apis::SheetsV4::ValueRange,
+          formula_values: ::Google::Apis::SheetsV4::ValueRange
+        ).returns(::T::Array[::T::Array[::T.nilable(::String)]])
+      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
+
+      sig { params(range: ::String).returns(::String) }
+      def format_range(range)
+        # "'#{@options.sheet_name}'!#{range}"
+        # XXX
+        range
+      end
+
+      sig { returns(::String) }
+      def full_range
+        format_range('A1:Z1000')
+      end
+
+      sig { params(str: ::String).returns(::T.nilable(::String)) }
+      def strip_to_nil(str)
+        str.strip.empty? ? nil : str
+      end
+    end
+  end
+end

data/lib/csv_plus_plus/reader/reader.rb

@@ -0,0 +1,27 @@
+# typed: strict
+# frozen_string_literal: true
+
+module CSVPlusPlus
+  module Reader
+    # +Reader+s are used to complement +Writer+ instances by reading in the existing spreadsheet and providing
+    # a way to merge in results.
+    class Reader
+      extend ::T::Sig
+      extend ::T::Generic
+      extend ::T::Helpers
+
+      abstract!
+
+      CellValue = type_member
+      public_constant :CellValue
+
+      sig { abstract.params(cell: ::CSVPlusPlus::Cell).returns(::T.nilable(::CSVPlusPlus::Reader::Reader::CellValue)) }
+      # Get the current value at the +cell+'s location.
+      #
+      # @param cell [Cell]
+      #
+      # @return [CellValue, nil]
+      def value_at(cell); end
+    end
+  end
+end

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/row.rb

@@ -1,23 +1,37 @@
+# typed: strict
 # frozen_string_literal: true
 
 module CSVPlusPlus
-  # A row of a template
+  # A row of a template.  A row contains an +Array+ of +Cell+s and possibly a row-level +Modifier+.
   #
-  # @attr_reader cells [Array<Cell>]
-  # @attr_reader index [Integer] The index of this row
+  # @attr_reader cells [Array<Cell>] The cells contained by this row.
+  # @attr_reader index [Integer] The index of this row. Starts at 0.
   # @attr_reader modifier [Modifier] The modifier to apply to all cells in this row
   class Row
-    attr_reader :cells, :index, :modifier
+    extend ::T::Sig
 
-    # @param index [Integer] The index of this row (starts at 0)
+    sig { returns(::T::Array[::CSVPlusPlus::Cell]) }
+    attr_reader :cells
+
+    sig { returns(::Integer) }
+    attr_reader :index
+
+    sig { returns(::CSVPlusPlus::Modifier::Modifier) }
+    attr_reader :modifier
+
+    sig do
+      params(cells: ::T::Array[::CSVPlusPlus::Cell], index: ::Integer, modifier: ::CSVPlusPlus::Modifier::Modifier).void
+    end
     # @param cells [Array<Cell>] The cells belonging to this row
+    # @param index [Integer] The index of this row (starts at 0)
     # @param modifier [Modifier] The modifier to apply to all cells in this row
-    def initialize(index, cells, modifier)
+    def initialize(cells:, index:, modifier:)
       @cells = cells
       @modifier = modifier
       @index = index
     end
 
+    sig { params(index: ::Integer).void }
     # Set the row's +index+ and update the +row_index+ of all affected cells
     #
     # @param index [Integer] The index of this row (starts at 0)
@@ -26,25 +40,52 @@ module CSVPlusPlus
       @cells.each { |cell| cell.row_index = index }
     end
 
+    sig { returns(::Integer) }
     # How much this row will expand itself, if at all (0)
     #
     # @return [Integer]
     def expand_amount
-      return 0 unless @modifier.expand
+      return 0 if @modifier.expand.nil?
 
-      @modifier.expand.repetitions || (1000 - @index)
+      ::T.must(@modifier.expand).repetitions || (1000 - @index)
     end
 
-    # @return [String]
-    def to_s
-      "Row(index: #{index}, modifier: #{modifier}, cells: #{cells})"
+    sig { params(starts_at: ::Integer, into: ::T::Array[::CSVPlusPlus::Row]).returns(::T::Array[::CSVPlusPlus::Row]) }
+    # Starting at +starts_at+, do a deep copy of this row into the +Array+ referenced by +into+.
+    #
+    # @param starts_at [Integer] The +row_index+ where this row was expanded.
+    # @param into [Array<Row>] An array where the expanded rows will be accumulated.
+    #
+    # @return [Array<Row>] The rows expanded
+    def expand_rows(starts_at:, into: [])
+      return into if @modifier.expand.nil?
+
+      ::T.must(@modifier.expand).starts_at = starts_at
+
+      starts_at.upto(expand_amount + starts_at - 1) do |row_index|
+        into << deep_clone.tap { |c| c.index = row_index }
+      end
+      into
     end
 
+    sig { returns(::T::Boolean) }
+    # Does the row have an ![[expand]] modifier but is yet to be expanded?
+    #
+    # @return [T::Boolean]
+    def unexpanded?
+      return false if @modifier.expand.nil?
+
+      !::T.must(@modifier.expand).expanded?
+    end
+
+    private
+
+    sig { returns(::CSVPlusPlus::Row) }
     # Return a deep copy of this row
     #
     # @return [Row]
     def deep_clone
-      ::Marshal.load(::Marshal.dump(self))
+      ::T.cast(::Marshal.load(::Marshal.dump(self)), ::CSVPlusPlus::Row)
     end
   end
 end

data/lib/csv_plus_plus/runtime/graph.rb

@@ -0,0 +1,68 @@
+# typed: false
+# frozen_string_literal: true
+
+require 'tsort'
+
+module CSVPlusPlus
+  module Runtime
+    # Graph ordering and searching functions
+    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, include_runtime_variables: false)
+        depth_first_search(ast) do |node|
+          next unless node.is_a?(::CSVPlusPlus::Entities::Reference)
+
+          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)
+        ::CSVPlusPlus::Runtime::Graph::DependencyGraph[
+          variables.map { |var_id, ast| [var_id, variable_references(ast)] }
+        ]
+      end
+
+      # TODO: I don't think we use this anymore - it was useful when I wanted to resolve variables in their dependency
+      #   order
+      #
+      # Perform a topological sort on a +DependencyGraph+.  A toplogical sort is noteworthy
+      # because it will give us the order in which we need to resolve our variable dependencies.
+      #
+      # Given this dependency graph:
+      #
+      #  { a: [b c], b: [c], c: [d], d: [] }
+      #
+      # it will return:
+      #
+      #  [d, c, b, a]
+      #
+      def self.topological_sort(dependencies)
+        dependencies.tsort
+      end
+
+      # Do a DFS on an AST starting at +node+
+      def self.depth_first_search(node, accum = [], &)
+        ret = yield(node)
+        accum << ret unless ret.nil?
+
+        return accum unless node.is_a?(::CSVPlusPlus::Entities::FunctionCall)
+
+        node.arguments.each { |n| depth_first_search(n, accum, &) }
+        accum
+      end
+
+      # A dependency graph represented as a +Hash+ which will be used by our +topological_sort+ function
+      class DependencyGraph < Hash
+        include ::TSort
+        alias tsort_each_node each_key
+
+        # sort each child
+        def tsort_each_child(node, &)
+          fetch(node).each(&)
+        end
+      end
+    end
+  end
+end