temple/lib/temple/ast/default.ex

defmodule Temple.Ast.Default do
  @moduledoc false
  @behaviour Temple.Parser

  use TypedStruct

  typedstruct do
    field :elixir_ast, Macro.t()
  end

  @impl true
  def applicable?(_ast), do: true

  @impl true
  def run(ast) do
    Temple.Ast.new(__MODULE__, elixir_ast: ast)
  end
end
Align component model with HEEx/Surface (#182) * Align component model with HEEx/Surface This change aligns the component model with HEEx/Surface. This shoudl allow one to interop components created in any syntax with any other syntax. The advantage of this is folks can utilize component packages created using a different syntax. This includes several enhancements and breaking changes, please see the changelog and the migration guide for further details. Closes #130 2022-10-12 13:17:23 +00:00			`defmodule Temple.Ast.Default do`
feat: New Component API 2021-01-02 18:21:48 +00:00			`@moduledoc false`
Parser abstraction This implements a Temple.Parser behavior. This contracts requires a `applicable/1` and `run/2` functions to be defined. `applicable/1` is passed the unparsed AST, and returns true or false as to whether this parser module should be run. `run/2` is passed the unparsed AST as well as the buffer. It should add parsed markup to the buffer. The function either returns `:ok` if the AST is done, or `{:component_applied, ast}`. If the latter is returned, the parser pass starts over with the return ast. 2020-07-24 00:59:10 +00:00			`@behaviour Temple.Parser`

SVG (#181) This basically just adds svg elements as void and nonvoid element aliases and it works, will test on a real proejct before releasing the next release. Also, fixed the weird behaviour problem by defining types for each of the ast nodes and then referencing those types when defining the ast type. Unclear why this works, but I imagine it has to do with the types not being a big part of the compilation process or something. This also uses the typed_struct library to do so. Seems pretty slick and does what it claims it does. 2022-09-20 00:35:45 +00:00			`use TypedStruct`
Output AST to EEx 2021-04-09 03:04:26 +00:00
SVG (#181) This basically just adds svg elements as void and nonvoid element aliases and it works, will test on a real proejct before releasing the next release. Also, fixed the weird behaviour problem by defining types for each of the ast nodes and then referencing those types when defining the ast type. Unclear why this works, but I imagine it has to do with the types not being a big part of the compilation process or something. This also uses the typed_struct library to do so. Seems pretty slick and does what it claims it does. 2022-09-20 00:35:45 +00:00			`typedstruct do`
			`field :elixir_ast, Macro.t()`
			`end`
Parser abstraction This implements a Temple.Parser behavior. This contracts requires a `applicable/1` and `run/2` functions to be defined. `applicable/1` is passed the unparsed AST, and returns true or false as to whether this parser module should be run. `run/2` is passed the unparsed AST as well as the buffer. It should add parsed markup to the buffer. The function either returns `:ok` if the AST is done, or `{:component_applied, ast}`. If the latter is returned, the parser pass starts over with the return ast. 2020-07-24 00:59:10 +00:00
SVG (#181) This basically just adds svg elements as void and nonvoid element aliases and it works, will test on a real proejct before releasing the next release. Also, fixed the weird behaviour problem by defining types for each of the ast nodes and then referencing those types when defining the ast type. Unclear why this works, but I imagine it has to do with the types not being a big part of the compilation process or something. This also uses the typed_struct library to do so. Seems pretty slick and does what it claims it does. 2022-09-20 00:35:45 +00:00			`@impl true`
Generate AST 2021-03-25 03:01:13 +00:00			`def applicable?(_ast), do: true`

SVG (#181) This basically just adds svg elements as void and nonvoid element aliases and it works, will test on a real proejct before releasing the next release. Also, fixed the weird behaviour problem by defining types for each of the ast nodes and then referencing those types when defining the ast type. Unclear why this works, but I imagine it has to do with the types not being a big part of the compilation process or something. This also uses the typed_struct library to do so. Seems pretty slick and does what it claims it does. 2022-09-20 00:35:45 +00:00			`@impl true`
Generate AST 2021-03-25 03:01:13 +00:00			`def run(ast) do`
Rename ast properties to align with given ast The properties were either not needed at all, or were named back when there was only one node type. now that each node is it's own struct, they really don't need to share any common properties. 2021-04-10 15:05:37 +00:00			`Temple.Ast.new(__MODULE__, elixir_ast: ast)`
Generate AST 2021-03-25 03:01:13 +00:00			`end`
Parser abstraction This implements a Temple.Parser behavior. This contracts requires a `applicable/1` and `run/2` functions to be defined. `applicable/1` is passed the unparsed AST, and returns true or false as to whether this parser module should be run. `run/2` is passed the unparsed AST as well as the buffer. It should add parsed markup to the buffer. The function either returns `:ok` if the AST is done, or `{:component_applied, ast}`. If the latter is returned, the parser pass starts over with the return ast. 2020-07-24 00:59:10 +00:00			`end`