csv_plus_plus 0.1.3 → 0.2.1

data/lib/csv_plus_plus/modifier/expand.rb

@@ -56,6 +56,23 @@ module CSVPlusPlus
         @starts_at = row_index
         @ends_at = row_index + @repetitions unless @repetitions.nil?
       end
+
+      sig { params(position: ::CSVPlusPlus::Runtime::Position).returns(::T::Boolean) }
+      # Does the given +position+ fall within this expand?
+      #
+      # @param position [Runtime::Position]
+      #
+      # @return [boolean]
+      def position_within?(position)
+        unless starts_at
+          raise(
+            ::CSVPlusPlus::Error::CompilerError,
+            'Must call Template.expand_rows! before checking the scope of expands.'
+          )
+        end
+
+        position.row_index >= ::T.must(starts_at) && (ends_at.nil? || position.row_index <= ::T.must(ends_at))
+      end
     end
   end
 end

data/lib/csv_plus_plus/modifier.rb

@@ -76,7 +76,12 @@ module CSVPlusPlus
       end
     end
 
-    sig { params(options: ::CSVPlusPlus::Options, row_level: ::T::Boolean).returns(::CSVPlusPlus::Modifier::Modifier) }
+    sig do
+      params(
+        options: ::CSVPlusPlus::Options::Options,
+        row_level: ::T::Boolean
+      ).returns(::CSVPlusPlus::Modifier::Modifier)
+    end
     # Return a +Modifier+ with the proper validation and helper functions attached for the given output
     #
     # @param options [boolean] is this a row level modifier? (otherwise cell-level)

data/lib/csv_plus_plus/options/file_options.rb

@@ -0,0 +1,49 @@
+# typed: strict
+# frozen_string_literal: true
+
+module CSVPlusPlus
+  module Options
+    # The options that are specific for compiling to a file
+    #
+    # @attr output_filename [Pathname] The file to write our compiled results to
+    class FileOptions < ::CSVPlusPlus::Options::Options
+      extend ::T::Sig
+      extend ::T::Helpers
+
+      sig { returns(::Pathname) }
+      attr_accessor :output_filename
+
+      sig { params(sheet_name: ::String, output_filename: ::String).void }
+      # Initialize an +Options+ object for writing to a file
+      def initialize(sheet_name, output_filename)
+        super(sheet_name)
+
+        @output_filename = ::T.let(::Pathname.new(output_filename), ::Pathname)
+      end
+
+      sig { override.returns(::CSVPlusPlus::Options::OutputFormat) }
+      # Given the options, figure out which type of +OutputFormat+ we'll be writing to
+      #
+      # @return [Options::OutputFormat]
+      def output_format
+        case output_filename.extname
+        when '.csv' then ::CSVPlusPlus::Options::OutputFormat::CSV
+        when '.ods' then ::CSVPlusPlus::Options::OutputFormat::OpenDocument
+        when /\.xl(sx|sm|tx|tm)$/ then ::CSVPlusPlus::Options::OutputFormat::Excel
+        else raise(::CSVPlusPlus::Error::CLIError, "Unsupported file extension: #{output_filename}")
+        end
+      end
+
+      sig { override.returns(::String) }
+      # Verbose summary for options specific to compiling to a file
+      #
+      # @return [String]
+      def verbose_summary
+        shared_summary(
+          <<~OUTPUT)
+            > Output filename                     | #{output_filename}
+          OUTPUT
+      end
+    end
+  end
+end

data/lib/csv_plus_plus/options/google_sheets_options.rb

