require "json"

class Foo
  # This is our base mapping.
  # Remember that in Crystal constants aren't typed unless used
  # in a program. If we only use them at compile time, we can
  # use them to remember and gather data at compile time.
  MAPPING = {
    x: Int32,
    y: Int32,
  }

  # We tell users to use this for extending JSON attributes
  macro extra_attributes(**values)
    # We mutate MAPPING at compile time
    {% for key, value in values %}
      {% MAPPING[key] = value %}
    {% end %}
  end

  # This runs once the bottom of the program is reached.
  # Scope is preserved, so MAPPING refers to the above constant.
  macro finished
    JSON.mapping({{MAPPING}})
  end
end

# One extension
class Foo
  extra_attributes z: Int32?
end

# Another extension
class Foo
  extra_attributes w: Int32?
end

# All of these work
p Foo.from_json(%<{"x": 1, "y": 2}>)
p Foo.from_json(%<{"x": 1, "y": 2, "z": 3}>)
p Foo.from_json(%<{"x": 1, "y": 2, "z": 3, "w": 4}>)

class ModelBase
  macro inherited
    # Here we capture all properties. The `of Nil => Nil` is needed for syntax,
    # but the contents will never be used at runtime, so no problem
    PROPERTIES = {} of Nil => Nil

    macro finished
      process_properties
    end
  end

  macro attribute(decl)
    {% PROPERTIES[decl.var] = decl.type %}
  end

  macro process_properties
    # Here we process properties to define methods, instance variables, etc.
    {{ puts PROPERTIES }}
  end
end

class User < ModelBase
  attribute name : String
  attribute age : Int32
end

# Without finished one would probably need to specify all attributes in one go:
# class User < ModelBase
#   attributes({
#     name : String,
#     age : Int32
#   })
# end