trifle-stats 2.4.1 → 2.5.0

data/lib/trifle/stats/transponder/expression.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+module Trifle
+  module Stats
+    class Transponder
+      class Expression
+        include Trifle::Stats::Mixins::Packer
+        Trifle::Stats::Series.register_transponder(:expression, self)
+
+        def transpond(series:, paths:, expression:, response:)
+          normalized_paths, normalized_response = normalized_config(paths, response)
+          ast = ExpressionEngine.parse(expression: expression, paths: normalized_paths)
+          series[:values] = transformed_values(series[:values], normalized_paths, normalized_response, ast)
+          series
+        end
+
+        def validate(paths:, expression:, response:)
+          normalized_paths, = normalized_config(paths, response)
+          ExpressionEngine.validate(paths: normalized_paths, expression: expression)
+        end
+
+        private
+
+        def normalized_config(paths, response)
+          normalized_paths = normalize_paths(paths)
+          normalized_response = normalize_response(response)
+
+          ensure_no_wildcards!(normalized_paths, normalized_response)
+          [normalized_paths, normalized_response]
+        end
+
+        def normalize_paths(paths)
+          raise ArgumentError, 'Paths must be an array.' unless paths.is_a?(Array)
+
+          cleaned = paths.map { |path| path.to_s.strip }.reject(&:empty?)
+          raise ArgumentError, 'At least one path is required.' if cleaned.empty?
+
+          cleaned
+        end
+
+        def normalize_response(response)
+          normalized_response = response.to_s.strip
+          ensure_response!(normalized_response)
+          normalized_response
+        end
+
+        def ensure_response!(response)
+          raise ArgumentError, 'Response path is required.' if response.empty?
+        end
+
+        def ensure_no_wildcards!(paths, response)
+          wildcard = paths.any? { |path| path.include?('*') } || response.include?('*')
+          raise ArgumentError, 'Wildcard paths are not supported yet.' if wildcard
+        end
+
+        def build_env(data, paths)
+          ExpressionEngine.allowed_vars(paths.length).zip(paths).to_h do |var, path|
+            [var, data.dig(*path.split('.'))]
+          end
+        end
+
+        def transformed_values(values, paths, response, ast)
+          values.map { |data| transform_row(data, paths, response, ast) }
+        end
+
+        def transform_row(data, paths, response, ast)
+          env = build_env(data, paths)
+          value = ExpressionEngine.evaluate(ast: ast, env: env)
+          put_response(data, response, value)
+        end
+
+        def put_response(data, response, value)
+          keys = response.split('.')
+          raise ArgumentError, "Cannot write to response path #{response}." unless can_create_path?(data, keys)
+
+          updated = deep_dup(data)
+          target = updated
+
+          keys[0..-2].each do |key|
+            target[key] ||= {}
+            target = target[key]
+          end
+
+          target[keys[-1]] = value
+          updated
+        end
+
+        def can_create_path?(data, keys)
+          return true if keys.length <= 1
+
+          current = data
+
+          keys[0..-2].each do |key|
+            value = current[key]
+            return true if value.nil?
+            return false unless value.is_a?(Hash)
+
+            current = value
+          end
+
+          true
+        end
+
+        def deep_dup(value)
+          case value
+          when Hash
+            value.transform_values { |inner| deep_dup(inner) }
+          when Array
+            value.map { |inner| deep_dup(inner) }
+          else
+            value
+          end
+        end
+      end
+    end
+  end
+end

data/lib/trifle/stats/transponder/expression_engine.rb

