csv_plus_plus 0.1.0 → 0.1.2

data/lib/csv_plus_plus/data_validation.rb

@@ -0,0 +1,138 @@
+# frozen_string_literal: true
+
+module CSVPlusPlus
+  # A validation on a cell value.  Used to support the `validate=` modifier directive.  This is mostly based on the
+  # Google Sheets API spec which can be seen here:
+  #
+  # {https://developers.google.com/sheets/api/reference/rest/v4/spreadsheets/other#ConditionType}
+  #
+  # @attr_reader arguments [Array<::String>] The parsed arguments as required by the condition.
+  # @attr_reader condition [Symbol] The condition (:blank, :text_eq, :date_before, etc.)
+  # @attr_reader invalid_reason [::String, nil] If set, the reason why this modifier is not valid.
+  class DataValidation
+    attr_reader :arguments, :condition, :invalid_reason
+
+    # @param value [::String] The value to parse as a data validation
+    def initialize(value)
+      condition, args = unquote(value).split(/\s*:\s*/)
+      @arguments = unquote(args || '').split(/\s+/)
+      @condition = condition.to_sym
+
+      validate!
+    end
+
+    # Each data validation represented by (+condition+) has their own require
+    # @return [boolean]
+    def valid?
+      @invalid_reason.nil?
+    end
+
+    protected
+
+    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 invalid!(reason)
+      @invalid_reason = reason
+    end
+
+    def a_number(arg)
+      Float(arg)
+    rescue ::ArgumentError
+      invalid!("Requires a number but given: #{arg}")
+    end
+
+    def a1_notation(arg)
+      return arg if ::CSVPlusPlus::Entities::CellReference.valid_cell_reference?(arg)
+    end
+
+    def a_date(arg, allow_relative_date: false)
+      return arg if ::CSVPlusPlus::Entities::Date.valid_date?(arg)
+
+      if allow_relative_date
+        a_relative_date(arg)
+      else
+        invalid!("Requires a date but given: #{arg}")
+      end
+    end
+
+    def a_relative_date(arg)
+      return arg if %w[past_month past_week past_year yesterday today tomorrow].include?(arg.downcase)
+
+      invalid!('Requires a relative date: past_month, past_week, past_year, yesterday, today or tomorrow')
+    end
+
+    def no_args
+      return if @arguments.empty?
+
+      invalid!("Requires no arguments but #{@arguments.length} given: #{@arguments}")
+    end
+
+    def one_arg
+      return @arguments[0] if @arguments.length == 1
+
+      invalid!("Requires only one argument but #{@arguments.length} given: #{@arguments}")
+    end
+
+    def one_arg_or_more
+      return @arguments if @arguments.length.positive?
+
+      invalid!("Requires at least one argument but #{@arguments.length} given: #{@arguments}")
+    end
+
+    def two_dates
+      return @arguments if @arguments.length == 2 && a_date(@arguments[0]) && a_date(@arguments[1])
+
+      invalid!("Requires exactly two dates but given: #{@arguments}")
+    end
+
+    def two_numbers
+      return @arguments if @arguments.length == 2 && a_number(@arguments[0]) && a_number(@arguments[1])
+
+      invalid!("Requires exactly two numbers but given: #{@arguments}")
+    end
+
+    # validate_boolean is a weird one because it can have 0, 1 or 2 @arguments - all of them must be (true | false)
+    def validate_boolean
+      return @arguments if @arguments.empty?
+
+      converted_args = @arguments.map(&:strip).map(&:downcase)
+      return @arguments if [1, 2].include?(@arguments.length) && converted_args.all? do |arg|
+                             %w[true false].include?(arg)
+                           end
+
+      invalid!("Requires 0, 1 or 2 arguments and they all must be either 'true' or 'false'. Received: #{arguments}")
+    end
+
+    # rubocop:disable Metrics/MethodLength, Metrics/CyclomaticComplexity, Metrics/AbcSize
+    def validate!
+      case condition.to_sym
+      when :blank, :date_is_valid, :not_blank, :text_is_email, :text_is_url
+        no_args
+      when :text_contains, :text_ends_with, :text_eq, :text_not_contains, :text_starts_with
+        one_arg
+      when :date_after, :date_before, :date_on_or_after, :date_on_or_before
+        a_date(one_arg, allow_relative_date: true)
+      when :date_eq, :date_not_eq
+        a_date(one_arg)
+      when :date_between, :date_not_between
+        two_dates
+      when :one_of_range
+        a1_notation(one_arg)
+      when :custom_formula, :one_of_list, :text_not_eq
+        one_arg_or_more
+      when :number_eq, :number_greater, :number_greater_than_eq, :number_less, :number_less_than_eq, :number_not_eq
+        a_number(one_arg)
+      when :number_between, :number_not_between
+        two_numbers
+      when :boolean
+        validate_boolean
+      else
+        invalid!('Not a recognized data validation directive')
+      end
+    end
+    # rubocop:enable Metrics/MethodLength, Metrics/CyclomaticComplexity, Metrics/AbcSize
+  end
+end

