csv_plus_plus 0.1.2 → 0.1.3

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/google_sheet_modifier.rb

@@ -1,77 +0,0 @@
-# frozen_string_literal: true
-
-module CSVPlusPlus
-  module Writer
-    # Decorate a Modifier so it can be written to the Google Sheets API
-    class GoogleSheetModifier < ::SimpleDelegator
-      # Format the border for Google Sheets
-      #
-      # @return [Google::Apis::SheetsV4::Border]
-      def border
-        # TODO: allow different border styles per side
-        ::Google::Apis::SheetsV4::Border.new(
-          color: bordercolor&.to_s || '#000000',
-          style: borderstyle&.to_s || 'solid'
-        )
-      end
-
-      # Format the color for Google Sheets
-      #
-      # @return [Google::Apis::SheetsV4::Color]
-      def color
-        google_sheets_color(super) if super
-      end
-
-      # Format the fontcolor for Google Sheets
-      #
-      # @return [Google::Apis::SheetsV4::Color]
-      def fontcolor
-        google_sheets_color(super) if super
-      end
-
-      # Format the halign for Google Sheets
-      #
-      # @return [String]
-      def halign
-        super&.to_s&.upcase
-      end
-
-      # Format the numberformat for Google Sheets
-      #
-      # @return [::Google::Apis::SheetsV4::NumberFormat]
-      def numberformat
-        ::Google::Apis::SheetsV4::NumberFormat.new(type: super) if super
-      end
-
-      # Builds a SheetsV4::TextFormat with the underlying Modifier
-      #
-      # @return [::Google::Apis::SheetsV4::TextFormat]
-      def text_format
-        ::Google::Apis::SheetsV4::TextFormat.new(
-          bold: formatted?(:bold) || nil,
-          italic: formatted?(:italic) || nil,
-          strikethrough: formatted?(:strikethrough) || nil,
-          underline: formatted?(:underline) || nil,
-          font_family: fontfamily,
-          font_size: fontsize,
-          foreground_color: fontcolor
-        )
-      end
-
-      # Format the valign for Google Sheets
-      def valign
-        super&.to_s&.upcase
-      end
-
-      private
-
-      def google_sheets_color(color)
-        ::Google::Apis::SheetsV4::Color.new(
-          red: color.red_percent,
-          green: color.green_percent,
-          blue: color.blue_percent
-        )
-      end
-    end
-  end
-end

data/lib/csv_plus_plus/writer/rubyxl_modifier.rb

@@ -1,59 +0,0 @@
-# frozen_string_literal: true
-
-module CSVPlusPlus
-  module Writer
-    # Build a RubyXL-decorated Modifier class adds some support for Excel
-    class RubyXLModifier < ::SimpleDelegator
-      # https://www.rubydoc.info/gems/rubyXL/RubyXL/NumberFormats
-      # https://support.microsoft.com/en-us/office/number-format-codes-5026bbd6-04bc-48cd-bf33-80f18b4eae68
-      NUM_FMT_IDS = {
-        currency: 5,
-        date: 14,
-        date_time: 22,
-        number: 1,
-        percent: 9,
-        text: 49,
-        time: 21,
-        scientific: 48
-      }.freeze
-      private_constant :NUM_FMT_IDS
-
-      # https://www.rubydoc.info/gems/rubyXL/2.3.0/RubyXL
-      # ST_BorderStyle = %w{ none thin medium dashed dotted thick double hair mediumDashed dashDot mediumDashDot
-      #                      dashDotDot slantDashDot }
-      BORDER_STYLES = {
-        dashed: 'dashed',
-        dotted: 'dotted',
-        double: 'double',
-        solid: 'thin',
-        solid_medium: 'medium',
-        solid_thick: 'thick'
-      }.freeze
-      private_constant :BORDER_STYLES
-
-      # The excel-specific border weight
-      #
-      # @return [Integer]
-      def border_weight
-        return unless borderstyle
-
-        # rubocop:disable Lint/ConstantResolution
-        BORDER_STYLES[borderstyle.to_sym]
-        # rubocop:enable Lint/ConstantResolution
-      end
-
-      # The excel-specific number format code
-      #
-      # @return [String]
-      def number_format_code
-        return unless numberformat
-
-        ::RubyXL::NumberFormats::DEFAULT_NUMBER_FORMATS.find_by_format_id(
-          # rubocop:disable Lint/ConstantResolution
-          NUM_FMT_IDS[numberformat.to_sym]
-          # rubocop:enable Lint/ConstantResolution
-        ).format_code
-      end
-    end
-  end
-end