luoma 0.1.0

data/lib/luoma/filter.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+module Luoma
+  class FilterContext
+    attr_reader :token, :render_context, :env
+
+    #: (t_token, RenderContext)
+    def initialize(token, render_context)
+      @token = token
+      @render_context = render_context
+      @env = render_context.env
+    end
+
+    # (String) -> TemplateTypeError
+    def type_error(message)
+      TemplateTypeError.new(
+        message, @token,
+        @render_context.template.source,
+        @render_context.template.name
+      )
+    end
+
+    # (String) -> FilterArgumentError
+    def argument_error(message)
+      FilterArgumentError.new(
+        message, @token,
+        @render_context.template.source,
+        @render_context.template.name
+      )
+    end
+
+    #: (untyped) -> Array[untyped]
+    def to_a(obj)
+      @env.to_a(obj, @render_context)
+    end
+
+    #: (untyped) -> Hash[untyped, untyped]
+    def to_h(obj)
+      @env.to_h(obj, @render_context)
+    end
+
+    #: (untyped) -> Integer
+    def to_i(obj, default: :nothing)
+      @env.to_i(obj, @render_context, default: default)
+    end
+
+    #: (untyped) -> String
+    def to_string(obj)
+      @env.to_string(obj, @render_context)
+    end
+
+    #: [X] (untyped, ?default: X) -> (Numeric | X)
+    def to_numeric(obj, default: :nothing)
+      @env.to_numeric(obj, @render_context, default: default)
+    end
+
+    #: (untyped) -> Enumerable[untyped]
+    def to_enumerable(obj)
+      @env.to_enumerable(obj, @render_context)
+    end
+
+    #: (untyped) -> untyped
+    def to_date(obj)
+      @env.to_date(obj, @render_context)
+    end
+
+    #: (untyped) -> bool
+    def truthy?(obj)
+      @env.truthy?(obj, @render_context)
+    end
+
+    #: (untyped, untyped) -> bool
+    def eq?(obj, other)
+      @env.eq?(obj, other, @render_context, @token)
+    end
+
+    #: (untyped, untyped) -> bool
+    def lt?(obj, other)
+      @env.lt?(obj, other, @render_context, @token)
+    end
+
+    #: (untyped, untyped) -> (-1 | 1 | 0 | nil)
+    def cmp(left, right)
+      @env.cmp(left, right, @render_context, @token)
+    end
+
+    #: (untyped) -> bool
+    def nothing?(obj)
+      @env.nothing?(obj)
+    end
+
+    #: (untyped, untyped, ?default: untyped?) -> untyped
+    def fetch(obj, key, default: :nothing)
+      obj.respond_to?(:[]) && obj.respond_to?(:key?) && key.is_a?(String) && obj.key?(key) ? obj[key] : default
+    end
+  end
+end

data/lib/luoma/filters/array.rb