@@ -0,0 +1,42 @@
+# typed: strict
+# frozen_string_literal: true
+
+module CSVPlusPlus
+  module Options
+    # The Google-specific options a user can supply.
+    #
+    # @attr sheet_id [String] The ID of the Google Sheet to write to.
+    class GoogleSheetsOptions < Options
+      extend ::T::Sig
+
+      sig { returns(::String) }
+      attr_reader :sheet_id
+
+      sig { params(sheet_name: ::String, sheet_id: ::String).void }
+      # @param sheet_name [String] The name of the sheet
+      # @param sheet_id [String] The unique ID Google uses to reference the sheet
+      def initialize(sheet_name, sheet_id)
+        super(sheet_name)
+
+        @sheet_id = sheet_id
+      end
+
+      sig { override.returns(::CSVPlusPlus::Options::OutputFormat) }
+      # @return [OutputFormat]
+      def output_format
+        ::CSVPlusPlus::Options::OutputFormat::GoogleSheets
+      end
+
+      sig { override.returns(::String) }
+      # Format a string with a verbose description of Google-specific options
+      #
+      # @return [String]
+      def verbose_summary
+        shared_summary(
+          <<~SUMMARY)
+            > Sheet ID | #{@sheet_id}
+          SUMMARY
+      end
+    end
+  end
+end

data/lib/csv_plus_plus/options/options.rb

@@ -0,0 +1,102 @@
+# typed: strict
+# frozen_string_literal: true
+
+module CSVPlusPlus
+  module Options
+    # The options a user can supply (via CLI flags)
+    #
+    # @attr backup [Boolean] Create a backup of the spreadsheet before writing
+    # @attr create_if_not_exists [Boolean] Create the spreadsheet if it does not exist?
+    # @attr key_values [Hash] Additional variables that can be supplied to the template
+    # @attr offset [Array<Integer>] An [x, y] offset (array with two integers)
+    # @attr overwrite_values [Boolean] Whether or not to overwrite existing values in the output spreadsheet.
+    # @attr sheet_name [String] The name of the spreadsheet to write to
+    # @attr verbose [Boolean] Include extra verbose output?
+    class Options
+      extend ::T::Sig
+      extend ::T::Helpers
+
+      abstract!
+
+      sig { returns(::T::Boolean) }
+      attr_accessor :backup
+
+      sig { returns(::T::Boolean) }
+      attr_accessor :create_if_not_exists
+
+      sig { returns(::T::Hash[::Symbol, ::CSVPlusPlus::Entities::Entity]) }
+      attr_accessor :key_values
+
+      sig { returns(::T::Array[::Integer]) }
+      attr_accessor :offset
+
+      sig { returns(::T::Boolean) }
+      attr_accessor :overwrite_values
+
+      sig { returns(::String) }
+      attr_accessor :sheet_name
+
+      sig { returns(::T::Boolean) }
+      attr_accessor :verbose
+
+      sig { params(sheet_name: ::String).void }
+      # Initialize a defaul +Options+ object
+      def initialize(sheet_name)
+        @backup = ::T.let(false, ::T::Boolean)
+        @create_if_not_exists = ::T.let(false, ::T::Boolean)
+        @key_values = ::T.let({}, ::T::Hash[::Symbol, ::CSVPlusPlus::Entities::Entity])
+        @offset = ::T.let([0, 0], ::T::Array[::Integer])
+        @overwrite_values = ::T.let(true, ::T::Boolean)
+        @sheet_name = sheet_name
+        @verbose = ::T.let(false, ::T::Boolean)
+      end
+
+      sig { abstract.returns(::CSVPlusPlus::Options::OutputFormat) }
+      # Given the options, figure out which type of +OutputFormat+ we'll be writing to
+      #
+      # @return [Options::OutputFormat]
+      def output_format; end
+
+      sig { abstract.returns(::String) }
+      # Return a string with a verbose description of what we're doing with the options
+      #
+      # @return [String]
+      def verbose_summary; end
+
+      protected
+
+      sig { params(str: ::String).returns(::String) }
+      # Return a string with a verbose description of what we're doing with the options
+      #
+      # @return [String]
+      def shared_summary(str)
+        <<~SUMMARY
+          #{summary_divider}
+
+          # csv++ Command Options
+
+          > 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}
+          > Backup                              | #{@backup}
+
+          ## Output Options
+
+          #{str}
+
+          #{summary_divider}
+        SUMMARY
+      end
+
+      private
+
+      sig { returns(::String) }
+      def summary_divider
+        '========================================================================='
+      end
+    end
+  end
+end