@@ -0,0 +1,356 @@
+# frozen_string_literal: true
+
+require 'bigdecimal'
+
+module Trifle
+  module Stats
+    class Transponder
+      class ExpressionEngine
+        LETTERS = ('a'..'z').to_a.freeze
+        TOKEN_OPERATORS = %w[+ - * / ( ) ,].freeze
+        NUMBER_PATTERN = /\A\d+(?:\.\d+)?/.freeze
+        IDENT_PATTERN = /\A[A-Za-z_][A-Za-z0-9_]*/.freeze
+
+        class << self
+          def max_vars
+            LETTERS.length
+          end
+
+          def allowed_vars(count)
+            LETTERS.take(count)
+          end
+
+          def validate(paths:, expression:)
+            normalized_paths = normalize_paths(paths)
+            parse(expression: expression, paths: normalized_paths)
+            true
+          end
+
+          def parse(expression:, paths:)
+            normalized_paths = normalize_paths(paths)
+            ensure_within_var_limit(normalized_paths)
+            tokens = tokenize(expression.to_s)
+            parser = Parser.new(tokens, allowed_vars(normalized_paths.length))
+            ast = parser.parse
+            raise ArgumentError, 'Unexpected token sequence.' unless parser.done?
+
+            ast
+          end
+
+          def evaluate(ast:, env:)
+            Evaluator.new(env).evaluate(ast)
+          end
+
+          private
+
+          def normalize_paths(paths)
+            raise ArgumentError, 'Paths must be an array.' unless paths.is_a?(Array)
+
+            cleaned = paths.map { |path| path.to_s.strip }.reject(&:empty?)
+            raise ArgumentError, 'At least one path is required.' if cleaned.empty?
+
+            cleaned
+          end
+
+          def ensure_within_var_limit(paths)
+            return if paths.length <= max_vars
+
+            raise ArgumentError, "Too many paths. Maximum supported is #{max_vars}."
+          end
+
+          def tokenize(expression)
+            trimmed = normalize_expression_text(expression)
+            tokens = []
+            index = 0
+
+            while index < trimmed.length
+              token, consumed = read_token(trimmed, index)
+              tokens << token unless token.nil?
+              index += consumed
+            end
+
+            tokens
+          end
+
+          def normalize_expression_text(expression)
+            trimmed = expression.to_s.strip
+            raise ArgumentError, 'Expression must be text.' if trimmed.empty?
+
+            trimmed
+          end
+
+          def read_token(source, index)
+            char = source[index]
+
+            return [nil, 1] if whitespace?(char)
+            return [char, 1] if operator?(char)
+            return number_token(source, index) if digit?(char)
+            return ident_token(source, index) if identifier_start?(char)
+
+            raise_invalid_token(index)
+          end
+
+          def whitespace?(char)
+            char.match?(/\s/)
+          end
+
+          def operator?(char)
+            TOKEN_OPERATORS.include?(char)
+          end
+
+          def digit?(char)
+            char.match?(/\d/)
+          end
+
+          def identifier_start?(char)
+            char.match?(/[A-Za-z_]/)
+          end
+
+          def number_token(source, index)
+            match = source[index..].match(NUMBER_PATTERN)
+            raise_invalid_token(index) unless match
+
+            [[:number, BigDecimal(match[0])], match[0].length]
+          end
+
+          def ident_token(source, index)
+            match = source[index..].match(IDENT_PATTERN)
+            raise_invalid_token(index) unless match
+
+            [[:ident, match[0]], match[0].length]
+          end
+
+          def raise_invalid_token(index)
+            raise ArgumentError, "Invalid token at position #{index}."
+          end
+        end
+
+        class Parser
+          def initialize(tokens, vars)
+            @tokens = tokens
+            @vars = vars
+            @index = 0
+          end
+
+          def parse
+            parse_expression
+          end
+
+          def done?
+            current.nil?
+          end
+
+          private
+
+          def parse_expression
+            node = parse_term
+
+            while %w[+ -].include?(current)
+              op = consume
+              node = [op.to_sym, node, parse_term]
+            end
+
+            node
+          end
+
+          def parse_term
+            node = parse_factor
+
+            while %w[* /].include?(current)
+              op = consume
+              node = [op.to_sym, node, parse_factor]
+            end
+
+            node
+          end
+
+          def parse_factor
+            return parse_unary_factor if %w[+ -].include?(current)
+            return parse_grouped_expression if current == '('
+
+            parse_primary
+          end
+
+          def parse_primary
+            token = current
+            raise ArgumentError, 'Unexpected end of expression.' if token.nil?
+
+            return parse_number(token) if number_token?(token)
+            return parse_identifier(token) if ident_token?(token)
+
+            raise ArgumentError, "Unexpected token #{token.inspect}."
+          end
+
+          def parse_args
+            return [] if current == ')'
+
+            args = [parse_expression]
+
+            while current == ','
+              consume
+              args << parse_expression
+            end
+
+            args
+          end
+
+          def current
+            @tokens[@index]
+          end
+
+          def consume
+            token = current
+            @index += 1
+            token
+          end
+
+          def parse_unary_factor
+            operator = consume
+            node = parse_factor
+            operator == '-' ? [:neg, node] : node
+          end
+
+          def parse_grouped_expression
+            consume
+            node = parse_expression
+            expect_token!(')', 'Missing closing parenthesis.')
+            consume
+            node
+          end
+
+          def parse_number(token)
+            consume
+            [:number, token[1]]
+          end
+
+          def parse_identifier(token)
+            consume
+            ident = token[1]
+            return parse_function_call(ident) if current == '('
+
+            validate_variable!(ident)
+            [:var, ident]
+          end
+
+          def parse_function_call(ident)
+            consume
+            args = parse_args
+            expect_token!(')', 'Missing closing parenthesis.')
+            consume
+            [:func, ident, args]
+          end
+
+          def validate_variable!(ident)
+            raise ArgumentError, "Unknown variable #{ident}." unless @vars.include?(ident)
+          end
+
+          def number_token?(token)
+            token.is_a?(Array) && token[0] == :number
+          end
+
+          def ident_token?(token)
+            token.is_a?(Array) && token[0] == :ident
+          end
+
+          def expect_token!(expected, message)
+            raise ArgumentError, message unless current == expected
+          end
+        end
+
+        class Evaluator
+          ZERO = BigDecimal('0')
+          AVERAGE = lambda do |args|
+            args.reduce(ZERO, :+) / BigDecimal(args.length.to_s)
+          end
+          BINARY_OPERATIONS = {
+            :+ => ->(left, right) { left + right },
+            :- => ->(left, right) { left - right },
+            :* => ->(left, right) { left * right },
+            :/ => ->(left, right) { right.zero? ? nil : left / right }
+          }.freeze
+          FUNCTIONS = {
+            'sum' => ->(args) { args.reduce(ZERO, :+) },
+            'mean' => AVERAGE,
+            'avg' => AVERAGE,
+            'min' => :min.to_proc,
+            'max' => :max.to_proc
+          }.freeze
+
+          def initialize(env)
+            @env = env || {}
+          end
+
+          def evaluate(node)
+            type, *rest = node
+            return rest[0] if type == :number
+            return evaluate_variable(rest[0]) if type == :var
+            return evaluate_negation(rest[0]) if type == :neg
+            return evaluate_binary(type, rest[0], rest[1]) if BINARY_OPERATIONS.key?(type)
+            return evaluate_function(rest[0], rest[1]) if type == :func
+
+            raise ArgumentError, "Unknown AST node #{type.inspect}."
+          end
+
+          private
+
+          def normalize_value(value)
+            return nil if value.nil?
+            return value if value.is_a?(BigDecimal)
+            return BigDecimal(value.to_s) if value.is_a?(Numeric)
+
+            nil
+          rescue ArgumentError
+            nil
+          end
+
+          def evaluate_variable(name)
+            normalize_value(@env[name])
+          end
+
+          def evaluate_negation(node)
+            value = evaluate(node)
+            value.nil? ? nil : -value
+          end
+
+          def evaluate_binary(operator, left_node, right_node)
+            left = evaluate(left_node)
+            right = evaluate(right_node)
+            apply_binary(operator, left, right)
+          end
+
+          def evaluate_function(name, arg_nodes)
+            args = arg_nodes.map { |arg| evaluate(arg) }
+            apply_function(name, args)
+          end
+
+          def apply_binary(operator, left, right)
+            return nil if left.nil? || right.nil?
+
+            operation = BINARY_OPERATIONS[operator]
+            raise ArgumentError, "Unknown binary operator #{operator.inspect}." unless operation
+
+            operation.call(left, right)
+          end
+
+          def apply_function(name, args)
+            return nil if args.empty? || args.any?(&:nil?)
+
+            return apply_sqrt(args) if name == 'sqrt'
+
+            function = FUNCTIONS[name]
+            raise ArgumentError, "Unknown function #{name}." unless function
+
+            function.call(args)
+          end
+
+          def apply_sqrt(args)
+            raise ArgumentError, 'Function sqrt expects 1 argument.' unless args.length == 1
+            return nil if args[0].negative?
+
+            BigDecimal(Math.sqrt(args[0].to_f).to_s)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/trifle/stats/version.rb