@@ -0,0 +1,372 @@
+# frozen_string_literal: true
+
+module Luoma
+  module Filters
+    # Return the concatenation of items in _left_ separated by _sep_.
+    # Coerce items in _left_ to strings if they aren't strings already.
+    def self.join(context, left, sep = " ")
+      context.to_enumerable(left).map { |item| context.to_string(item) }.join(context.to_string(sep))
+    end
+
+    # If _left_ is enumerable, return _left_ flattened to _depth_. Otherwise
+    # return _left_.
+    def self.flatten(context, left, depth = nil)
+      left = context.to_enumerable(left)
+
+      context.to_a(left).flatten(
+        depth.nil? ? depth : context.to_numeric(depth, default: 1).to_i # steep:ignore
+      )
+    end
+
+    # Return true if at least one item in _left_ is truthy.
+    def self.any(context, left, key = :nothing, value = :nothing)
+      left = context.to_enumerable(left)
+
+      case key
+      when :nothing
+        left.any? { |i| context.truthy?(i) }
+      when ExpressionDrop
+        key.expr.broadcast_with_index(left).any? { |i| context.truthy?(i) }
+      else
+        key = context.to_string(key)
+        if value == :nothing
+          left.map { |i| context.fetch(i, key) }.any? { |j| context.truthy?(j) }
+        else
+          left.map { |i| context.fetch(i, key) }.any? { |j| context.eq?(j, value) }
+        end
+      end
+    end
+
+    # Return true if all items in _left_ are truthy.
+    def self.all(context, left, key = :nothing, value = :nothing)
+      left = context.to_enumerable(left)
+
+      case key
+      when :nothing
+        left.all? { |i| context.truthy?(i) }
+      when ExpressionDrop
+        key.expr.broadcast_with_index(left).all? { |i| context.truthy?(i) }
+      else
+        key = context.to_string(key)
+        if value == :nothing
+          left.map { |i| context.fetch(i, key) }.all? { |j| context.truthy?(j) }
+        else
+          left.map { |i| context.fetch(i, key) }.all? { |j| context.eq?(j, value) }
+        end
+      end
+    end
+
+    # Return a copy of _left_ with nil items removed.
+    # Coerce _left_ to an array-like object if it is not one already.
+    #
+    # If _key_ is given, assume items in _left_ are hash-like and remove items from _left_
+    # where `item.fetch(key, nil)` is nil.
+    #
+    # If key is not `:nothing`, coerce it to a string before calling `fetch` on items in
+    # _left_.
+    def self.compact(context, left, key = :nothing)
+      left = context.to_enumerable(left)
+
+      case key
+      when :nothing
+        left.reject { |value| value.nil? || context.nothing?(value) }
+      when ExpressionDrop
+        left.each_with_index.reject do |item, index|
+          value = key.expr.call_with_index(item, index)
+          value.nil? || context.nothing?(value)
+        end.map(&:first)
+      else
+        left.reject do |item|
+          value = context.fetch(item, key)
+          value.nil? || context.nothing?(value)
+        end
+      end
+    end
+
+    # Return _left_ concatenated with _right_.
+    # Coerce _left_ and _right_ to an array if they aren't arrays already.
+    def self.concat(context, left, right)
+      context.to_a(left).concat(context.to_a(right))
+    end
+
+    # Return the first item in _left_ where _key_ is equal to _value_, or nil
+    # if no such item exists.
+    #
+    # If _value_ is not given, return the first item where _key_ is truthy.
+    #
+    # If _key_ is a Lambda expression, evaluate the expression for each item in
+    # _left_ and return the first item where the expression results in a truthy
+    # value, ignoring _value_.
+    def self.find(context, left, key, value = :nothing)
+      left = context.to_enumerable(left)
+
+      if key.is_a?(ExpressionDrop)
+        key.expr.broadcast_with_index(left).zip(left) do |r, i|
+          return i if context.truthy?(r)
+        end
+      elsif value == :nothing
+        key_ = context.to_string(key)
+        left.each do |item|
+          return item if context.truthy?(context.fetch(item, key_)) || context.eq?(item, key)
+        end
+      else
+        key = context.to_string(key)
+        left.each do |item|
+          return item if context.eq?(context.fetch(item, key), value) || context.eq?(item, value)
+        end
+      end
+
+      nil
+    end
+
+    # Return the index of the first item in _left_ where _key_ is equal to
+    # _value_, or nil if no such item exists.
+    #
+    # If _value_ is not given, return the index of the first item where _key_
+    # is truthy.
+    #
+    # If _key_ is a Lambda expression, evaluate the expression for each item in
+    # _left_ and return the index of the  first item where the expression
+    # results in a truthy value, ignoring _value_.
+    def self.find_index(context, left, key, value = :nothing)
+      left = context.to_enumerable(left)
+
+      if key.is_a?(ExpressionDrop)
+        key.expr.broadcast_with_index(left).each_with_index do |item, index|
+          return index if context.truthy?(item)
+        end
+      elsif value == :nothing
+        key_ = context.to_string(key)
+        left.each_with_index do |item, index|
+          return index if context.truthy?(context.fetch(item, key_)) || context.eq?(item, key)
+        end
+      else
+        key = context.to_string(key)
+        left.each_with_index do |item, index|
+          return index if context.eq?(context.fetch(item, key), value) || context.eq?(item, value)
+        end
+      end
+
+      nil
+    end
+
+    # Return the first item in _left_, or `:nothing` if _left_ does not have a
+    # first item.
+    #
+    # Coerce _left_ to an array if it is not a string, hash or array.
+    def self.first(context, left)
+      case left
+      when String
+        left.empty? ? :nothing : left[0]
+      when Hash, Array
+        left.empty? ? :nothing : left.first
+      else
+        left_ = context.to_a(left)
+        left_.empty? ? :nothing : left_.first
+      end
+    end
+
+    # Return the last item in _left_, or `:nothing` if _left_ does not have a
+    # last item.
+    #
+    # Coerce _left_ to an array if it is not a string or array.
+    def self.last(context, left)
+      case left
+      when String
+        left.empty? ? :nothing : left[-1]
+      when Array
+        left.empty? ? :nothing : left.last
+      else
+        left_ = context.to_a(left)
+        left_.empty? ? :nothing : left_.last
+      end
+    end
+
+    def self.map(context, left, key)
+      left = context.to_enumerable(left)
+
+      if key.is_a?(ExpressionDrop)
+        key.expr.broadcast_with_index(left)
+      else
+        key = context.to_string(key)
+        left.map { |item| context.fetch(item, key) }
+      end
+    end
+
+    def self.flat_map(context, left, key)
+      left = context.to_enumerable(left)
+
+      if key.is_a?(ExpressionDrop)
+        key.expr.broadcast_with_index(left).flatten!(1)
+      else
+        key = context.to_string(key)
+        left.flat_map { |item| context.fetch(item, key) }
+      end
+    end
+
+    # Return _left_ with all items in reverse order.
+    # Coerce _left_ to an array if it isn't an array already.
+    def self.reverse(context, left)
+      context.to_a(left).reverse
+    end
+
+    def self.reject(context, left, key, value = :nothing)
+      left = context.to_enumerable(left)
+
+      if key.is_a?(ExpressionDrop)
+        left.each_with_index.reject do |item, index|
+          context.truthy?(key.expr.call_with_index(item, index))
+        end.map(&:first)
+      elsif value == :nothing
+        key_ = context.to_string(key)
+        left.reject do |item|
+          context.truthy?(context.fetch(item, key_)) || context.eq?(item, key)
+        end
+      else
+        key = context.to_string(key)
+        left.reject do |item|
+          context.eq?(context.fetch(item, key), value) || context.eq?(item, value)
+        end
+      end
+    end
+
+    def self.where(context, left, key, value = :nothing)
+      left = context.to_enumerable(left)
+
+      if key.is_a?(ExpressionDrop)
+        left.each_with_index.filter do |item, index|
+          context.truthy?(key.expr.call_with_index(item, index))
+        end.map(&:first)
+      elsif value == :nothing
+        key_ = context.to_string(key)
+        left.filter do |item|
+          context.truthy?(context.fetch(item, key_)) || context.eq?(item, key)
+        end
+      else
+        key = context.to_string(key)
+        left.filter do |item|
+          context.eq?(context.fetch(item, key), value) || context.eq?(item, value)
+        end
+      end
+    end
+
+    # Deduplicate items in _left_.
+    # Coerce _left_ to an array if it isn't an array already.
+    def self.uniq(context, left, key = :nothing)
+      left = context.to_a(left)
+
+      # Like Array#uniq but using our own comparator, context#eq?.
+      # @type var uniq_: ^(Array[untyped]) ?{ (untyped, Integer) -> untyped } -> Array[untyped]
+      uniq_ = lambda do |array, &key|
+        decorated = [] #: Array[untyped]
+        result = [] #: Array[untyped]
+
+        array.each_with_index do |item, index|
+          value = key ? key.call(item, index) : item
+
+          unless decorated.any? { |existing| context.eq?(existing, value) }
+            decorated << value
+            result << item
+          end
+        end
+
+        result
+      end
+
+      if key == :nothing
+        uniq_.call(left)
+      elsif key.is_a?(ExpressionDrop)
+        uniq_.call(left) { |item, index| key.expr.call_with_index(item, index) }
+      else
+        key = context.to_string(key)
+        uniq_.call(left) { |item, _index| context.fetch(item, key) }
+      end
+    end
+
+    # Return the sum of all numeric values in the input array.
+    def self.sum(context, left, key = :nothing)
+      left = context.to_enumerable(left)
+
+      if key == :nothing
+        left.sum { |v| context.to_numeric(v, default: 0) }
+      elsif key.is_a?(ExpressionDrop)
+        key.expr.broadcast_with_index(left).sum { |v| context.to_numeric(v, default: 0) }
+      else
+        key = context.to_string(key)
+        left.sum { |v| context.to_numeric(context.fetch(v, key, default: 0)) }
+      end
+    end
+
+    # Combine _left_ with _right_, producing an array or pairs.
+    # Coerce _left_ and _right_ to arrays if they aren't arrays already.
+    def self.zip(context, left, right)
+      context.to_a(left).zip(context.to_a(right))
+    end
+
+    # Return the minimum numeric value found in _left_.
+    # Coerce _left_ to an array if it's not an array already.
+    def self.min(context, left, key = :nothing)
+      left = context.to_enumerable(left)
+
+      # @type var min_: ^(Enumerable[untyped]) ?{ (untyped, Integer) -> untyped } -> untyped
+      min_ = lambda do |enum, &key|
+        best_item = nil #:untyped
+        best_value = nil #: Numeric?
+
+        enum.each_with_index do |item, index|
+          value = context.to_numeric(key ? key.call(item, index) : item, default: nil)
+          next if value.nil?
+
+          if best_value.nil? || context.lt?(value, best_value)
+            best_item = item
+            best_value = value
+          end
+        end
+
+        best_item
+      end
+
+      if key == :nothing
+        min_.call(left)
+      elsif key.is_a?(ExpressionDrop)
+        min_.call(left) { |item, index| key.expr.call_with_index(item, index) }
+      else
+        key = context.to_string(key)
+        min_.call(left) { |item, _index| context.fetch(item, key, default: nil) }
+      end
+    end
+
+    # Return the maximum numeric value found in _left_.
+    # Coerce _left_ to an array if it's not an array already.
+    def self.max(context, left, key = :nothing)
+      left = context.to_enumerable(left)
+
+      # @type var max_: ^(Enumerable[untyped]) ?{ (Integer, untyped) -> untyped } -> untyped
+      max_ = lambda do |enum, &key|
+        best_item = nil # untyped
+        best_value = nil #: Numeric?
+
+        enum.each_with_index do |item, index|
+          value = context.to_numeric(key ? key.call(item, index) : item, default: nil)
+          next if value.nil?
+
+          if best_value.nil? || context.lt?(best_value, value)
+            best_item = item
+            best_value = value
+          end
+        end
+
+        best_item
+      end
+
+      if key == :nothing
+        max_.call(left)
+      elsif key.is_a?(ExpressionDrop)
+        max_.call(left) { |item, index| key.expr.call_with_index(item, index) }
+      else
+        key = context.to_string(key)
+        max_.call(left) { |item, _index| context.fetch(item, key, default: nil) }
+      end
+    end
+  end
+end

