csv_plus_plus 0.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 66b51b9e9784f89236625da57b647867b502b50acad209d1e98619fd94fb6f70
+  data.tar.gz: f4815f9a10637ee82a4f4f1e32afbd9db47bf728eb3992bb77ce75d9fb460092
+SHA512:
+  metadata.gz: 5a983659e3033642f9ff185adca67897a3510578ef765f1cc4f65e8df6ec1f1ecf8b767e6860c3af00c773b6b5d4229bc4699e071a38b04a3f31ec55a225cf76
+  data.tar.gz: '0684df3fc8678b6061d572da196bcdfb24f224009c9fa61b64b769178aa18dd6697c7a9f4dba3ab93e15b3a79ecfcd350f23abf1c117bee9026a0b9ba47e6e6c'

data/lib/csv_plus_plus/cell.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require_relative './language/cell_value.tab'
+require_relative './modifier'
+
+module CSVPlusPlus
+  ##
+  # A cell of a template
+  class Cell
+    attr_accessor :ast, :row_index
+    attr_reader :index, :modifier
+
+    # Parse a +value+ into a Cell object.  The +value+ should already have been through
+    # a CSV parser
+    def self.parse(value, runtime:, modifier:)
+      new(value:, row_index: runtime.row_index, index: runtime.cell_index, modifier:).tap do |c|
+        c.ast = ::CSVPlusPlus::Language::CellValueParser.new.parse(value, runtime)
+      end
+    end
+
+    # initialize
+    def initialize(row_index:, index:, value:, modifier:)
+      @value = value
+      @modifier = modifier
+      @index = index
+      @row_index = row_index
+    end
+
+    # The value (cleaned up some)
+    def value
+      return if @value.nil? || @value.strip.empty?
+
+      @value.strip
+    end
+
+    # to_s
+    def to_s
+      "Cell(index: #{@index}, row_index: #{@row_index}, value: #{@value}, modifier: #{@modifier})"
+    end
+
+    # A compiled final representation of the cell.  This can only happen after all cell have had
+    # variables and functions resolved.
+    def to_csv
+      return value unless @ast
+
+      # This looks really simple but we're relying on each node of the AST to define #to_s and calling
+      # this at the top will recursively print the tree
+      "=#{@ast}"
+    end
+  end
+end

data/lib/csv_plus_plus/code_section.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require_relative './language/code_section.tab'
+require_relative './language/entities'
+
+module CSVPlusPlus
+  ##
+  # A representation of the code section part of a template (the variable and function definitions)
+  class CodeSection
+    attr_reader :functions
+    attr_accessor :variables
+
+    # initialize
+    def initialize(variables: {}, functions: {})
+      @variables = variables
+      @functions = functions
+    end
+
+    # Define a (or re-define an existing) variable
+    def def_variable(id, entity)
+      @variables[id.to_sym] = entity
+    end
+
+    # Define (or re-define existing) variables
+    def def_variables(variables)
+      variables.each { |id, entity| def_variable(id, entity) }
+    end
+
+    # Define a (or re-define an existing) function
+    def def_function(id, entity)
+      @functions[id.to_sym] = entity
+    end
+
+    # Is the variable defined?
+    def defined_variable?(var_id)
+      @variables.key?(var_id.to_sym)
+    end
+
+    # Is the function defined?
+    def defined_function?(fn_id)
+      @functions.key?(fn_id.to_sym)
+    end
+
+    # to_s
+    def to_s
+      "CodeSection(functions: #{@functions}, variables: #{@variables})"
+    end
+  end
+end

