liquid2 0.1.0

data/lib/liquid2/filter.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+require "bigdecimal"
+require "time"
+
+module Liquid2
+  # Liquid filters and helper methods.
+  module Filters
+    # Cast _obj_ to an enumerable for use in a Liquid filter.
+    # @param obj [Object]
+    # @return [Enumerable]
+    def self.to_enumerable(obj)
+      case obj
+      when Array
+        obj.flatten
+      when Hash, String
+        [obj]
+      # when String
+      #   obj.each_char
+      when Enumerable
+        obj
+      else
+        obj.respond_to?(:each) ? obj.each : [obj]
+      end
+    end
+
+    # Cast _obj_ to a number.
+    def self.to_number(obj, default: 0)
+      case obj
+      when String
+        # Cast to float before integer as `to_f` will parse exponents, `to_i` will not.
+        # Use `Float(obj)` instead of `obj.to_f` because `to_f` ignores trailing non-digit chars.
+        obj.match?(/\A-?\d+(?:[eE]\+?\d+)?\Z/) ? obj.to_f.to_i : Float(obj)
+      when Float, Integer, BigDecimal, Numeric
+        # Numeric is the base class for heap allocated numbers.
+        obj
+      else
+        default
+      end
+    rescue ArgumentError
+      default
+    end
+
+    # Case _obj_ to an Integer.
+    def self.to_integer(obj)
+      obj.is_a?(Integer) ? obj : Integer(obj)
+    end
+
+    # Cast _obj_ to a number, favouring BigDecimal over Float.
+    def self.to_decimal(obj, default: 0)
+      case obj
+      when String
+        obj.match?(/\A-?\d+(?:[eE]\+?\d+)?\Z/) ? obj.to_f.to_i : BigDecimal(obj)
+      when Float
+        BigDecimal(obj.to_s)
+      when Integer, BigDecimal, Numeric
+        obj
+      else
+        default
+      end
+    rescue ArgumentError
+      default
+    end
+
+    # Cast _obj_ to a  date and time. Return `nil` if casting fails.
+    #
+    # TODO: This was copied from Shopify/liquid. Include their license and copyright.
+    def self.to_date(obj)
+      return obj if obj.respond_to?(:strftime)
+
+      if obj.is_a?(String)
+        return nil if obj.empty?
+
+        obj = obj.downcase
+      end
+
+      case obj
+      when "now", "today"
+        Time.now
+      when /\A\d+\z/, Integer
+        Time.at(obj.to_i)
+      when String
+        Time.parse(obj)
+      end
+    rescue ::ArgumentError
+      nil
+    end
+
+    def self.fetch(obj, key, default = nil)
+      obj[key]
+    rescue ArgumentError, TypeError, NoMethodError
+      default
+    end
+  end
+end

data/lib/liquid2/filters/array.rb