data/lib/luoma/filters/date.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Luoma
+  module Filters
+    # Format date and time object _left_ with _format_.
+    # Coerce _left_ to a `Time` if it is not a time-like object already.
+    # Coerce _format_ to a string if it is not a string already.
+    def self.date(context, left, format)
+      format = context.to_string(format)
+      return left if format.empty?
+
+      if (date = context.to_date(left))
+        date.strftime(format)
+      else
+        left
+      end
+    end
+  end
+end

data/lib/luoma/filters/default.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Luoma
+  module Filters
+    # Return _left_, or _default_ if _obj_ is `nil`, `false` or empty.
+    # If _allow_false_ is `true`, _left_ is returned if _left_ is `false`.
+    def self.default(context, left, default = "", allow_false: false)
+      return default if left.is_a?(FalsyStrictUndefinedDrop)
+
+      left_ = left.is_a?(Drop) ? left.to_primitive(:boolean, context.render_context) : left
+      return left_ if allow_false && left_ == false
+
+      !context.truthy?(left_) || Luoma::Predicates.empty?(context.render_context, left_) ? default : left_
+    end
+  end
+end

data/lib/luoma/filters/json.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Luoma
+  module Filters
+    # Return _left_ serialized in JSON format.
+    def self.json(context, left, pretty: false)
+      if pretty
+        JSON.pretty_generate(left)
+      else
+        JSON.generate(left)
+      end
+    end
+  end
+end