data/lib/csv_plus_plus/{language → entities}/ast_builder.rb

@@ -1,9 +1,7 @@
 # frozen_string_literal: true
 
-require_relative './entities'
-
 module CSVPlusPlus
-  module Language
+  module Entities
     # Some helpful functions that can be mixed into a class to help building ASTs
     module ASTBuilder
       # Let the current class have functions which can build a given entity by calling it's type.  For example
@@ -13,11 +11,11 @@ module CSVPlusPlus
       # @param arguments [] The arguments to create the entity with
       #
       # @return [Entity, #super]
-      def method_missing(method_name, *arguments)
-        entity_class = ::CSVPlusPlus::Language::TYPES[method_name.to_sym]
+      def method_missing(method_name, *args, **kwargs, &)
+        entity_class = ::CSVPlusPlus::Entities::TYPES[method_name.to_sym]
         return super unless entity_class
 
-        entity_class.new(*arguments)
+        entity_class.new(*args, **kwargs, &)
       end
 
       # Let the current class have functions which can build a given entity by calling it's type.  For example
@@ -28,7 +26,7 @@ module CSVPlusPlus
       #
       # @return [Boolean, #super]
       def respond_to_missing?(method_name, *_arguments)
-        ::CSVPlusPlus::Language::TYPES.include?(method_name.to_sym) || super
+        ::CSVPlusPlus::Entities::TYPES.include?(method_name.to_sym) || super
       end
 
       # Turns index-based/X,Y coordinates into a A1 format

data/lib/csv_plus_plus/entities/boolean.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require_relative './entity'
+
+module CSVPlusPlus
+  module Entities
+    # A boolean value
+    #
+    # @attr_reader value [true, false]
+    class Boolean < Entity
+      attr_reader :value
+
+      # @param value [String, Boolean]
+      def initialize(value)
+        super(:boolean)
+        # TODO: probably can do a lot better in general on type validation
+        @value = value.is_a?(::String) ? (value.downcase == 'true') : value
+      end
+
+      # @return [String]
+      def to_s
+        @value.to_s.upcase
+      end
+
+      # @return [boolean]
+      def ==(other)
+        super && value == other.value
+      end
+    end
+  end
+end

data/lib/csv_plus_plus/{language → entities}/builtins.rb

@@ -1,12 +1,10 @@
 # frozen_string_literal: true
 
-require_relative './ast_builder'
-
 module CSVPlusPlus
-  module Language
+  module Entities
     # Provides ASTs for builtin functions and variables
     module Builtins
