csv_plus_plus 0.1.2 → 0.1.3

data/lib/csv_plus_plus/options.rb

@@ -1,8 +1,6 @@
+# typed: strict
 # frozen_string_literal: true
 
-require_relative './cli_flag'
-require_relative './google_options'
-
 module CSVPlusPlus
   # The options a user can supply (via CLI flags)
   #
@@ -15,28 +13,80 @@ module CSVPlusPlus
   # @attr verbose [boolean] Include extra verbose output?
   # @attr_reader google [GoogleOptions] Options that are specific to the Google Sheets writer
   class Options
-    attr_accessor :backup, :create_if_not_exists, :key_values, :offset, :output_filename, :sheet_name, :verbose
+    extend ::T::Sig
+
+    # The supported output formats.  We use this to dispatch flow in several places
+    class OutputFormat < ::T::Enum
+      enums do
+        CSV = new
+        Excel = new
+        GoogleSheets = new
+        OpenDocument = new
+      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
 
-    # initialize
+    sig { void }
+    # Initialize a default +Options+ object
     def initialize
-      @offset = [0, 0]
-      @create_if_not_exists = false
-      @key_values = {}
-      @verbose = false
-      @backup = false
+      @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))
     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
+    # @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
     #
-    # @return [String]
+    # @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
+    #
+    # @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}")
+      end
+    end
+
+    sig { returns(::T.nilable(::String)) }
     # Returns an error string or nil if there are no validation problems
     #
     # @return [String, nil]
@@ -46,6 +96,7 @@ module CSVPlusPlus
       '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]
@@ -55,7 +106,6 @@ module CSVPlusPlus
 
         # 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]}
@@ -73,14 +123,9 @@ module CSVPlusPlus
       SUMMARY
     end
 
-    # @return [String]
-    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
 
+    sig { returns(::String) }
     def summary_divider
       '========================================================================='
     end

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

@@ -221,7 +221,7 @@ module_eval(<<'.,.,', 'cell_value.y', 25)
 
 module_eval(<<'.,.,', 'cell_value.y', 26)
   def _reduce_5(val, _values, result)
-     result = variable(val[1])
+     result = variable(val[1].to_sym)
     result
   end
 .,.,
@@ -256,21 +256,21 @@ module_eval(<<'.,.,', 'cell_value.y', 30)
 
 module_eval(<<'.,.,', 'cell_value.y', 31)
   def _reduce_10(val, _values, result)
-     result = cell_reference(val[0])
+     result = cell_reference(ref: val[0])
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'cell_value.y', 33)
   def _reduce_11(val, _values, result)
-     result = function_call(val[0], val[2])
+     result = function_call(val[0].to_sym, val[2])
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'cell_value.y', 34)
   def _reduce_12(val, _values, result)
-     result = function_call(val[0], [])
+     result = function_call(val[0].to_sym, [])
     result
   end
 .,.,
@@ -291,7 +291,7 @@ module_eval(<<'.,.,', 'cell_value.y', 37)
 
 module_eval(<<'.,.,', 'cell_value.y', 39)
   def _reduce_15(val, _values, result)
-     result = function_call(val[1], [val[0], val[2]], infix: true)
+     result = function_call(val[1].to_sym, [val[0], val[2]], infix: true)
     result
   end
 .,.,

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

@@ -17,11 +17,6 @@ module_eval(<<'...end code_section.y/module_eval...', 'code_section.y', 69)
   include ::CSVPlusPlus::Lexer
   include ::CSVPlusPlus::Entities::ASTBuilder
 
-  def initialize(scope)
-    super()
-    @scope = scope
-  end
-
   protected
 
   def anything_to_parse?(input)
@@ -66,12 +61,12 @@ module_eval(<<'...end code_section.y/module_eval...', 'code_section.y', 69)
   private
 
   def def_function(id, arguments, body)
-    fn_def = function(id, arguments, body)
-    @scope.def_function(fn_def.id, fn_def)
+    fn_def = function(id.to_sym, arguments, body)
+    @runtime.def_function(fn_def.id, fn_def)
   end
 
   def def_variable(id, ast)
-    @scope.def_variable(id, ast)
+    @runtime.def_variable(id.to_sym, ast)
   end
 ...end code_section.y/module_eval...
 ##### State transition tables begin ###