data/lib/luoma/filters/math.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module Luoma
+  module Filters
+    # Return the absolute value of `left`.
+    def self.abs(context, left)
+      left_ = context.to_numeric(left)
+      context.nothing?(left_) ? left_ : left_.abs
+    end
+
+    # Return the maximum of `left` and `right`.
+    def self.at_least(context, left, right)
+      [context.to_numeric(left, default: nil), context.to_numeric(right, default: nil)].compact.max || :nothing
+    end
+
+    # Return the minimum of `left` and `right`.
+    def self.at_most(context, left, right)
+      [context.to_numeric(left, default: nil), context.to_numeric(right, default: nil)].compact.min || :nothing
+    end
+
+    # Return `left` rounded up to the next whole number.
+    def self.ceil(context, left)
+      left_ = context.to_numeric(left)
+      context.nothing?(left_) ? left_ : left_.ceil
+    end
+
+    # Return the result of dividing `left` by `right`.
+    # If both `left` and `right` are integers, integer division is performed.
+    def self.divided_by(context, left, right)
+      lhs = context.to_numeric(left, default: :nothing)
+      rhs = context.to_numeric(right, default: :nothing)
+      return :nothing if context.nothing?(lhs) || context.nothing?(rhs) || rhs.zero? # steep:ignore
+
+      result = lhs.to_d / rhs # steep:ignore
+      result.frac.zero? && lhs.is_a?(::Integer) && rhs.is_a?(::Integer) ? result.to_i : result
+    end
+
+    # Return the result of multiplying `left` by `right`.
+    def self.times(context, left, right)
+      lhs = context.to_numeric(left, default: :nothing)
+      rhs = context.to_numeric(right, default: :nothing)
+      context.nothing?(lhs) || context.nothing?(rhs) ? :nothing : lhs * rhs # steep:ignore
+    end
+
+    # Return `left` rounded down to the next whole number.
+    def self.floor(context, left)
+      left_ = context.to_numeric(left)
+      context.nothing?(left_) ? left_ : left_.floor
+    end
+
+    # Return `right` subtracted from `left`.
+    def self.minus(context, left, right)
+      lhs = context.to_numeric(left, default: :nothing)
+      rhs = context.to_numeric(right, default: :nothing)
+      context.nothing?(lhs) || context.nothing?(rhs) ? :nothing : lhs - rhs # steep:ignore
+    end
+
+    # Return the remainder of dividing `left` by `right`.
+    def self.modulo(context, left, right)
+      lhs = context.to_numeric(left, default: :nothing)
+      rhs = context.to_numeric(right, default: :nothing)
+      return :nothing if context.nothing?(lhs) || context.nothing?(rhs) || rhs.zero? # steep:ignore
+
+      result = lhs.to_d % rhs # steep:ignore
+      result.frac.zero? && lhs.is_a?(::Integer) && rhs.is_a?(::Integer) ? result.to_i : result
+    end
+
+    # Return `right` added to `left`.
+    def self.plus(context, left, right)
+      lhs = context.to_numeric(left, default: :nothing)
+      rhs = context.to_numeric(right, default: :nothing)
+      context.nothing?(lhs) || context.nothing?(rhs) ? :nothing : lhs + rhs # steep:ignore
+    end
+
+    # Return `left` rounded to _ndigits_ decimal digits.
+    def self.round(context, left, ndigits = 0)
+      left_ = context.to_numeric(left)
+      return left_ if context.nothing?(left_)
+      return left_.round if ndigits == 0 # rubocop:disable Style/NumericPredicate
+
+      left_.round(context.to_i(ndigits, default: 0))
+    end
+  end
+end