@@ -0,0 +1,202 @@
+# frozen_string_literal: true
+
+module Liquid2
+  # Liquid filters and helper methods.
+  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(left, sep = " ")
+      sep = Liquid2.to_s(sep)
+      to_enumerable(left).map { |item| Liquid2.to_s(item) }.join(Liquid2.to_s(sep))
+    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 `:undefined`, coerce it to a string before calling `fetch` on items in
+    # _left_.
+    def self.compact(left, key = :undefined, context:)
+      left = Liquid2::Filters.to_enumerable(left)
+
+      case key
+      when Liquid2::Lambda
+        key.map(context, left).zip(left).reject do |r, _i|
+          r.nil? || r.is_a?(Liquid2::Undefined)
+        end.map(&:last)
+      when :undefined
+        left.compact
+      else
+        # TODO: stringify key?
+        left.reject do |item|
+          item.respond_to?(:fetch) ? item.fetch(key, nil).nil? : true
+        end
+      end
+    end
+
+    # Return _left_ concatenated with _right_, or nil if _right_ is not an array.
+    # Coerce _left_ to an array if it isn't an array already.
+    def self.concat(left, right)
+      unless right.respond_to?(:to_ary)
+        raise Liquid2::LiquidArgumentError.new("expected an array", nil)
+      end
+
+      Filters.to_enumerable(left).to_a.concat(right)
+    end
+
+    def self.find(left, key, value = nil, context:)
+      left = Liquid2::Filters.to_enumerable(left)
+
+      if key.is_a?(Liquid2::Lambda)
+        key.map(context, left).zip(left).reject do |r, i|
+          return i unless r.is_a?(Liquid2::Undefined) || !Liquid2.truthy?(context, r)
+        end
+      elsif !value.nil? && !Liquid2.undefined?(value)
+        left.each do |item|
+          return item if fetch(item, key) == value
+        end
+      else
+        left.each do |item|
+          return item if fetch(item, key)
+        end
+      end
+
+      nil
+    end
+
+    def self.find_index(left, key, value = nil, context:)
+      left = Liquid2::Filters.to_enumerable(left)
+
+      if key.is_a?(Liquid2::Lambda)
+        key.map(context, left).reject.with_index do |r, index|
+          return index unless r.is_a?(Liquid2::Undefined) || !Liquid2.truthy?(context, r)
+        end
+      elsif !value.nil? && !Liquid2.undefined?(value)
+        left.each_with_index do |item, index|
+          return index if fetch(item, key) == value
+        end
+      else
+        left.each_with_index do |item, index|
+          return index if fetch(item, key)
+        end
+      end
+
+      nil
+    end
+
+    def self.has(left, key, value = nil, context:)
+      left = Liquid2::Filters.to_enumerable(left)
+
+      if key.is_a?(Liquid2::Lambda)
+        key.map(context, left).reject do |r|
+          return true unless r.is_a?(Liquid2::Undefined) || !Liquid2.truthy?(context, r)
+        end
+      elsif !value.nil? && !Liquid2.undefined?(value)
+        left.each do |item|
+          return true if fetch(item, key) == value
+        end
+      else
+        left.each do |item|
+          return true if fetch(item, key)
+        end
+      end
+
+      false
+    end
+
+    # Return the first item in _left_, or `nil` if _left_ does not have a first item.
+    def self.first(left)
+      case left
+      when String
+        left[0]
+      else
+        left.first if left.respond_to?(:first)
+      end
+    end
+
+    # Return the last item in _left_, or `nil` if _left_ does not have a last item.
+    def self.last(left)
+      case left
+      when String
+        left[-1]
+      else
+        left.last if left.respond_to?(:last)
+      end
+    end
+
+    def self.map(left, key, context:)
+      left = Liquid2::Filters.to_enumerable(left)
+
+      if key.is_a?(Liquid2::Lambda)
+        key.map(context, left).map do |item|
+          item.is_a?(Liquid2::Undefined) ? nil : item
+        end
+      else
+        key = Liquid2.to_s(key)
+        left.map { |item| 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(left)
+      to_enumerable(left).to_a.reverse
+    end
+
+    def self.reject(left, key, value = nil, context:)
+      left = Liquid2::Filters.to_enumerable(left)
+
+      if key.is_a?(Liquid2::Lambda)
+        key.map(context, left).zip(left).reject do |r, _item|
+          r.is_a?(Liquid2::Undefined) || Liquid2.truthy?(context, r)
+        end.map(&:last)
+      elsif !value.nil? && !Liquid2.undefined?(value)
+        key = Liquid2.to_s(key)
+        left.reject do |item|
+          fetch(item, key) == value
+        end
+      else
+        key = Liquid2.to_s(key)
+        left.reject do |item|
+          Liquid2.truthy?(context, fetch(item, key))
+        end
+      end
+    end
+
+    def self.where(left, key, value = nil, context:)
+      left = Liquid2::Filters.to_enumerable(left)
+
+      if key.is_a?(Liquid2::Lambda)
+        key.map(context, left).zip(left).filter do |r, _item|
+          r.is_a?(Liquid2::Undefined) || Liquid2.truthy?(context, r)
+        end.map(&:last)
+      elsif !value.nil? && !Liquid2.undefined?(value)
+        key = Liquid2.to_s(key)
+        left.filter do |item|
+          fetch(item, key) == value
+        end
+      else
+        key = Liquid2.to_s(key)
+        left.filter do |item|
+          Liquid2.truthy?(context, fetch(item, key))
+        end
+      end
+    end
+
+    # Deduplicate items in _left_.
+    # Coerce _left_ to an array if it isn't an array already.
+    def self.uniq(left, key = nil, context:)
+      left = Liquid2::Filters.to_enumerable(left)
+
+      if key.nil?
+        left.to_a.uniq
+      elsif key.is_a?(Liquid2::Lambda)
+        key.map(context, left).zip(left).uniq { |r, _item| r }.map(&:last)
+      else
+        left.to_a.uniq { |item| fetch(item, key) }
+      end
+    end
+  end
+end

data/lib/liquid2/filters/date.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Liquid2
+  # Liquid filters and helper methods.
+  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(left, format)
+      format = Liquid2.to_s(format)
+      return left if format.empty?
+
+      if (date = Filters.to_date(left))
+        date.strftime(format)
+      else
+        left
+      end
+    end
+  end
+end

data/lib/liquid2/filters/default.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Liquid2
+  # Liquid filters and helper methods.
+  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(left, default = "", context:, allow_false: false)
+      return default if left.respond_to?(:force_default) && left.force_default
+
+      obj = left.respond_to?(:to_liquid) ? left.to_liquid(context) : left
+      falsey = allow_false ? left.nil? : !obj
+      falsey || (left.respond_to?(:empty?) && left.empty?) ? default : left
+    end
+  end
+end

data/lib/liquid2/filters/json.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Liquid2
+  # Liquid filters and helper methods.
+  module Filters
+    # Return _left_ serialized in JSON format.
+    def self.json(left, pretty: false)
+      if pretty
+        JSON.pretty_generate(left)
+      else
+        JSON.generate(left)
+      end
+    end
+  end
+end

data/lib/liquid2/filters/math.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+module Liquid2
+  # Liquid filters and helper methods.
+  module Filters
+    # Return the absolute value of _left_.
+    def self.abs(left)
+      to_number(left).abs
+    end
+
+    # Return the maximum of _left_ and _right_.
+    def self.at_least(left, right)
+      [to_number(left), to_number(right)].max
+    end
+
+    # Return the minimum of _left_ and _right_.
+    def self.at_most(left, right)
+      [to_number(left), to_number(right)].min
+    end
+
+    # Return _left_ rounded up to the next whole number.
+    def self.ceil(left)
+      to_number(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(left, right)
+      to_decimal(left) / to_decimal(right) # steep:ignore
+    rescue ZeroDivisionError => e
+      raise LiquidTypeError.new(e.message, nil)
+    end
+
+    # Return the result of multiplying _left_ by _right_.
+    def self.times(left, right)
+      to_decimal(left) * to_decimal(right) # steep:ignore
+    end
+
+    # Return _left_ rounded down to the next whole number.
+    def self.floor(left)
+      to_number(left).floor
+    end
+
+    # Return _right_ subtracted from _left_.
+    def self.minus(left, right)
+      to_decimal(left) - to_decimal(right) # steep:ignore
+    end
+
+    # Return the remainder of dividing _left_ by _right_.
+    def self.modulo(left, right)
+      to_decimal(left) % to_decimal(right) # steep:ignore
+    rescue ZeroDivisionError => e
+      raise LiquidTypeError.new(e.message, nil)
+    end
+
+    # Return _right_ added to _left_.
+    def self.plus(left, right)
+      to_decimal(left) + to_decimal(right) # steep:ignore
+    end
+
+    # Return _left_ rounded to _ndigits_ decimal digits.
+    def self.round(left, ndigits = 0)
+      left = to_decimal(left)
+      return left.round if ndigits == 0 # rubocop:disable Style/NumericPredicate
+
+      left.round(to_decimal(ndigits)) # steep:ignore
+    end
+
+    def self.sum(left, key = nil, context:)
+      left = Liquid2::Filters.to_enumerable(left)
+
+      case key
+      when Liquid2::Lambda
+        items = key.map(context, left).reject do |item|
+          Liquid2.undefined?(item)
+        end
+
+        items.sum { |item| Liquid2::Filters.to_decimal(item) }
+      when nil, Liquid2::Undefined
+        left.sum { |item| Liquid2::Filters.to_decimal(item) } # steep:ignore
+      else
+        k = Liquid2.to_s(key)
+        left.sum { |item| Liquid2::Filters.to_decimal(fetch(item, k)) } # steep:ignore
+      end
+    end
+  end
+end

data/lib/liquid2/filters/size.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Liquid2
+  # Liquid filters and helper methods.
+  module Filters
+    # Return the size of _left_, or zero if _left_ has no size.
+    def self.size(left)
+      left.respond_to?(:size) ? left.size : 0
+    end
+  end
+end

data/lib/liquid2/filters/slice.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Liquid2
+  # Liquid filters and helper methods.
+  module Filters
+    # Return the subsequence of _left_ starting at _start_ up to _length_.
+    def self.slice(left, start, length = 1)
+      length = 1 if Liquid2.undefined?(length)
+      case left
+      when Array
+        left.slice(to_integer(start), to_integer(length)) || []
+      else
+        Liquid2.to_s(left).slice(to_integer(start), to_integer(length)) || ""
+      end
+    end
+  end
+end

data/lib/liquid2/filters/sort.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+module Liquid2
+  # Liquid filters and helper methods.
+  module Filters
+    def self.sort(left, key = nil, context:)
+      left = Liquid2::Filters.to_enumerable(left)
+
+      case key
+      when Liquid2::Lambda
+        key.map(context, left).zip(left).sort do |a, b|
+          nil_safe_compare(a.first, b.first)
+        end.map(&:last)
+      when nil, Liquid2::Undefined
+        left.sort { |a, b| nil_safe_compare(a, b) }
+      else
+        key = Liquid2.to_s(key)
+        left.sort { |a, b| nil_safe_compare(fetch(a, key), fetch(b, key)) }
+      end
+    end
+
+    def self.sort_natural(left, key = nil, context:)
+      left = Liquid2::Filters.to_enumerable(left)
+
+      case key
+      when Liquid2::Lambda
+        key.map(context, left).zip(left).sort do |a, b|
+          nil_safe_casecmp(a.first, b.first)
+        end.map(&:last)
+      when nil, Liquid2::Undefined
+        left.sort { |a, b| nil_safe_casecmp(a, b) }
+      else
+        key = Liquid2.to_s(key)
+        left.sort { |a, b| nil_safe_casecmp(fetch(a, key), fetch(b, key)) }
+      end
+    end
+
+    def self.sort_numeric(left, key = nil, context:)
+      left = Liquid2::Filters.to_enumerable(left)
+
+      case key
+      when Liquid2::Lambda
+        key.map(context, left).zip(left).sort do |a, b|
+          numeric_compare(a.first, b.first)
+        end.map(&:last)
+      when nil, Liquid2::Undefined
+        left.sort { |a, b| numeric_compare(a, b) }
+      else
+        key = Liquid2.to_s(key)
+        left.sort { |a, b| numeric_compare(fetch(a, key), fetch(b, key)) }
+      end
+    end
+
+    def self.nil_safe_compare(left, right)
+      result = left <=> right
+
+      if result
+        result
+      elsif left.nil?
+        1
+      elsif right.nil?
+        -1
+      else
+        raise Liquid2::LiquidArgumentError.new("can't sort incomparable type", nil)
+      end
+    end
+
+    def self.nil_safe_casecmp(left, right)
+      if !left.nil? && !right.nil?
+        left.to_s.casecmp(right.to_s)
+      elsif left.nil? && right.nil?
+        0
+      else
+        left.nil? ? 1 : -1
+      end
+    end
+
+    def self.numeric_compare(left, right)
+      # @type var res: untyped
+      res = ints(left) <=> ints(right)
+      res || -1
+    end
+
+    def self.ints(obj)
+      case obj
+      when Integer, Float, BigDecimal
+        [obj]
+      else
+        numeric = obj.to_s.scan(/-?\d+/)
+        return [Float::INFINITY] if numeric.empty?
+
+        numeric.map(&:to_i)
+      end
+    end
+  end
+end