data/lib/csv_plus_plus/options.rb

@@ -2,17 +2,8 @@
 # frozen_string_literal: true
 
 module CSVPlusPlus
-  # The options a user can supply (via CLI flags)
-  #
-  # @attr backup [boolean] Create a backup of the spreadsheet before writing
-  # @attr create_if_not_exists [boolean] Create the spreadsheet if it does not exist?
-  # @attr key_values [Hash] Additional variables that can be supplied to the template
-  # @attr offset [Array<Integer>] An [x, y] offset (array with two integers)
-  # @attr output_filename [String] The file to write our compiled results to
-  # @attr sheet_name [String] The name of the spreadsheet to write to
-  # @attr verbose [boolean] Include extra verbose output?
-  # @attr_reader google [GoogleOptions] Options that are specific to the Google Sheets writer
-  class Options
+  # Options that a user can supply - either specific for compiling to a file (xlsx, csv) or Google Sheets
+  module Options
     extend ::T::Sig
 
     # The supported output formats.  We use this to dispatch flow in several places
@@ -25,109 +16,30 @@ module CSVPlusPlus
       end
     end
 
-    sig { returns(::T::Boolean) }
-    attr_accessor :backup
-
-    sig { returns(::T::Boolean) }
-    attr_accessor :create_if_not_exists
-
-    sig { returns(::T::Hash[::Symbol, ::String]) }
-    attr_accessor :key_values
-
-    sig { returns(::T::Array[::Integer]) }
-    attr_accessor :offset
-
-    sig { returns(::T.nilable(::String)) }
-    attr_accessor :output_filename
-
-    sig { returns(::T.nilable(::String)) }
-    attr_accessor :sheet_name
-
-    sig { returns(::T::Boolean) }
-    attr_accessor :verbose
-
-    sig { returns(::T.nilable(::CSVPlusPlus::GoogleOptions)) }
-    attr_reader :google
-
-    sig { void }
-    # Initialize a default +Options+ object
-    def initialize
-      @offset = ::T.let([0, 0], ::T::Array[::Integer])
-      @create_if_not_exists = ::T.let(false, ::T::Boolean)
-      @key_values = ::T.let({}, ::T::Hash[::Symbol, ::String])
-      @verbose = ::T.let(false, ::T::Boolean)
-      @backup = ::T.let(false, ::T::Boolean)
-      @google = ::T.let(nil, ::T.nilable(::CSVPlusPlus::GoogleOptions))
+    sig do
+      params(flags: ::T::Hash[::Symbol, ::String], input_filename: ::Pathname).returns(::CSVPlusPlus::Options::Options)
     end
-
-    sig { params(sheet_id: ::String).returns(::CSVPlusPlus::GoogleOptions) }
-    # Set the Google Sheet ID
-    #
-    # @param sheet_id [::String] The identifier used by Google's API to reference the sheet.  You can find it in the URL
-    #   for the sheet
+    # Use the given +flags+ to determine if we're dealing with either a Google Sheets or file-based
+    # compilation and build an +Options+ instance accordingly.
     #
-    # @return [::String]
-    def google_sheet_id=(sheet_id)
-      @google = ::CSVPlusPlus::GoogleOptions.new(sheet_id)
-    end
-
-    sig { returns(::CSVPlusPlus::Options::OutputFormat) }
-    # Given the options, figure out which type of +OutputFormat+ we'll be writing to
+    # @param flags [Hash<Symbol, String>]
+    # @param input_filename [Pathname]
     #