@@ -2,6 +2,6 @@
 
 module Trifle
   module Stats
-    VERSION = '2.4.1'
+    VERSION = '2.5.0'
   end
 end

data/lib/trifle/stats.rb

@@ -28,16 +28,8 @@ require 'trifle/stats/operations/timeseries/set'
 require 'trifle/stats/operations/timeseries/values'
 require 'trifle/stats/operations/status/beam'
 require 'trifle/stats/operations/status/scan'
-require 'trifle/stats/transponder/add'
-require 'trifle/stats/transponder/divide'
-require 'trifle/stats/transponder/max'
-require 'trifle/stats/transponder/mean'
-require 'trifle/stats/transponder/min'
-require 'trifle/stats/transponder/multiply'
-require 'trifle/stats/transponder/ratio'
-require 'trifle/stats/transponder/standard_deviation'
-require 'trifle/stats/transponder/subtract'
-require 'trifle/stats/transponder/sum'
+require 'trifle/stats/transponder/expression_engine'
+require 'trifle/stats/transponder/expression'
 require 'trifle/stats/version'
 
 module Trifle

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: trifle-stats
 version: !ruby/object:Gem::Version
-  version: 2.4.1
+  version: 2.5.0
 platform: ruby
 authors:
 - Jozef Vaclavik
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-02-25 00:00:00.000000000 Z
+date: 2026-07-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -238,23 +238,14 @@ files:
 - lib/trifle/stats/nocturnal.rb
 - lib/trifle/stats/nocturnal/key.rb
 - lib/trifle/stats/nocturnal/parser.rb