data/lib/luoma/filters/size.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Luoma
+  module Filters
+    # Return the size of _left_, or zero if _left_ has no size.
+    def self.size(context, left)
+      return left.length(context.render_context) if left.is_a?(Drop)
+      return left.size if left.respond_to?(:size)
+
+      0
+    end
+  end
+end

data/lib/luoma/filters/slice.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Luoma
+  module Filters
+    def self.slice(
+      context,
+      left,
+      start_ = :nothing, stop_ = :nothing, step_ = :nothing,
+      start: :nothing, stop: :nothing, step: :nothing
+    )
+      left = context.to_a(left) unless left.is_a?(String) || left.is_a?(Drop)
+      length = left.is_a?(Drop) ? left.length(context.render_context) : left.length
+
+      # Give priority to keyword arguments, default to nil if neither are given.
+      start = start_ == :nothing ? nil : start_ if start == :nothing
+      stop = stop_ == :nothing ? nil : stop_ if stop == :nothing
+      step = step_ == :nothing ? nil : step_ if step == :nothing
+      step = context.to_i(step || 1, default: 0)
+
+      return [] if length.zero? || step.zero?
+
+      start = context.to_i(start, default: 0) unless start.nil?
+      stop = context.to_i(stop, default: 0) unless stop.nil?
+
+      normalized_start = if start.nil?
+                           step.negative? ? length - 1 : 0
+                         elsif start&.negative?
+                           [length + start, 0].max
+                         else
+                           [start, length - 1].min
+                         end
+
+      normalized_stop = if stop.nil?
+                          step.negative? ? -1 : length
+                        elsif stop&.negative?
+                          [length + stop, -1].max
+                        else
+                          [stop, length].min
+                        end
+
+      if left.is_a?(Drop)
+        left.slice(normalized_start, normalized_stop, step)
+      else
+        # This does not work for strings.
+        # left[(normalized_start...normalized_stop).step(step)]
+        #
+        # But this does.
+        (normalized_start...normalized_stop).step(step).map { |i| left[i] }
+      end
+    end
+  end
+end