csv_plus_plus 0.1.2 → 0.2.0

data/lib/csv_plus_plus/google_options.rb

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

data/lib/csv_plus_plus/graph.rb

@@ -1,62 +0,0 @@
-# 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
-
-      # sort each child
-      def tsort_each_child(node, &)
-        fetch(node).each(&)
-      end
-    end
-  end
-end

data/lib/csv_plus_plus/lexer/lexer.rb

@@ -1,85 +0,0 @@
-# frozen_string_literal: true
-
-require_relative '../color'
-
-module CSVPlusPlus
-  # Common methods to be mixed into the Racc parsers
-  #
-  # @attr_reader tokens [Array]
-  module Lexer
-    attr_reader :tokens
-
-    # Initialize a lexer instance with an empty +@tokens+
-    def initialize(tokens: [])
-      @tokens = tokens
-    end
-
-    # Used by racc to iterate each token
-    #
-    # @return [Array<(String, String)>]
-    def next_token
-      @tokens.shift
-    end
-
-    # Orchestate the tokenizing, parsing and error handling of parsing input.  Each instance will implement their own
-    #   #tokenizer method
-    #
-    # @return [Lexer#return_value] Each instance will define it's own +return_value+ with the result of parsing
-    def parse(input, runtime)
-      return if input.nil?
-
-      return return_value unless anything_to_parse?(input)
-
-      tokenize(input, runtime)
-      do_parse
-      return_value
-    rescue ::Racc::ParseError => e
-      runtime.raise_formula_syntax_error("Error parsing #{parse_subject}", e.message, wrapped_error: e)
-    rescue ::CSVPlusPlus::Error::ModifierValidationError => e
-      raise(::CSVPlusPlus::Error::ModifierSyntaxError.new(runtime, wrapped_error: e))
-    end
-
-    TOKEN_LIBRARY = {
-      A1_NOTATION: [::CSVPlusPlus::Entities::CellReference::A1_NOTATION_REGEXP, :A1_NOTATION],
-      FALSE: [/false/i, :FALSE],
-      HEX_COLOR: [::CSVPlusPlus::Color::HEX_STRING_REGEXP, :HEX_COLOR],
-      ID: [/[$!\w:]+/, :ID],
-      INFIX_OP: [%r{\^|\+|-|\*|/|&|<|>|<=|>=|<>}, :INFIX_OP],
-      NUMBER: [/-?[\d.]+/, :NUMBER],
-      STRING: [%r{"(?:[^"\\]|\\(?:["\\/bfnrt]|u[0-9a-fA-F]{4}))*"}, :STRING],
-      TRUE: [/true/i, :TRUE],
-      VAR_REF: [/\$\$/, :VAR_REF]
-    }.freeze
-    public_constant :TOKEN_LIBRARY
-
-    private
-
-    def tokenize(input, runtime)
-      return if input.nil?
-
-      t = tokenizer.scan(input)
-
-      until t.scanner.empty?
-        next if t.matches_ignore?
-
-        return if t.stop?
-
-        t.scan_tokens!
-        consume_token(t, runtime)
-      end
-
-      @tokens << %i[EOL EOL]
-    end
-
-    def consume_token(tokenizer, runtime)
-      if tokenizer.last_token
-        @tokens << [tokenizer.last_token, tokenizer.last_match]
-      elsif tokenizer.scan_catchall
-        @tokens << [tokenizer.last_match, tokenizer.last_match]
-      else
-        # TODO: this should raise a modifier_syntax_error if we're on the modifier parser
-        runtime.raise_formula_syntax_error("Unable to parse #{parse_subject} starting at", tokenizer.peek)
-      end
-    end
-  end
-end

data/lib/csv_plus_plus/references.rb

@@ -1,68 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'graph'
-require_relative 'scope'
-
-module CSVPlusPlus
-  # References in an AST that need to be resolved
-  #
-  # @attr functions [Array<Entities::Function>] Functions references
-  # @attr variables [Array<Entities::Variable>] Variable references
-  class References
-    attr_accessor :functions, :variables
-
-    # Extract references from an AST and return them in a new +References+ object
-    #
-    # @param ast [Entity] An +Entity+ to do a depth first search on for references.  Entities can be
-    #   infinitely deep because they can contain other function calls as params to a function call
-    # @param scope [Scope] The +CodeSection+ containing all currently defined functions & variables
-    #
-    # @return [References]
-    def self.extract(ast, scope)
-      new.tap do |refs|
-        ::CSVPlusPlus::Graph.depth_first_search(ast) do |node|
-          next unless node.function_call? || node.variable?
-
-          refs.functions << node if function_reference?(node, scope)
-          refs.variables << node if node.variable?
-        end
-      end
-    end
-
-    # Is the node a resolvable reference?
-    #
-    # @param node [Entity] The node to check if it's resolvable
-    #
-    # @return [boolean]
-    # TODO: move this into the Entity subclasses
-    def self.function_reference?(node, scope)
-      node.function_call? && (scope.defined_function?(node.id) \
-                              || ::CSVPlusPlus::Entities::Builtins::FUNCTIONS.key?(node.id))
-    end
-
-    private_class_method :function_reference?
-
-    # Create an object with empty references.  The caller will build them up as it depth-first-searches
-    def initialize
-      @functions = []
-      @variables = []
-    end
-
-    # Are there any references to be resolved?
-    #
-    # @return [boolean]
-    def empty?
-      @functions.empty? && @variables.empty?
-    end
-
-    # @return [String]
-    def to_s
-      "References(functions: #{@functions}, variables: #{@variables})"
-    end
-
-    # @return [boolean]
-    def ==(other)
-      @functions == other.functions && @variables == other.variables
-    end
-  end
-end

data/lib/csv_plus_plus/scope.rb

@@ -1,196 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'can_define_references'
-require_relative 'entities'
-require_relative 'graph'
-require_relative 'references'
-
-module CSVPlusPlus
-  # A class representing the scope of the current Template and responsible for resolving variables
-  #
-  # @attr_reader functions [Hash<Symbol, Function>] The currently functions defined
-  # @attr_reader runtime [Runtime] The compiler's current runtime
-  # @attr_reader variables [Hash<Symbol, Entity>] The currently defined variables
-  #
-  # rubocop:disable Metrics/ClassLength
-  class Scope
-    include ::CSVPlusPlus::CanDefineReferences
-    # TODO: split out a CanResolveReferences
-
-    attr_reader :functions, :runtime, :variables
-
-    # @param runtime [Runtime]
-    def initialize(runtime:, functions: {}, variables: {})
-      @runtime = runtime
-      @functions = functions
-      @variables = variables
-    end
-
-    # Resolve all values in the ast of the current cell being processed
-    #
-    # @return [Entity]
-    def resolve_cell_value
-      return unless (ast = @runtime.cell&.ast)
-
-      last_round = nil
-      loop do
-        refs = ::CSVPlusPlus::References.extract(ast, self)
-        return ast if refs.empty?
-
-        # TODO: throw an error here instead I think - basically we did a round and didn't make progress
-        return ast if last_round == refs
-
-        ast = resolve_functions(resolve_variables(ast, refs.variables), refs.functions)
-      end
-    end
-
-    # Bind +var_id+ to the current cell (based on where +@runtime+ is currently pointing).
-    #
-    # @param var_id [Symbol] The name of the variable to bind the cell reference to
-    #
-    # @return [CellReference]
-    def bind_variable_to_cell(var_id)
-      ::CSVPlusPlus::Entities::CellReference.from_index(
-        cell_index: runtime.cell_index,
-        row_index: runtime.row_index
-      ).tap do |cell_reference|
-        def_variable(var_id, cell_reference)
-      end
-    end
-
-    # @return [String]
-    def to_s
-      "Scope(functions: #{@functions}, runtime: #{@runtime}, variables: #{@variables})"
-    end
-
-    private
-
-    # Resolve all variable references defined statically in the code section
-    # TODO: experiment with getting rid of this - does it even play correctly with runtime vars?
-    def resolve_static_variables!
-      last_var_dependencies = {}
-      loop do
-        var_dependencies, resolution_order = variable_resolution_order(only_static_vars(variables))
-        return if var_dependencies == last_var_dependencies
-
-        # TODO: make the contract better here
-        @variables = resolve_dependencies(var_dependencies, resolution_order, variables)
-        last_var_dependencies = var_dependencies.clone
-      end
-    end
-
-    def only_static_vars(var_dependencies)
-      var_dependencies.reject { |k| @runtime.runtime_variable?(k) }
-    end
-
-    def resolve_functions(ast, refs)
-      refs.reduce(ast.dup) do |acc, elem|
-        function_replace(acc, elem.id, resolve_function(elem.id))
-      end
-    end
-
-    def resolve_variables(ast, refs)
-      refs.reduce(ast.dup) do |acc, elem|
-        variable_replace(acc, elem.id, resolve_variable(elem.id))
-      end
-    end
-
-    # Make a copy of the AST represented by +node+ and replace +fn_id+ with +replacement+ throughout
-    # rubocop:disable Metrics/MethodLength
-    def function_replace(node, fn_id, replacement)
-      if node.function_call? && node.id == fn_id
-        call_function_or_runtime_value(replacement, node)
-      elsif node.function_call?
-        # not our function, but continue our depth first search on it
-        ::CSVPlusPlus::Entities::FunctionCall.new(
-          node.id,
-          node.arguments.map { |n| function_replace(n, fn_id, replacement) },
-          infix: node.infix
-        )
-      else
-        node
-      end
-    end
-    # rubocop:enable Metrics/MethodLength
-
-    def resolve_function(fn_id)
-      id = fn_id.to_sym
-      return functions[id] if defined_function?(id)
-
-      ::CSVPlusPlus::Entities::Builtins::FUNCTIONS[id]
-    end
-
-    def call_function_or_runtime_value(function_or_runtime_value, function_call)
-      if function_or_runtime_value.function?
-        call_function(function_or_runtime_value, function_call)
-      else
-        function_or_runtime_value.resolve_fn.call(@runtime, function_call.arguments)
-      end
-    end
-
-    def call_function(function, function_call)
-      i = 0
-      function.arguments.reduce(function.body.dup) do |ast, argument|
-        variable_replace(ast, argument, function_call.arguments[i]).tap do
-          i += 1
-        end
-      end
-    end
-
-    # Make a copy of the AST represented by +node+ and replace +var_id+ with +replacement+ throughout
-    def variable_replace(node, var_id, replacement)
-      if node.function_call?
-        arguments = node.arguments.map { |n| variable_replace(n, var_id, replacement) }
-        # TODO: refactor these places where we copy functions... it's brittle with the kwargs
-        ::CSVPlusPlus::Entities::FunctionCall.new(node.id, arguments, infix: node.infix)
-      elsif node.variable? && node.id == var_id
-        replacement
-      else
-        node
-      end
-    end
-
-    def resolve_variable(var_id)
-      id = var_id.to_sym
-      return variables[id] if defined_variable?(id)
-
-      # this will throw a syntax error if it doesn't exist (which is what we want)
-      @runtime.runtime_value(id)
-    end
-
-    def check_unbound_vars(dependencies, variables)
-      unbound_vars = dependencies.values.flatten - variables.keys
-      return if unbound_vars.empty?
-
-      @runtime.raise_formula_syntax_error('Undefined variables', unbound_vars.map(&:to_s).join(', '))
-    end
-
-    def variable_resolution_order(variables)
-      # we have a hash of variables => ASTs but they might have references to each other, so
-      # we need to interpolate them first (before interpolating the cell values)
-      var_dependencies = ::CSVPlusPlus::Graph.dependency_graph(variables, @runtime)
-      # are there any references that we don't have variables for? (undefined variable)
-      check_unbound_vars(var_dependencies, variables)
-
-      # a topological sort will give us the order of dependencies
-      [var_dependencies, ::CSVPlusPlus::Graph.topological_sort(var_dependencies)]
-      # TODO: don't expose this exception directly to the caller
-    rescue ::TSort::Cyclic
-      @runtime.raise_formula_syntax_error('Cyclic variable dependency detected', var_refs.keys)
-    end
-
-    def resolve_dependencies(var_dependencies, resolution_order, variables)
-      {}.tap do |resolved_vars|
-        # for each var and each dependency it has, build up and mutate resolved_vars
-        resolution_order.each do |var|
-          resolved_vars[var] = variables[var].dup
-
-          var_dependencies[var].each do |dependency|
-            resolved_vars[var] = variable_replace(resolved_vars[var], dependency, variables[dependency])
-          end
-        end
-      end
-    end
-  end
-  # rubocop:enable Metrics/ClassLength
-end

data/lib/csv_plus_plus/validated_modifier.rb

@@ -1,164 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'data_validation'
-require_relative 'modifier'
-
-module CSVPlusPlus
-  # Validates and coerces modifier values as they are parsed.
-  #
-  # Previously this logic was handled in the parser's grammar, but with the introduction of variable binding, the
-  # grammar is no longer context free so we need the parser to be a little looser on what it accepts and validate it
-  # here.  Having this layer is also nice because we can provide better error messages to the user for what went
-  # wrong during the parse.
-  class ValidatedModifier < ::CSVPlusPlus::Modifier
-    # Validates that +border+ is 'all', 'top', 'bottom', 'left' or 'right'.
-    #
-    # @param value [String] The unvalidated user input
-    def border=(value)
-      super(one_of(:border, value, %i[all top bottom left right]))
-    end
-
-    # Validates that +bordercolor+ is a hex color.
-    #
-    # @param value [String] The unvalidated user input
-    def bordercolor=(value)
-      super(color_value(:bordercolor, value))
-    end
-
-    # Validates that +borderstyle+ is 'dashed', 'dotted', 'double', 'solid', 'solid_medium' or 'solid_thick'.
-    #
-    # @param value [String] The unvalidated user input
-    def borderstyle=(value)
-      super(one_of(:borderstyle, value, %i[dashed dotted double solid solid_medium solid_thick]))
-    end
-
-    # Validates that +color+ is a hex color.
-    #
-    # @param value [String] The unvalidated user input
-    def color=(value)
-      super(color_value(:color, value))
-    end
-
-    # Validates that +expand+ is a positive integer.
-    #
-    # @param value [String] The unvalidated user input
-    def expand=(value)
-      super(::CSVPlusPlus::Expand.new(positive_integer(:expand, value)))
-    end
-
-    # Validates that +fontcolor+ is a hex color.
-    #
-    # @param value [String] The unvalidated user input
-    def fontcolor=(value)
-      super(color_value(:fontcolor, value))
-    end
-
-    # Validates that +fontcolor+ is a hex color.
-    def fontfamily=(value)
-      super(matches_regexp(:fontfamily, unquote(value), /^[\w\s]+$/, 'It is not a valid font family.'))
-    end
-
-    # Validates that +fontsize+ is a positive integer
-    #
-    # @param value [String] The unvalidated user input
-    def fontsize=(value)
-      super(positive_integer(:fontsize, value))
-    end
-
-    # Validates that +format+ is 'bold', 'italic', 'strikethrough' or 'underline'.
-    #
-    # @param value [String] The unvalidated user input
-    def format=(value)
-      super(one_of(:format, value, %i[bold italic strikethrough underline]))
-    end
-
-    # Validates that +halign+ is 'left', 'center' or 'right'.
-    #
-    # @param value [String] The unvalidated user input
-    def halign=(value)
-      super(one_of(:halign, value, %i[left center right]))
-    end
-
-    # Validates that +note+ is a quoted string.
-    #
-    # @param value [String] The unvalidated user input
-
-    # Validates that +numberformat+ is 'currency', 'date', 'date_time', 'number', 'percent', 'text', 'time' or
-    # 'scientific'.
-    #
-    # @param value [String] The unvalidated user input
-    def numberformat=(value)
-      super(one_of(:nubmerformat, value, %i[currency date date_time number percent text time scientific]))
-    end
-
-    # Validates that +valign+ is 'top', 'center' or 'bottom'.
-    #
-    # @param value [String] The unvalidated user input
-    def valign=(value)
-      super(one_of(:valign, value, %i[top center bottom]))
-    end
-
-    # Validates that the conditional validating rules are well-formed.
-    #
-    # Pretty much based off of the Google Sheets API spec here:
-    #
-    # @param value [String] The unvalidated user input
-    def validation=(value)
-      super(a_data_validation(:validation, value))
-    end
-
-    # Validates +variable+ is a valid variable identifier.
-    #
-    # @param value [String] The unvalidated user input
-    def var=(value)
-      # TODO: I need a shared definition of what a variable can be (I guess the :ID token)
-      super(matches_regexp(:var, value, /^\w+$/, 'It must be a sequence of letters, numbers and _.').to_sym)
-    end
-
-    private
-
-    # XXX centralize this :(((
-    def unquote(str)
-      # TODO: I'm pretty sure this isn't sufficient and we need to deal with the backslashes
-      str.gsub(/^['\s]*|['\s]*$/, '')
-    end
-
-    def a_data_validation(modifier, value)
-      data_validation = ::CSVPlusPlus::DataValidation.new(value)
-      return data_validation unless data_validation.valid?
-
-      raise_error(modifier, value, message: data_validation.invalid_reason)
-    end
-
-    def color_value(modifier, value)
-      unless ::CSVPlusPlus::Color.valid_hex_string?(value)
-        raise_error(modifier, value, message: 'It must be a 3 or 6 digit hex code.')
-      end
-
-      ::CSVPlusPlus::Color.new(value)
-    end
-
-    def matches_regexp(modifier, value, regexp, message)
-      raise_error(modifier, value, message:) unless value =~ regexp
-      value
-    end
-
-    def one_of(modifier, value, choices)
-      value.downcase.to_sym.tap do |v|
-        raise_error(modifier, value, choices:) unless choices.include?(v)
-      end
-    end
-
-    def positive_integer(modifier, value)
-      Integer(value, 10).tap do |i|
-        raise_error(modifier, value, message: 'It must be positive and greater than 0.') unless i.positive?
-      end
-    rescue ::ArgumentError
-      raise_error(modifier, value, message: 'It must be a valid (whole) number.')
-    end
-
-    def raise_error(modifier, bad_input, choices: nil, message: nil)
-      raise(::CSVPlusPlus::Error::ModifierValidationError.new(modifier, bad_input, choices:, message:))
-    end
-  end
-end

data/lib/csv_plus_plus/writer/base_writer.rb

@@ -1,20 +0,0 @@
-# frozen_string_literal: true
-
-module CSVPlusPlus
-  module Writer
-    # Some shared functionality that all Writers should build on
-    class BaseWriter
-      attr_accessor :options
-
-      protected
-
-      # Open a CSV outputter to +filename+
-      def initialize(options)
-        @options = options
-        load_requires
-      end
-
-      def load_requires; end
-    end
-  end
-end