-- lib/trifle/stats/nocturnal_legacy.rb
 - lib/trifle/stats/operations/status/beam.rb
 - lib/trifle/stats/operations/status/scan.rb
 - lib/trifle/stats/operations/timeseries/increment.rb
 - lib/trifle/stats/operations/timeseries/set.rb
 - lib/trifle/stats/operations/timeseries/values.rb
 - lib/trifle/stats/series.rb
-- lib/trifle/stats/transponder/add.rb
-- lib/trifle/stats/transponder/divide.rb
-- lib/trifle/stats/transponder/max.rb
-- lib/trifle/stats/transponder/mean.rb
-- lib/trifle/stats/transponder/min.rb
-- lib/trifle/stats/transponder/multiply.rb
-- lib/trifle/stats/transponder/ratio.rb
-- lib/trifle/stats/transponder/standard_deviation.rb
-- lib/trifle/stats/transponder/subtract.rb
-- lib/trifle/stats/transponder/sum.rb
+- lib/trifle/stats/transponder/expression.rb
+- lib/trifle/stats/transponder/expression_engine.rb
 - lib/trifle/stats/version.rb
 - trifle-stats.gemspec
 homepage: https://trifle.io

data/lib/trifle/stats/nocturnal_legacy.rb

@@ -1,161 +0,0 @@
-# frozen_string_literal: true
-
-module Trifle
-  module Stats
-    class Nocturnal # rubocop:disable Metrics/ClassLength
-      UNIT_MAP = {
-        's' => :second,
-        'm' => :minute,
-        'h' => :hour,
-        'd' => :day,
-        'w' => :week,
-        'mo' => :month,
-        'q' => :quarter,
-        'y' => :year
-      }.freeze
-
-      DAYS_INTO_WEEK = {
-        sunday: 0, monday: 1, tuesday: 2, wednesday: 3,
-        thursday: 4, friday: 5, saturday: 6
-      }.freeze
-
-      def self.timeline(from:, to:, granularity:, config: nil)
-        list = []
-        from = new(from, config: config).send(granularity)
-        to = new(to, config: config).send(granularity)
-        item = from.dup
-        while item <= to
-          list << item
-          item = Nocturnal.new(item, config: config).send("next_#{granularity}")
-        end
-        list
-      end
-
-      def initialize(at, config: nil)
-        @at = at
-        @config = config
-      end
-
-      def config
-        @config || Trifle::Stats.default
-      end
-
-      def change(**fractions)
-        Time.new(
-          fractions.fetch(:year, @at.year),
-          fractions.fetch(:month, @at.month),
-          fractions.fetch(:day, @at.day),
-          fractions.fetch(:hour, @at.hour),
-          fractions.fetch(:minute, @at.min),
-          fractions.fetch(:second, 0),
-          config.tz.utc_offset
-        )
-      end
-
-      def second
-        change(second: @at.sec)
-      end
-
-      def next_second
-        Nocturnal.new(
-          second + 1,
-          config: config
-        ).second
-      end
-
-      def minute
-        change(second: 0)
-      end
-
-      def next_minute
-        Nocturnal.new(
-          minute + 60,
-          config: config
-        ).minute
-      end
-
-      def hour
-        change(minute: 0)
-      end
-
-      def next_hour
-        Nocturnal.new(
-          hour + 60 * 60,
-          config: config
-        ).hour
-      end
-
-      def day
-        change(hour: 0, minute: 0)
-      end
-
-      def next_day
-        Nocturnal.new(
-          day + 60 * 60 * 24,
-          config: config
-        ).day
-      end
-
-      def week
-        today = day
-
-        (today.to_date - days_to_week_start).to_time
-      end
-
-      def next_week
-        Nocturnal.new(
-          week + 60 * 60 * 24 * 7,
-          config: config
-        ).week
-      end
-
-      def days_to_week_start
-        start_day_number = DAYS_INTO_WEEK.fetch(
-          config.beginning_of_week
-        )
-
-        (@at.wday - start_day_number) % 7
-      end
-
-      def month
-        change(day: 1, hour: 0, minute: 0)
-      end
-
-      def next_month
-        Nocturnal.new(
-          month + 60 * 60 * 24 * 31,
-          config: config
-        ).month
-      end
-
-      def quarter
-        first_quarter_month = @at.month - (2 + @at.month) % 3
-
-        change(
-          month: first_quarter_month,
-          day: 1,
-          hour: 0,
-          minute: 0
-        )
-      end
-
-      def next_quarter
-        Nocturnal.new(
-          quarter + 60 * 60 * 24 * 31 * 3,
-          config: config
-        ).quarter
-      end
-
-      def year
-        change(month: 1, day: 1, hour: 0, minute: 0)
-      end
-
-      def next_year
-        Nocturnal.new(
-          year + 60 * 60 * 24 * 31 * 12,
-          config: config
-        ).year
-      end
-    end
-  end
-end