data/lib/csv_plus_plus/color.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module CSVPlusPlus
+  # A color value
+  class Color
+    attr_reader :red, :green, :blue
+
+    # create an instance from a string like "#FFF" or "#FFFFFF"
+    def initialize(hex_string)
+      @red, @green, @blue =
+        hex_string
+        .gsub(/^#?/, '')
+        .match(/(\w\w?)(\w\w?)(\w\w?)/)
+        .captures
+        .map do |s|
+          255 / (s.length == 2 ? s : s + s).to_i(16)
+        rescue ::StandardError
+          0
+        end
+    end
+  end
+end

data/lib/csv_plus_plus/expand.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module CSVPlusPlus
+  Expand =
+    ::Struct.new(:repetitions) do
+      # Does this infinitely expand?
+      def infinite?
+        repetitions.nil?
+      end
+
+      # to_s
+      def to_s
+        "Expand #{repetitions || 'infinity'}"
+      end
+    end
+
+  public_constant :Expand
+end

data/lib/csv_plus_plus/google_options.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module CSVPlusPlus
+  # The Google-specific options a user can supply
+  GoogleOptions =
+    ::Struct.new(:sheet_id) do
+      # Return a string with a verbose description of what we're doing with the options
+      def verbose_summary
+        <<~SUMMARY
+          ## Google Sheets Options
+
+          > Sheet ID | #{sheet_id}
+        SUMMARY
+      end
+
+      # to_s
+      def to_s
+        "GoogleOptions(sheet_id: #{sheet_id})"
+      end
+    end
+
+  public_constant :GoogleOptions
+end

data/lib/csv_plus_plus/graph.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require 'tsort'
+
+module CSVPlusPlus
+  ##
+  # 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, runtime, include_runtime_variables: false)
+      depth_first_search(ast) do |node|
+        next unless node.variable?
+
+        node.id if !runtime.runtime_variable?(node.id) || include_runtime_variables
+      end
+    end
+
+    # Create a dependency graph of +variables+
+    def self.dependency_graph(variables, runtime)
+      ::CSVPlusPlus::Graph::DependencyGraph[
+        variables.map { |var_id, ast| [var_id, variable_references(ast, runtime)] }
+      ]
+    end
+
+    # 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.function_call?
+
+      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
+
+      # create a +DependencyGraph+ from a +Hash+
+      def self.from_hash(hash)
+        self[hash.map { |k, v| [k, v] }]
+      end
+
+      # sort each child
+      def tsort_each_child(node, &)
+        fetch(node).each(&)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,333 @@
+#
+# DO NOT MODIFY!!!!
+# This file is automatically generated by Racc 1.6.2
+# from Racc grammar file "".
+#
+
+require 'racc/parser.rb'
+
+  require_relative '../lexer'
+
+module CSVPlusPlus
+  module Language
+    class CellValueParser < Racc::Parser
+
+module_eval(<<'...end cell_value.y/module_eval...', 'cell_value.y', 48)
+  include ::CSVPlusPlus::Lexer
+
+  protected
+
+  def anything_to_parse?(input)
+    input.strip.start_with?('=')
+  end
+
+  def parse_subject
+    'cell value'
+  end
+
+  def return_value
+    @ast
+  end
+
+  def tokenizer(input)
+    ::CSVPlusPlus::Lexer::Tokenizer.new(
+      catchall: /[\(\)\/\*\+\-,=&]/,
+      ignore: /\s+/,
+      input:,
+      tokens: [
+        [/true/i, :TRUE],
+        [/false/i, :FALSE],
+        [/"(?:[^"\\]|\\(?:["\\\/bfnrt]|u[0-9a-fA-F]{4}))*"/, :STRING],
+        [/-?[\d.]+/, :NUMBER],
+        [/\$\$/, :VAR_REF],
+        [/[\$\w_]+/, :ID]
+      ]
+    )
+  end
+...end cell_value.y/module_eval...
+##### State transition tables begin ###
+
+racc_action_table = [
+    33,    16,    17,    20,    18,    19,    15,     7,    16,    17,
+    20,    18,    19,     7,    34,    12,    13,    10,     9,    11,
+     8,    12,    13,    10,     9,    11,     8,     7,    16,    17,
+    20,    18,    19,     7,     2,    12,    13,    10,     9,    11,
+     8,    12,    13,    10,     9,    11,     8,     7,    16,    17,
+    20,     3,    14,     7,    22,    12,    13,    10,     9,    11,
+     8,    12,    13,    10,     9,    11,     8,     7,    16,    17,
+    20,    23,    16,     7,    31,    12,    13,    10,     9,    11,
+     8,    12,    13,    10,     9,    11,     8,     7,    29,    16,
+    17,    20,    18,    19,    16,    12,    13,    10,     9,    11,
+     8 ]
+
+racc_action_check = [
+    30,     4,     4,     4,     4,     4,     4,     2,    32,    32,
+    32,    32,    32,     7,    30,     2,     2,     2,     2,     2,
+     2,     7,     7,     7,     7,     7,     7,    16,    35,    35,
+    35,    35,    35,    17,     0,    16,    16,    16,    16,    16,
+    16,    17,    17,    17,    17,    17,    17,    18,    26,    26,
+    26,     1,     3,    19,     8,    18,    18,    18,    18,    18,
+    18,    19,    19,    19,    19,    19,    19,    20,    27,    27,
+    27,    13,    25,    23,    23,    20,    20,    20,    20,    20,
+    20,    23,    23,    23,    23,    23,    23,    34,    21,    21,
+    21,    21,    21,    21,    28,    34,    34,    34,    34,    34,
+    34 ]
+
+racc_action_pointer = [
+    18,    51,     5,    52,    -3,   nil,   nil,    11,    43,   nil,
+   nil,   nil,   nil,    69,   nil,   nil,    25,    31,    45,    51,
+    65,    85,   nil,    71,   nil,    68,    44,    64,    90,   nil,
+    -3,   nil,     4,   nil,    85,    24 ]
+
+racc_action_default = [
+   -20,   -20,   -20,   -20,   -20,    -2,    -3,   -20,   -20,    -6,
+    -7,    -8,    -9,   -10,    36,    -1,   -20,   -20,   -20,   -20,
+   -20,   -20,    -5,   -20,   -15,   -16,   -17,   -18,   -19,    -4,
+   -20,   -12,   -14,   -11,   -20,   -13 ]
+
+racc_goto_table = [
+     4,     1,    30,   nil,   nil,    21,   nil,   nil,   nil,   nil,
+   nil,   nil,   nil,   nil,    24,    25,    26,    27,    28,   nil,
+   nil,    32,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,
+   nil,   nil,    35 ]
+
+racc_goto_check = [
+     2,     1,     5,   nil,   nil,     2,   nil,   nil,   nil,   nil,
+   nil,   nil,   nil,   nil,     2,     2,     2,     2,     2,   nil,
+   nil,     2,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,
+   nil,   nil,     2 ]
+
+racc_goto_pointer = [
+   nil,     1,    -2,   nil,   nil,   -21 ]
+
+racc_goto_default = [
+   nil,   nil,   nil,     5,     6,   nil ]
+
+racc_reduce_table = [
+  0, 0, :racc_error,
+  3, 19, :_reduce_1,
+  1, 20, :_reduce_none,
+  1, 20, :_reduce_none,
+  3, 20, :_reduce_4,
+  2, 20, :_reduce_5,
+  1, 20, :_reduce_6,
+  1, 20, :_reduce_7,
+  1, 20, :_reduce_8,
+  1, 20, :_reduce_9,
+  1, 20, :_reduce_10,
+  4, 21, :_reduce_11,
+  3, 21, :_reduce_12,
+  3, 23, :_reduce_13,
+  1, 23, :_reduce_14,
+  3, 22, :_reduce_15,
+  3, 22, :_reduce_16,
+  3, 22, :_reduce_17,
+  3, 22, :_reduce_18,
+  3, 22, :_reduce_19 ]
+
+racc_reduce_n = 20
+
+racc_shift_n = 36
+
+racc_token_table = {
+  false => 0,
+  :error => 1,
+  "(" => 2,
+  ")" => 3,
+  "&" => 4,
+  "*" => 5,
+  "/" => 6,
+  "+" => 7,
+  "-" => 8,
+  :EOL => 9,
+  :FALSE => 10,
+  :ID => 11,
+  :NUMBER => 12,
+  :STRING => 13,
+  :TRUE => 14,
+  :VAR_REF => 15,
+  "=" => 16,
+  "," => 17 }
+
+racc_nt_base = 18
+
+racc_use_result_var = true
+
+Racc_arg = [
+  racc_action_table,
+  racc_action_check,
+  racc_action_default,
+  racc_action_pointer,
+  racc_goto_table,
+  racc_goto_check,
+  racc_goto_default,
+  racc_goto_pointer,
+  racc_nt_base,
+  racc_reduce_table,
+  racc_token_table,
+  racc_shift_n,
+  racc_reduce_n,
+  racc_use_result_var ]
+
+Racc_token_to_s_table = [
+  "$end",
+  "error",
+  "\"(\"",
+  "\")\"",
+  "\"&\"",
+  "\"*\"",
+  "\"/\"",
+  "\"+\"",
+  "\"-\"",
+  "EOL",
+  "FALSE",
+  "ID",
+  "NUMBER",
+  "STRING",
+  "TRUE",
+  "VAR_REF",
+  "\"=\"",
+  "\",\"",
+  "$start",
+  "cell_value",
+  "exp",
+  "fn_call",
+  "infix_fn_call",
+  "fn_call_args" ]
+
+Racc_debug_parser = false
+
+##### State transition tables end #####
+
+# reduce 0 omitted
+
+module_eval(<<'.,.,', 'cell_value.y', 17)
+  def _reduce_1(val, _values, result)
+     @ast = val[1]
+    result
+  end
+.,.,
+
+# reduce 2 omitted
+
+# reduce 3 omitted
+
+module_eval(<<'.,.,', 'cell_value.y', 21)
+  def _reduce_4(val, _values, result)
+     result = val[1]
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'cell_value.y', 22)
+  def _reduce_5(val, _values, result)
+     result = e(:variable, val[1])
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'cell_value.y', 23)
+  def _reduce_6(val, _values, result)
+     result = e(:string, val[0])
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'cell_value.y', 24)
+  def _reduce_7(val, _values, result)
+     result = e(:number, val[0])
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'cell_value.y', 25)
+  def _reduce_8(val, _values, result)
+     result = e(:boolean, true)
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'cell_value.y', 26)
+  def _reduce_9(val, _values, result)
+     result = e(:boolean, false)
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'cell_value.y', 27)
+  def _reduce_10(val, _values, result)
+     result = e(:cell_reference, val[0])
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'cell_value.y', 29)
+  def _reduce_11(val, _values, result)
+     result = e(:function_call, val[0], val[2])
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'cell_value.y', 30)
+  def _reduce_12(val, _values, result)
+     result = e(:function_call, val[0], [])
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'cell_value.y', 32)
+  def _reduce_13(val, _values, result)
+     result = val[0] << val[2]
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'cell_value.y', 33)
+  def _reduce_14(val, _values, result)
+     result = [val[0]]
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'cell_value.y', 35)
+  def _reduce_15(val, _values, result)
+     result = e(:function_call, :concat, [val[0], val[2]])
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'cell_value.y', 36)
+  def _reduce_16(val, _values, result)
+     result = e(:function_call, :multiply, [val[0], val[2]])
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'cell_value.y', 37)
+  def _reduce_17(val, _values, result)
+     result = e(:function_call, :add, [val[0], val[2]])
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'cell_value.y', 38)
+  def _reduce_18(val, _values, result)
+     result = e(:function_call, :minus, [val[0], val[2]])
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'cell_value.y', 39)
+  def _reduce_19(val, _values, result)
+     result = e(:function_call, :divide, [val[0], val[2]])
+    result
+  end
+.,.,
+
+def _reduce_none(val, _values, result)
+  val[0]
+end
+
+    end   # class CellValueParser
+  end   # module Language
+end   # module CSVPlusPlus