@@ -326,7 +321,7 @@ module_eval(<<'.,.,', 'code_section.y', 45)
 
 module_eval(<<'.,.,', 'code_section.y', 46)
   def _reduce_16(val, _values, result)
-     result = variable(val[1])
+     result = variable(val[1].to_sym)
     result
   end
 .,.,
@@ -361,28 +356,28 @@ module_eval(<<'.,.,', 'code_section.y', 50)
 
 module_eval(<<'.,.,', 'code_section.y', 51)
   def _reduce_21(val, _values, result)
-     result = cell_reference(val[0])
+     result = cell_reference(ref: val[0])
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'code_section.y', 53)
   def _reduce_22(val, _values, result)
-     result = function_call(val[1], [val[0], val[2]], infix: true)
+     result = function_call(val[1].to_sym, [val[0], val[2]], infix: true)
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'code_section.y', 55)
   def _reduce_23(val, _values, result)
-     result = function_call(val[0], val[2])
+     result = function_call(val[0].to_sym, val[2])
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'code_section.y', 56)
   def _reduce_24(val, _values, result)
-     result = function_call(val[0], [])
+     result = function_call(val[0].to_sym, [])
     result
   end
 .,.,

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

@@ -7,28 +7,25 @@
 require 'racc/parser.rb'
 
 
-require_relative '../expand'
 require_relative '../lexer'
 
 module CSVPlusPlus
   module Parser
     class Modifier < Racc::Parser
 
-module_eval(<<'...end modifier.y/module_eval...', 'modifier.y', 61)
+module_eval(<<'...end modifier.y/module_eval...', 'modifier.y', 60)
   attr_reader :return_value
 
   include ::CSVPlusPlus::Lexer
 
   # @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
@@ -82,14 +79,16 @@ module_eval(<<'...end modifier.y/module_eval...', 'modifier.y', 61)
         [
           /
             (?:
-              [\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,
         ],
@@ -107,7 +106,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 +122,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
@@ -393,7 +387,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 +450,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 +464,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/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/can_define_references.rb

@@ -0,0 +1,87 @@
+# typed: true
+# frozen_string_literal: true
+
+module CSVPlusPlus
+  module Runtime
+    # Methods for classes that need to manage +@variables+ and +@functions+
+    module CanDefineReferences
+      # Define a (or re-define an existing) variable
+      #
+      # @param id [String, Symbol] The identifier for the variable
+      # @param entity [Entity] The value (entity) the variable holds
+      #
+      # @return [Entity] The value of the variable (+entity+)
+      def def_variable(id, entity)
+        @variables[id.to_sym] = entity
+      end
+
+      # Define (or re-define existing) variables
+      #
+      # @param vars [Hash<Symbol, Variable>] Variables to define
+      def def_variables(vars)
+        vars.each { |id, entity| def_variable(id, entity) }
+      end
+
+      # Define a (or re-define an existing) function
+      #
+      # @param id [String, Symbol] The identifier for the function
+      # @param entity [Entities::Function] The defined function
+      #
+      # @return [Entities::Function] The defined function
+      def def_function(id, entity)
+        @functions[id.to_sym] = entity
+      end
+
+      # Is the variable defined?
+      #
+      # @param var_id [Symbol, String] The identifier of the variable
+      #
+      # @return [boolean]
+      def defined_variable?(var_id)
+        @variables.key?(var_id.to_sym)
+      end
+
+      # Is the function defined?
+      #
+      # @param fn_id [Symbol, String] The identifier of the function
+      #
+      # @return [boolean]
+      def defined_function?(fn_id)
+        @functions.key?(fn_id.to_sym)
+      end
+
+      # Provide a summary of the functions and variables compiled (to show in verbose mode)
+      #
+      # @return [String]
+      def verbose_summary
+        <<~SUMMARY
+          # Code Section Summary
+
+          ## Resolved Variables
+
+          #{variable_summary}
+
+          ## Functions
+
+          #{function_summary}
+        SUMMARY
+      end
+
+      private
+
+      def variable_summary
+        return '(no variables defined)' if @variables.empty?
+
+        @variables.map { |k, v| "#{k} := #{v}" }
+                  .join("\n")
+      end
+
+      def function_summary
+        return '(no functions defined)' if @functions.empty?
+
+        @functions.map { |k, f| "#{k}: #{f}" }
+                  .join("\n")
+      end
+    end
+  end
+end