-    # @return [Options::OutputFormat]
-    def output_format
-      return ::CSVPlusPlus::Options::OutputFormat::GoogleSheets if @google
-
-      case @output_filename
-      when /\.csv$/ then ::CSVPlusPlus::Options::OutputFormat::CSV
-      when /\.ods$/ then ::CSVPlusPlus::Options::OutputFormat::OpenDocument
-      when /\.xl(sx|sm|tx|tm)$/ then ::CSVPlusPlus::Options::OutputFormat::Excel
-      else raise(::CSVPlusPlus::Error::Error, "Unsupported file extension: #{@output_filename}")
+    # @return [Options::Options]
+    def self.from_cli_flags(flags, input_filename)
+      sheet_name = flags[:'sheet-name'] || input_filename.sub_ext('').to_s
+      if (google_sheet_id = flags[:'google-sheet-id'])
+        ::CSVPlusPlus::Options::GoogleSheetsOptions.new(sheet_name, google_sheet_id)
+      elsif (output_filename = flags[:output])
+        ::CSVPlusPlus::Options::FileOptions.new(sheet_name, output_filename)
+      else
+        raise(::CSVPlusPlus::Error::CLIError, 'You must supply either -o/--output or -g/-google-sheet-id')
       end
     end
-
-    sig { returns(::T.nilable(::String)) }
-    # Returns an error string or nil if there are no validation problems
-    #
-    # @return [String, nil]
-    def validate
-      return if @google || @output_filename
-
-      'You must supply either a Google Sheet ID or an output file'
-    end
-
-    sig { returns(::String) }
-    # Return a string with a verbose description of what we're doing with the options
-    #
-    # @return [String]
-    def verbose_summary
-      <<~SUMMARY
-        #{summary_divider}
-
-        # csv++ Command Options
-
-        > 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
-
-    private
-
-    sig { returns(::String) }
-    def summary_divider
-      '========================================================================='
-    end
   end
 end
+
+require_relative './options/options'
+
+require_relative './options/file_options'
+require_relative './options/google_sheets_options'

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

@@ -7,6 +7,7 @@
 require 'racc/parser.rb'
 
   require_relative '../lexer'
+  require_relative '../lexer/racc_lexer'
   require_relative '../entities/ast_builder'
 
 module CSVPlusPlus
@@ -14,35 +15,43 @@ module CSVPlusPlus
     class CellValue < Racc::Parser
 
 module_eval(<<'...end cell_value.y/module_eval...', 'cell_value.y', 49)
+  extend ::T::Sig
+  extend ::T::Generic
   include ::CSVPlusPlus::Entities::ASTBuilder
-  include ::CSVPlusPlus::Lexer
+  include ::CSVPlusPlus::Lexer::RaccLexer
+
+  ReturnType = type_member {{ fixed: ::T.nilable(::CSVPlusPlus::Entities::Entity) }}
 
   protected
 
+  sig { override.params(input: ::String).returns(::T::Boolean) }
   def anything_to_parse?(input)
     input.strip.start_with?('=')
   end
 
+  sig { override.returns(::String) }
   def parse_subject
     'cell value'
   end
 
+  sig { override.returns(ReturnType) }
   def return_value
     @ast
   end
 
+  sig { override.returns(::CSVPlusPlus::Lexer::Tokenizer) }
   def tokenizer
     ::CSVPlusPlus::Lexer::Tokenizer.new(
       catchall: /[\{\}\(\),=]/,
       ignore: /\s+/,
       tokens: [
-        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_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[:VAR_REF],
+        ::CSVPlusPlus::Lexer::TOKEN_LIBRARY[:REF]
       ]
     )
   end
