csv_plus_plus 0.1.3 → 0.2.0

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

@@ -6,33 +6,46 @@
 
 require 'racc/parser.rb'
 
-  require_relative '../lexer'
+  require_relative '../lexer/racc_lexer'
   require_relative '../entities/ast_builder'
 
 module CSVPlusPlus
   module Parser
     class CodeSection < Racc::Parser
 
-module_eval(<<'...end code_section.y/module_eval...', 'code_section.y', 69)
-  include ::CSVPlusPlus::Lexer
+module_eval(<<'...end code_section.y/module_eval...', 'code_section.y', 68)
+  extend ::T::Sig
+  extend ::T::Generic
+  include ::CSVPlusPlus::Lexer::RaccLexer
   include ::CSVPlusPlus::Entities::ASTBuilder
 
+  ReturnType = type_member {{ fixed: ::T.nilable(::String) }}
+
+  sig { params(scope: ::CSVPlusPlus::Runtime::Scope).void }
+  def initialize(scope)
+    super()
+    @scope = scope
+  end
+
   protected
 
+  sig { override.params(input: ::String).returns(::T::Boolean) }
   def anything_to_parse?(input)
     @rest = input.strip
 
     return !@rest.index(::CSVPlusPlus::Lexer::END_OF_CODE_SECTION).nil?
   end
 
+  sig { override.returns(::String) }
   def parse_subject
     'code section'
   end
 