-      extend ::CSVPlusPlus::Language::ASTBuilder
+      extend ::CSVPlusPlus::Entities::ASTBuilder
 
       VARIABLES = {
         # The number (integer) of the current cell. Starts at 1

data/lib/csv_plus_plus/entities/cell_reference.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require_relative './ast_builder'
+require_relative './entity'
+
+module CSVPlusPlus
+  module Entities
+    # A reference to a cell
+    #
+    # @attr_reader cell_reference [String] The cell reference in A1 format
+    class CellReference < Entity
+      attr_reader :cell_reference
+
+      A1_NOTATION_REGEXP = /(['\w]+!)?\w+:\w+/
+      public_constant :A1_NOTATION_REGEXP
+
+      # Create a +CellReference+ to the given indexes
+      #
+      # @param cell_index [Integer] The current cell index
+      # @param row_index [Integer] The current row index
+      #
+      # @return [CellReference]
+      def self.from_index(cell_index:, row_index:)
+        return unless row_index || cell_index
+
+        # I can't just extend this class due to circular references :(
+        ::Class.new.extend(::CSVPlusPlus::Entities::ASTBuilder).ref(cell_index:, row_index:)
+      end
+
+      # Does the given +cell_reference_string+ conform to a valid cell reference?
+      #
+      # {https://developers.google.com/sheets/api/guides/concepts}
+      #
+      # @param cell_reference_string [::String] The string to check if it is a valid cell reference (we assume it's in
+      #   A1 notation but maybe can support R1C1)
+      #
+      # @return [boolean]
+      def self.valid_cell_reference?(cell_reference_string)
+        !(cell_reference_string =~ ::CSVPlusPlus::Entities::CellReference::A1_NOTATION_REGEXP).nil?
+      end
+
+      # @param cell_reference [String] The cell reference in A1 format
+      def initialize(cell_reference)
+        super(:cell_reference)
+
+        @cell_reference = cell_reference
+      end
+
+      # @return [::String]
+      def to_s
+        @cell_reference
+      end
+
+      # @return [Boolean]
+      def ==(other)
+        super && @cell_reference == other.cell_reference
+      end
+    end
+  end
+end

data/lib/csv_plus_plus/entities/date.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module CSVPlusPlus
+  module Entities
+    # A date value
+    #
+    # @attr_reader value [Date] The parsed date
+    class Date < Entity
+      attr_reader :value
+
+      # TODO: support time?
+      DATE_STRING_REGEXP = %r{^\d{1,2}[/-]\d{1,2}[/-]\d{1,4}?$}
+      public_constant :DATE_STRING_REGEXP
+
+      # Is the given string a valid date?
+      #
+      # @param date_string [::String]
+      def self.valid_date?(date_string)
+        !(date_string.strip =~ ::CSVPlusPlus::Entities::Date::DATE_STRING_REGEXP).nil?
+      end
+
+      # @param value [String] The user-inputted date value
+      def initialize(value)
+        super(:date)
+
+        @value = ::Date.parse(value)
+      end
+    end
+  end
+end

data/lib/csv_plus_plus/entities/entity.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+require_relative '../entities'
+
+module CSVPlusPlus
+  module Entities
+    # A basic building block of the abstract syntax tree (AST)
+    #
+    # @attr_reader id [Symbol] The identifier of the entity.  For functions this is the function name,
+    #   for variables it's the variable name
+    # @attr_reader type [Symbol] The type of the entity.  Valid values are defined in +::CSVPlusPlus::Entities::TYPES+
+    class Entity
+      attr_reader :id, :type
+
+      # @param type [::String, Symbol]
+      # @param id [::String, nil]
+      def initialize(type, id: nil)
+        @type = type.to_sym
+        @id = id.downcase.to_sym if id
+      end
+
+      # @return [boolean]
+      def ==(other)
+        self.class == other.class && @type == other.type && @id == other.id
+      end
+
+      # Respond to predicates that correspond to types like #boolean?, #string?, etc
+      #
+      # @param method_name [Symbol] The +method_name+ to respond to
+      def method_missing(method_name, *_arguments)
+        if method_name =~ /^(\w+)\?$/
+          t = ::Regexp.last_match(1)
+          a_type?(t) && @type == t.to_sym
+        else
+          super
+        end
+      end
+
+      # Respond to predicates by type (entity.boolean?, entity.string?, etc)
+      #
+      # @param method_name [Symbol] The +method_name+ to respond to
+      #
+      # @return [boolean]
+      def respond_to_missing?(method_name, *_arguments)
+        (method_name =~ /^(\w+)\?$/ && a_type?(::Regexp.last_match(1))) || super
+      end
+
+      private
+
+      def a_type?(str)
+        ::CSVPlusPlus::Entities::TYPES.include?(str.to_sym)
+      end
+    end
+
+    # An entity that can take other entities as arguments.  Current use cases for this
+    # are function calls and function definitions
+    #
+    # @attr_reader arguments [Array<Entity>] The arguments supplied to this entity.
+    class EntityWithArguments < Entity
+      attr_reader :arguments
+
+      # @param type [::String, Symbol]
+      # @param id [::String]
+      # @param arguments [Array<Entity>]
+      def initialize(type, id: nil, arguments: [])
+        super(type, id:)
+        @arguments = arguments
+      end
+
+      # @return [boolean]
+      def ==(other)
+        super && @arguments == other.arguments
+      end
+
+      protected
+
+      attr_writer :arguments
+
+      def arguments_to_s
+        @arguments.join(', ')
+      end
+    end
+  end
+end

data/lib/csv_plus_plus/entities/function.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require_relative './entity'
+
+module CSVPlusPlus
+  module Entities
+    # A function definition
+    #
+    # @attr_reader body [Entity] The body of the function.  +body+ can contain variable references
+    # from +@arguments+
+    class Function < EntityWithArguments
+      attr_reader :body
+
+      # @param id [Symbool, String] the name of the function - what it will be callable by
+      # @param arguments [Array<Symbol>]
+      # @param body [Entity]
+      def initialize(id, arguments, body)
+        super(:function, id:, arguments: arguments.map(&:to_sym))
+        @body = body
+      end
+
+      # @return [String]
+      def to_s
+        "def #{@id.to_s.upcase}(#{arguments_to_s}) #{@body}"
+      end
+
+      # @return [boolean]
+      def ==(other)
+        super && @body == other.body
+      end
+    end
+  end
+end

data/lib/csv_plus_plus/entities/function_call.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module CSVPlusPlus
+  module Entities
+    # A function call
+    #
+    # @attr_reader infix [boolean] Whether or not this function call is infix (X * Y, A + B, etc)
+    class FunctionCall < EntityWithArguments
+      attr_reader :infix
+
+      # @param id [String] The name of the function
+      # @param arguments [Array<Entity>] The arguments to the function
+      # @param infix [boolean] Whether the function is infix
+      def initialize(id, arguments, infix: false)
+        super(:function_call, id:, arguments:)
+
+        @infix = infix
+      end
+
+      # @return [String]
+      def to_s
+        if @infix
+          "(#{arguments.join(" #{@id} ")})"
+        else
+          "#{@id.to_s.upcase}(#{arguments_to_s})"
+        end
+      end
+
+      # @return [boolean]
+      def ==(other)
+        super && @id == other.id
+      end
+    end
+  end
+end

data/lib/csv_plus_plus/entities/number.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module CSVPlusPlus
+  module Entities
+    # A number value
+    #
+    # @attr_reader value [Numeric] The parsed number value
+    class Number < Entity
+      attr_reader :value
+
+      # @param value [String, Numeric] Either a +String+ that looks like a number, or an already parsed Numeric
+      def initialize(value)
+        super(:number)
+
+        @value =
+          if value.instance_of?(::String)
+            value.include?('.') ? Float(value) : Integer(value, 10)
+          else
+            value
+          end
+      end
+
+      # @return [String]
+      def to_s
+        @value.to_s
+      end
+
+      # @return [boolean]
+      def ==(other)
+        super && value == other.value
+      end
+    end
+  end
+end

data/lib/csv_plus_plus/entities/runtime_value.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module CSVPlusPlus
+  module Entities
+    # A runtime value. These are values which can be materialized at any point via the +resolve_fn+
+    # which takes an ExecutionContext as a param
+    #
+    # @attr_reader resolve_fn [lambda] A lambda that is called when the runtime value is resolved
+    class RuntimeValue < Entity
+      attr_reader :arguments, :resolve_fn
+
+      # @param resolve_fn [lambda] A lambda that is called when the runtime value is resolved
+      def initialize(resolve_fn, arguments: nil)
+        super(:runtime_value)
+
+        @arguments = arguments
+        @resolve_fn = resolve_fn
+      end
+
+      # @return [String]
+      def to_s
+        '(runtime_value)'
+      end
+    end
+  end
+end

data/lib/csv_plus_plus/entities/string.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module CSVPlusPlus
+  module Entities
+    # A string value
+    #
+    # @attr_reader value [String]
+    class String < Entity
+      attr_reader :value
+
+      # @param value [String] The string that has been parsed out of the template
+      def initialize(value)
+        super(:string)
+
+        @value = value.gsub(/^"|"$/, '')
+      end
+
+      # @return [String]
+      def to_s
+        "\"#{@value}\""
+      end
+
+      # @return [boolean]
+      def ==(other)
+        super && value == other.value
+      end
+    end
+  end
+end

data/lib/csv_plus_plus/entities/variable.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module CSVPlusPlus
+  module Entities
+    # TODO: get rid of this I think - everything will just be References
+    #
+    # A reference to a variable
+    class Variable < Entity
+      # @param id [Symbol] The identifier of the variable
+      def initialize(id)
+        super(:variable, id:)
+      end
+
+      # @return [String]
+      def to_s
+        "$$#{@id}"
+      end
+
+      # @return [boolean]
+      def ==(other)
+        super && id == other.id
+      end
+    end
+  end
+end

data/lib/csv_plus_plus/entities.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require_relative 'entities/boolean'
+require_relative 'entities/cell_reference'
+require_relative 'entities/date'
+require_relative 'entities/entity'
+require_relative 'entities/function'
+require_relative 'entities/function_call'
+require_relative 'entities/number'
+require_relative 'entities/runtime_value'
+require_relative 'entities/string'
+require_relative 'entities/variable'
+
+module CSVPlusPlus
+  module Entities
+    TYPES = {
+      boolean: ::CSVPlusPlus::Entities::Boolean,
+      cell_reference: ::CSVPlusPlus::Entities::CellReference,
+      date: ::CSVPlusPlus::Entities::Date,
+      function: ::CSVPlusPlus::Entities::Function,
+      function_call: ::CSVPlusPlus::Entities::FunctionCall,
+      number: ::CSVPlusPlus::Entities::Number,
+      runtime_value: ::CSVPlusPlus::Entities::RuntimeValue,
+      string: ::CSVPlusPlus::Entities::String,
+      variable: ::CSVPlusPlus::Entities::Variable
+    }.freeze
+
+    public_constant :TYPES
+  end
+end
+
+require_relative 'entities/ast_builder'
+require_relative 'entities/builtins'

data/lib/csv_plus_plus/error/error.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module CSVPlusPlus
+  module Error
+    # An error thrown by our code (generally to be handled at the top level bin/ command)
+    class Error < StandardError
+      # TODO: perhaps give this a better name? something more descriptive than just Error
+    end
+  end
+end

data/lib/csv_plus_plus/error/formula_syntax_error.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require_relative './syntax_error'
+
+module CSVPlusPlus
+  module Error
+    # An error that can be thrown when there is an error parsing a modifier
+    #
+    # @attr_reader message [::String] A helpful error message
+    # @attr_reader bad_input [String] The offending input that caused the error to be thrown
+    class FormulaSyntaxError < ::CSVPlusPlus::Error::SyntaxError
+      attr_reader :message, :bad_input
+
+      # You must supply either a +choices+ or +message+
+      #
+      # @param message [String] A relevant message to show
+      # @param bad_input [String] The offending input that caused the error to be thrown
+      # @param runtime [Runtime] The current runtime
+      # @param wrapped_error [StandardError] The underlying error that caused the syntax error.  For example a
+      #   Racc::ParseError that was thrown
+      def initialize(message, bad_input, runtime, wrapped_error: nil)
+        @bad_input = bad_input
+        @message = message
+
+        super(runtime, wrapped_error:)
+      end
+
+      # Create a relevant error message given +@bad_input+ and +@message+.
+      #
+      # @return [::String]
+      def error_message
+        "#{@message}: \"#{@bad_input}\""
+      end
+    end
+  end
+end