datum.cr

module Crystal
  # :nodoc:
  macro datum_accessors(short, type, immutable)
    # Checks that the underlying value is `{{type}}`, and returns its value.
    # Raises otherwise.
    def as_{{short.id}} : {{type}}
      {% if immutable == true %}
        @raw.as({{type}}).clone
      {% else %}
        @raw.as({{type}})
      {% end %}
    end

    {% if type.resolve != Nil %}
      # Checks that the underlying value is `{{type}}`, and returns its value.
      # Returns `nil` otherwise.
      def as_{{short.id}}? : {{type}}?
        {% if immutable == true %}
          @raw.as?({{type}}).clone
        {% else %}
          @raw.as?({{type}})
        {% end %}
      end
    {% end %}
  end

  # `Crystal.datum` macro is an internal helper to create data types that will hold
  # values of multiple kinds similar to `JSON::Any` and `YAML::Any`.
  #
  # * **types**: contains a named tuple of prefixes and data types of each leaf
  # * **hash_key_type** specifies the type used as the key of `Hash`
  # * **immutable**: will generate honor immutability of the values via `.clone`
  # * **target_type**: is the type where the macro is invoked (it's a workaround for #9099).

  # :nodoc:
  macro datum(*, types, hash_key_type, immutable, target_type)

    # All possible `{{target_type}}` types.
    alias Type = {% for short, type in types %}{{type}} | {% end %}Array(self) | Hash({{hash_key_type}}, self)

    # Returns the raw underlying value, a `Type`.
    getter raw : Type

    # Creates a `{{target_type}}` that wraps the given `Type`.
    def initialize(@raw : Type)
    end

    Crystal.datum_accessors a, Array(self), {{immutable}}
    Crystal.datum_accessors h, Hash({{hash_key_type}}, self), {{immutable}}

    {% for short, type in types %}
      Crystal.datum_accessors {{short}}, {{type}}, {{immutable}}
    {% end %}

    # Assumes the underlying value is an `Array` or `Hash` and returns its size.
    #
    # Raises if the underlying value is not an `Array` or `Hash`.
    def size : Int
      case object = @raw
      when Array
        object.size
      when Hash
        object.size
      else
        raise "Expected Array or Hash for #size, not #{object.class}"
      end
    end

    # Assumes the underlying value is an `Array` or `Hash`
    # and returns the element at the given *index_or_key*.
    #
    # Raises if the underlying value is not an `Array` nor a `Hash`.
    def [](index_or_key) : self
      case object = @raw
      when Array
        if index_or_key.is_a?(Int)
          object[index_or_key]
        else
          raise "Expected int key for Array#[], not #{object.class}"
        end
      when Hash
        object[index_or_key]
      else
        raise "Expected Array or Hash, not #{object.class}"
      end
    end

    # Assumes the underlying value is an `Array` or `Hash` and returns the element
    # at the given *index_or_key*, or `nil` if out of bounds or the key is missing.
    #
    # Raises if the underlying value is not an `Array` nor a `Hash`.
    def []?(index_or_key) : self?
      case object = @raw
      when Array
        if index_or_key.is_a?(Int)
          object[index_or_key]?
        else
          nil
        end
      when Hash
        object[index_or_key]?
      else
        raise "Expected Array or Hash, not #{object.class}"
      end
    end

    # Traverses the depth of a structure and returns the value.
    # Returns `nil` if not found.
    def dig?(index_or_key, *subkeys) : self?
      self[index_or_key]?.try &.dig?(*subkeys)
    end

    # :nodoc:
    def dig?(index_or_key) : self?
      case @raw
      when Hash, Array
        self[index_or_key]?
      else
        nil
      end
    end

    # Traverses the depth of a structure and returns the value, otherwise raises.
    def dig(index_or_key, *subkeys) : self
      self[index_or_key].dig(*subkeys)
    end

    # :nodoc:
    def dig(index_or_key) : self
      self[index_or_key]
    end

    def inspect(io : IO) : Nil
      @raw.inspect(io)
    end

    def to_s(io : IO) : Nil
      @raw.to_s(io)
    end

    # :nodoc:
    def pretty_print(pp)
      @raw.pretty_print(pp)
    end

    # Returns `true` if both `self` and *other*'s raw object are equal.
    def ==(other : self)
      raw == other.raw
    end

    # Returns `true` if the raw object is equal to *other*.
    def ==(other)
      raw == other
    end

    # See `Object#hash(hasher)`
    def_hash raw

    # Returns a new `{{target_type}}` instance with the `raw` value `dup`ed.
    def dup
      self.class.new(raw.dup)
    end

    # Returns a new `{{target_type}}` instance with the `raw` value `clone`ed.
    def clone
      self.class.new(raw.clone)
    end
  end
end