@@ -50,45 +59,43 @@ module_eval(<<'...end cell_value.y/module_eval...', 'cell_value.y', 49)
 ##### State transition tables begin ###
 
 racc_action_table = [
-     7,    21,    15,    25,     2,    16,     3,     7,    14,    18,
-    19,    16,    16,    16,     7,    12,    13,    16,    10,     9,
-    11,     8,    12,    13,    26,    10,     9,    11,     8,    12,
-    13,   nil,    10,     9,    11,     8,     7,    23,   nil,   nil,
-   nil,   nil,   nil,     7,   nil,   nil,   nil,   nil,   nil,   nil,
-   nil,    12,    13,   nil,    10,     9,    11,     8,    12,    13,
-   nil,    10,     9,    11,     8 ]
+    23,    19,    14,     2,    15,     7,     3,    13,    17,    15,
+    15,     7,    15,   nil,   nil,   nil,    15,     7,   nil,   nil,
+    11,    24,     9,    12,     8,    10,    11,     7,     9,    12,
+     8,    10,    11,   nil,     9,    12,     8,    10,     7,    21,
+   nil,   nil,    11,   nil,     9,    12,     8,    10,   nil,   nil,
+   nil,   nil,   nil,    11,   nil,     9,    12,     8,    10 ]
 
 racc_action_check = [
-     2,    17,     4,    22,     0,     4,     1,     7,     3,     8,
-    13,    20,    24,    27,    16,     2,     2,    17,     2,     2,
-     2,     2,     7,     7,    22,     7,     7,     7,     7,    16,
-    16,   nil,    16,    16,    16,    16,    19,    19,   nil,   nil,
-   nil,   nil,   nil,    26,   nil,   nil,   nil,   nil,   nil,   nil,
-   nil,    19,    19,   nil,    19,    19,    19,    19,    26,    26,
-   nil,    26,    26,    26,    26 ]
+    20,    16,     4,     0,     4,     2,     1,     3,    12,    18,
+    22,     7,    25,   nil,   nil,   nil,    16,    15,   nil,   nil,
+     2,    20,     2,     2,     2,     2,     7,    24,     7,     7,
+     7,     7,    15,   nil,    15,    15,    15,    15,    17,    17,
+   nil,   nil,    24,   nil,    24,    24,    24,    24,   nil,   nil,
+   nil,   nil,   nil,    17,   nil,    17,    17,    17,    17 ]
 
 racc_action_pointer = [
-    -6,     6,    -2,     8,   -14,   nil,   nil,     5,    -9,   nil,
-   nil,   nil,   nil,     8,   nil,   nil,    12,    -2,   nil,    34,
-    -8,   nil,     0,   nil,    -7,   nil,    41,    -6 ]
+    -7,     6,     3,     7,   -14,   nil,   nil,     9,   nil,   nil,
+   nil,   nil,     6,   nil,   nil,    15,    -2,    36,    -9,   nil,
+    -3,   nil,    -8,   nil,    25,    -6 ]
 
 racc_action_default = [
-   -16,   -16,   -16,   -16,   -16,    -2,    -3,   -16,   -16,    -6,
-    -7,    -8,    -9,   -10,    28,    -1,   -16,   -16,    -5,   -16,
-   -15,    -4,   -16,   -12,   -14,   -11,   -16,   -13 ]
+   -15,   -15,   -15,   -15,   -15,    -2,    -3,   -15,    -5,    -6,
+    -7,    -8,    -9,    26,    -1,   -15,   -15,   -15,   -14,    -4,
+   -15,   -11,   -13,   -10,   -15,   -12 ]
 
 racc_goto_table = [
-     4,     1,    22,   nil,   nil,    17,   nil,   nil,   nil,   nil,
-   nil,   nil,   nil,   nil,    20,   nil,   nil,    24,   nil,   nil,
-   nil,   nil,   nil,   nil,    27 ]
+     4,     1,    20,   nil,   nil,    16,   nil,   nil,   nil,   nil,
+   nil,   nil,   nil,    18,   nil,    22,   nil,   nil,   nil,   nil,
+   nil,   nil,    25 ]
 
 racc_goto_check = [
      2,     1,     5,   nil,   nil,     2,   nil,   nil,   nil,   nil,
-   nil,   nil,   nil,   nil,     2,   nil,   nil,     2,   nil,   nil,
-   nil,   nil,   nil,   nil,     2 ]
+   nil,   nil,   nil,     2,   nil,     2,   nil,   nil,   nil,   nil,
+   nil,   nil,     2 ]
 
 racc_goto_pointer = [
-   nil,     1,    -2,   nil,   nil,   -17 ]
+   nil,     1,    -2,   nil,   nil,   -15 ]
 
 racc_goto_default = [
    nil,   nil,   nil,     5,     6,   nil ]