+  sig { override.returns(::CSVPlusPlus::Lexer::Tokenizer) }
   def tokenizer
     ::CSVPlusPlus::Lexer::Tokenizer.new(
       catchall: /[\{\}\(\),]/, # TODO: do I even need this (oh I think brackets are for arrays
-      ignore: /\s+|\#[^\n]+\n/,
+      ignore: /\s+|\#.*/,
       stop_fn: lambda do |scanner|
         return false unless scanner.scan(/#{::CSVPlusPlus::Lexer::END_OF_CODE_SECTION}/)
 
@@ -41,85 +54,88 @@ module_eval(<<'...end code_section.y/module_eval...', 'code_section.y', 69)
         true
       end,
       tokens: [
-        [/:=/, :ASSIGN],
-        [/def/, :FN_DEF],
-        TOKEN_LIBRARY[:TRUE],
-        TOKEN_LIBRARY[:FALSE],
-        TOKEN_LIBRARY[:NUMBER],
-        TOKEN_LIBRARY[:STRING],
-        TOKEN_LIBRARY[:INFIX_OP],
-        TOKEN_LIBRARY[:VAR_REF],
-        TOKEN_LIBRARY[:ID]
+        ::CSVPlusPlus::Lexer::Token.new(regexp: /:=/, token: :ASSIGN),
+        ::CSVPlusPlus::Lexer::Token.new(regexp: /\bdef\b/, token: :FN_DEF),
+        ::CSVPlusPlus::Lexer::TOKEN_LIBRARY[:TRUE],
+        ::CSVPlusPlus::Lexer::TOKEN_LIBRARY[:FALSE],
+        ::CSVPlusPlus::Lexer::TOKEN_LIBRARY[:NUMBER],
+        ::CSVPlusPlus::Lexer::TOKEN_LIBRARY[:STRING],
+        ::CSVPlusPlus::Lexer::TOKEN_LIBRARY[:INFIX_OP],
+        ::CSVPlusPlus::Lexer::TOKEN_LIBRARY[:REF]
       ],
     )
   end
 
+  sig { override.returns(ReturnType) }
   def return_value
     @rest
   end
 
   private
 
+  sig do
+    params(id: ::Symbol, arguments: ::T::Array[::Symbol], body: ::CSVPlusPlus::Entities::Entity)
+      .returns(::CSVPlusPlus::Entities::Entity)
+  end
   def def_function(id, arguments, body)
-    fn_def = function(id.to_sym, arguments, body)
-    @runtime.def_function(fn_def.id, fn_def)
+    @scope.def_function(id, function(id, arguments, body))
   end
 
+  sig do
+    params(id: ::Symbol, ast: ::CSVPlusPlus::Entities::Entity)
+      .returns(::CSVPlusPlus::Entities::Entity)
+  end
   def def_variable(id, ast)
-    @runtime.def_variable(id.to_sym, ast)
+    @scope.def_variable(id, ast)
   end
 ...end code_section.y/module_eval...
 ##### State transition tables begin ###
 
 racc_action_table = [
-    20,    38,     9,    12,    13,    14,    16,    20,    31,    33,
-    34,    31,    42,    31,    20,    31,    29,    25,    26,    31,
-    23,    22,    24,    21,    25,    26,    20,    23,    22,    24,
-    21,    25,    26,    30,    23,    22,    24,    21,    20,    41,
-    31,   nil,    35,    25,    26,    20,    23,    22,    24,    21,
-     3,    10,   nil,     7,     7,    25,    26,    36,    23,    22,
-    24,    21,    25,    26,    43,    23,    22,    24,    21,     8,
-     8,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,    44 ]
+    20,    33,     9,    12,    13,    28,    20,    14,    16,    30,
+    32,    30,    20,    40,    30,    30,    34,    24,    20,    22,
+    25,    21,    23,    24,    29,    22,    25,    21,    23,    24,
+    20,    22,    25,    21,    23,    24,    36,    22,    25,    21,
+    23,    20,    39,     3,    41,    10,     7,    24,     7,    22,
+    25,    21,    23,    30,    30,   nil,   nil,   nil,    24,    42,
+    22,    25,    21,    23,     8,   nil,     8 ]
 
 racc_action_check = [
-    13,    32,     1,     7,     8,     9,    12,    15,    17,    21,
-    26,    27,    36,    37,    20,    39,    16,    13,    13,    32,
-    13,    13,    13,    13,    15,    15,    31,    15,    15,    15,
-    15,    20,    20,    16,    20,    20,    20,    20,    34,    34,
-    45,   nil,    28,    31,    31,    44,    31,    31,    31,    31,
-     0,     2,   nil,     0,     2,    34,    34,    28,    34,    34,
-    34,    34,    44,    44,    40,    44,    44,    44,    44,     0,
-     2,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,    40 ]
+    13,    27,     1,     7,     8,    16,    15,     9,    12,    17,
+    25,    26,    20,    34,    35,    37,    27,    13,    30,    13,
+    13,    13,    13,    15,    16,    15,    15,    15,    15,    20,
+    42,    20,    20,    20,    20,    30,    31,    30,    30,    30,
+    30,    32,    32,     0,    38,     2,     0,    42,     2,    42,
+    42,    42,    42,    31,    43,   nil,   nil,   nil,    32,    38,
+    32,    32,    32,    32,     0,   nil,     2 ]
 
 racc_action_pointer = [
-    48,     2,    49,   nil,   nil,   nil,   nil,   -18,    -2,     5,
-   nil,   nil,     3,    -3,   nil,     4,    12,   -14,   nil,   nil,
-    11,   -12,   nil,   nil,   nil,   nil,     7,   -11,    38,   nil,
-   nil,    23,    -3,   nil,    35,   nil,    -9,    -9,   nil,    -7,
-    60,   nil,   nil,   nil,    42,    18 ]
+    41,     2,    43,   nil,   nil,   nil,   nil,   -20,    -2,     7,
+   nil,   nil,     5,    -3,   nil,     3,     1,   -12,   nil,   nil,
+     9,   nil,   nil,   nil,   nil,     7,   -10,    -3,   nil,   nil,
+    15,    32,    38,   nil,   -10,    -7,   nil,    -6,    40,   nil,
+   nil,   nil,    27,    33 ]
 
 racc_action_default = [
-   -27,   -27,   -27,    -2,    -4,    -5,    -6,   -27,   -27,   -27,
-    -1,    -3,   -27,   -27,    46,   -27,   -27,   -12,   -13,   -14,
-   -27,   -27,   -17,   -18,   -19,   -20,   -21,    -7,   -27,    -9,
-   -11,   -27,   -27,   -16,   -27,    -8,   -27,   -22,   -15,   -26,
-   -27,   -24,   -10,   -23,   -27,   -25 ]
+   -26,   -26,   -26,    -2,    -4,    -5,    -6,   -26,   -26,   -26,
+    -1,    -3,   -26,   -26,    44,   -26,   -26,   -12,   -13,   -14,
+   -26,   -16,   -17,   -18,   -19,   -20,    -7,   -26,    -9,   -11,
+   -26,   -26,   -26,    -8,   -26,   -21,   -15,   -25,   -26,   -23,
+   -10,   -22,   -26,   -24 ]
 
 racc_goto_table = [
-    17,     4,    27,    11,     1,     2,    15,    32,    28,    40,
-   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,    37,   nil,
-   nil,    39,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,
-   nil,    45 ]
+    17,     4,    26,    11,     1,     2,    15,    31,    27,    38,
+   nil,   nil,   nil,   nil,   nil,   nil,   nil,    35,   nil,    37,
+   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,    43 ]
 
 racc_goto_check = [
      7,     3,     7,     3,     1,     2,     6,     7,     8,    11,
-   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,     7,   nil,
-   nil,     7,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,
-   nil,     7 ]
+   nil,   nil,   nil,   nil,   nil,   nil,   nil,     7,   nil,     7,
+   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,     7 ]
 
 racc_goto_pointer = [
    nil,     4,     5,     1,   nil,   nil,    -6,   -13,    -8,   nil,
-   nil,   -25 ]
+   nil,   -23 ]
 
 racc_goto_default = [
    nil,   nil,   nil,   nil,     5,     6,   nil,   nil,   nil,    18,
@@ -142,21 +158,20 @@ racc_reduce_table = [
   1, 34, :_reduce_none,
   1, 34, :_reduce_none,
   3, 34, :_reduce_15,
-  2, 34, :_reduce_16,
+  1, 34, :_reduce_16,
   1, 34, :_reduce_17,
   1, 34, :_reduce_18,
   1, 34, :_reduce_19,
   1, 34, :_reduce_20,
-  1, 34, :_reduce_21,
-  3, 37, :_reduce_22,
-  4, 36, :_reduce_23,
-  3, 36, :_reduce_24,
-  3, 38, :_reduce_25,
-  1, 38, :_reduce_26 ]
+  3, 37, :_reduce_21,
+  4, 36, :_reduce_22,
+  3, 36, :_reduce_23,
+  3, 38, :_reduce_24,
+  1, 38, :_reduce_25 ]
 
-racc_reduce_n = 27
+racc_reduce_n = 26
 
-racc_shift_n = 46
+racc_shift_n = 44
 
 racc_token_table = {
   false => 0,
@@ -180,9 +195,9 @@ racc_token_table = {
   "<>" => 18,
   "," => 19,
   :FALSE => 20,
-  :ID => 21,
-  :INFIX_OP => 22,
-  :NUMBER => 23,
+  :INFIX_OP => 21,
+  :NUMBER => 22,
+  :REF => 23,
   :STRING => 24,
   :TRUE => 25,
   :VAR_REF => 26 }
@@ -229,9 +244,9 @@ Racc_token_to_s_table = [
   "\"<>\"",
   "\",\"",
   "FALSE",
-  "ID",
   "INFIX_OP",
   "NUMBER",
+  "REF",
   "STRING",
   "TRUE",
   "VAR_REF",
@@ -268,7 +283,7 @@ Racc_debug_parser = false
 
 module_eval(<<'.,.,', 'code_section.y', 33)
   def _reduce_7(val, _values, result)
-     def_function(val[1], val[2], val[3])
+     def_function(val[1].to_sym, val[2], val[3])
     result
   end
 .,.,
@@ -303,7 +318,7 @@ module_eval(<<'.,.,', 'code_section.y', 39)
 
 module_eval(<<'.,.,', 'code_section.y', 41)
   def _reduce_12(val, _values, result)
-     def_variable(val[0], val[2])
+     def_variable(val[0].to_sym, val[2])
     result
   end
 .,.,
@@ -321,76 +336,69 @@ module_eval(<<'.,.,', 'code_section.y', 45)
 
 module_eval(<<'.,.,', 'code_section.y', 46)
   def _reduce_16(val, _values, result)
-     result = variable(val[1].to_sym)
+     result = string(val[0])
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'code_section.y', 47)
   def _reduce_17(val, _values, result)
-     result = string(val[0])
+     result = number(val[0])
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'code_section.y', 48)
   def _reduce_18(val, _values, result)
-     result = number(val[0])
+     result = boolean(true)
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'code_section.y', 49)
   def _reduce_19(val, _values, result)
-     result = boolean(true)
+     result = boolean(false)
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'code_section.y', 50)
   def _reduce_20(val, _values, result)
-     result = boolean(false)
+     result = reference(ref: val[0])
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'code_section.y', 51)
+module_eval(<<'.,.,', 'code_section.y', 52)
   def _reduce_21(val, _values, result)
-     result = cell_reference(ref: val[0])
+     result = function_call(val[1].to_sym, [val[0], val[2]], infix: true)
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'code_section.y', 53)
+module_eval(<<'.,.,', 'code_section.y', 54)
   def _reduce_22(val, _values, result)
-     result = function_call(val[1].to_sym, [val[0], val[2]], infix: true)
+     result = function_call(val[0].to_sym, val[2])
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'code_section.y', 55)
   def _reduce_23(val, _values, result)
-     result = function_call(val[0].to_sym, val[2])
+     result = function_call(val[0].to_sym, [])
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'code_section.y', 56)
+module_eval(<<'.,.,', 'code_section.y', 57)
   def _reduce_24(val, _values, result)
-     result = function_call(val[0].to_sym, [])
+     result = val[0] << val[2]
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'code_section.y', 58)
   def _reduce_25(val, _values, result)
-     result = val[0] << val[2]
-    result
-  end
-.,.,
-
-module_eval(<<'.,.,', 'code_section.y', 59)
-  def _reduce_26(val, _values, result)
      result = [val[0]]
     result
   end

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

@@ -7,16 +7,18 @@
 require 'racc/parser.rb'
 
 
-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', 60)
-  attr_reader :return_value
+  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]
@@ -30,6 +32,7 @@ module_eval(<<'...end modifier.y/module_eval...', 'modifier.y', 60)
 
   protected
 
+  sig { override.params(input: ::String).returns(::T::Boolean) }
   def anything_to_parse?(input)
     @modifiers_to_parse = input.scan(/!?\[\[/).count
 
@@ -41,10 +44,18 @@ module_eval(<<'...end modifier.y/module_eval...', 'modifier.y', 60)
     @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+/,
@@ -58,26 +69,25 @@ module_eval(<<'...end modifier.y/module_eval...', 'modifier.y', 60)
         @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+\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)
@@ -90,12 +100,12 @@ module_eval(<<'...end modifier.y/module_eval...', 'modifier.y', 60)
               [\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(/^'|'$/, '') }
@@ -154,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 ]

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