@@ -99,21 +106,20 @@ racc_reduce_table = [
   1, 27, :_reduce_none,
   1, 27, :_reduce_none,
   3, 27, :_reduce_4,
-  2, 27, :_reduce_5,
+  1, 27, :_reduce_5,
   1, 27, :_reduce_6,
   1, 27, :_reduce_7,
   1, 27, :_reduce_8,
   1, 27, :_reduce_9,
-  1, 27, :_reduce_10,
-  4, 28, :_reduce_11,
-  3, 28, :_reduce_12,
-  3, 30, :_reduce_13,
-  1, 30, :_reduce_14,
-  3, 29, :_reduce_15 ]
+  4, 28, :_reduce_10,
+  3, 28, :_reduce_11,
+  3, 30, :_reduce_12,
+  1, 30, :_reduce_13,
+  3, 29, :_reduce_14 ]
 
-racc_reduce_n = 16
+racc_reduce_n = 15
 
-racc_shift_n = 28
+racc_shift_n = 26
 
 racc_token_table = {
   false => 0,
@@ -134,9 +140,9 @@ racc_token_table = {
   "<>" => 15,
   :EOL => 16,
   :FALSE => 17,
-  :ID => 18,
-  :INFIX_OP => 19,
-  :NUMBER => 20,
+  :INFIX_OP => 18,
+  :NUMBER => 19,
+  :REF => 20,
   :STRING => 21,
   :TRUE => 22,
   :VAR_REF => 23,
@@ -181,9 +187,9 @@ Racc_token_to_s_table = [
   "\"<>\"",
   "EOL",
   "FALSE",
-  "ID",
   "INFIX_OP",
   "NUMBER",
+  "REF",
   "STRING",
   "TRUE",
   "VAR_REF",
@@ -221,76 +227,69 @@ module_eval(<<'.,.,', 'cell_value.y', 25)
 
 module_eval(<<'.,.,', 'cell_value.y', 26)
   def _reduce_5(val, _values, result)
-     result = variable(val[1].to_sym)
+     result = string(val[0])
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'cell_value.y', 27)
   def _reduce_6(val, _values, result)
-     result = string(val[0])
+     result = number(val[0])
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'cell_value.y', 28)
   def _reduce_7(val, _values, result)
-     result = number(val[0])
+     result = boolean(true)
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'cell_value.y', 29)
   def _reduce_8(val, _values, result)
-     result = boolean(true)
+     result = boolean(false)
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'cell_value.y', 30)
   def _reduce_9(val, _values, result)
-     result = boolean(false)
+     result = reference(ref: val[0])
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'cell_value.y', 31)
+module_eval(<<'.,.,', 'cell_value.y', 32)
   def _reduce_10(val, _values, result)
-     result = cell_reference(ref: val[0])
+     result = function_call(val[0].to_sym, val[2])
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'cell_value.y', 33)
   def _reduce_11(val, _values, result)
-     result = function_call(val[0].to_sym, val[2])
+     result = function_call(val[0].to_sym, [])
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'cell_value.y', 34)
+module_eval(<<'.,.,', 'cell_value.y', 35)
   def _reduce_12(val, _values, result)
-     result = function_call(val[0].to_sym, [])
+     result = val[0] << val[2]
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'cell_value.y', 36)
   def _reduce_13(val, _values, result)
-     result = val[0] << val[2]
-    result
-  end
-.,.,
-
-module_eval(<<'.,.,', 'cell_value.y', 37)
-  def _reduce_14(val, _values, result)
      result = [val[0]]
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'cell_value.y', 39)
-  def _reduce_15(val, _values, result)
+module_eval(<<'.,.,', 'cell_value.y', 38)
+  def _reduce_14(val, _values, result)
      result = function_call(val[1].to_sym, [val[0], val[2]], infix: true)
     result
   end