So let's say we have our User.can_confirm?, we could also create in our macro: User.confirmable(query) which would just do a from u in query, where: [state: [..available_states..]

This fits in well with this being an ecto based fsm

How about documenting states and transitions?

Example:

      [
        doc:      "Activating has succeded"
        name:     :activate,
        from:     [:activating],
        to:       :active,
      ],

This isn't really an issue but a query.

I am looking for a FSM solution with built in persistence where events and state transitions can be configured at run-time.

Does this solution do that?

If not, is there anything else you recommend.

By defining a state machine on a model, I can non longer define a changeset in my model. If I import Ecto.Changeset after I've defined my state machine, things tend to work well again.

I've included examples of what should fail and succeed here: https://gist.github.com/davidrichards/694c7eb030c01b17b014cbaea3aad4f1

The error I get is something along the lines of:

== Compilation error on file web/models/invitation.ex ==
** (CompileError) web/models/invitation.ex:77: undefined function cast/3
    (stdlib) lists.erl:1338: :lists.foreach/2
    (stdlib) erl_eval.erl:670: :erl_eval.do_apply/6

This is the error I get from my own project, not the gist I created above.

Bottom line, I think by aliasing the Ecto.Changeset inside the macro we are changing the way we need to write changesets in our models for non-state changes. To get the import to work again after using the macro, I either have to import Ecto.Changeset again (as in the second example in the gist) or use Changeset.cast(...), Changest.put_change(...), etc.

If there's a way to make that macro less obtrusive to it's surrounding model, that would be useful.

Thanks for this work, btw.

Fix would be to use this:

      events
      |> Enum.each(fn(event) ->
        unless event[:to] in states do
          raise "Target state :#{event[:to]} is not present in @states"
        end

        def unquote(event[:name])(model) do
          model
          |> Changeset.change(%{ unquote(column) => "#{unquote(event[:to])}" })
          |> unquote(event[:callback]).()
          |> unquote(:"validate_state_transition_#{column}")(unquote(event), model)
        end

        def unquote(:"can_#{event[:name]}?")(model) do
          :"#{Map.get(model, unquote(column))}" in unquote(event[:from])
        end
      end)

      defp unquote(:"validate_state_transition_#{column}")(changeset, event, model) do
        change = Map.get(model, unquote(column))

        if :"#{change}" in event[:from] do
          changeset
        else
          changeset
          |> Changeset.add_error(unquote(column),
            "You can't move state from :#{change} to :#{event[:to]}"
            )
        end
      end

It would be cool, to have a praedicate to check if a column is in a state, like: is_update_successfull?

Code to use here:

      states
      |> Enum.each(fn(state) ->
        def unquote(:"is_#{column}_#{state}?")(model) do
          :"#{Map.get(model, unquote(column))}" == unquote(state)
        end
      end)

It like there isn't a license for ecto_state_machine. Given that it's a public repo and on the Awesome Elixir list I'm assuming that you'd like it to be open source software, and including a LICENSE.md file would make that explicit.

In this component there could be some inspirations for this module: http://symfony.com/blog/new-in-symfony-3-2-workflow-component

For example:

• Returning a list of all possible transitions (for transition in workflow_transitions(article))

Would be nice to use multiple callbacks in order to support things like Ecto.Multi. So instead of just having a :callback which needs to call :validate_state_transition which expects an Ecto.Changeset, you have :before_transition and an :after_transition.

This allows you to do

  use EctoStateMachine,
    states: [:initial, :confirmed],
    events: [
      [
        name:     :confirm,
        from:     [:inital],
        to:       :confirmed,
        before_transition: fn(model, _params) -> Ecto.Changeset.change(model, expired_at: Ecto.DateTime.utc()),
        after_transition: fn(changeset, params) do
          Multi.new
          |> Multi.update(changeset)
          |> Multi.insert(TBD.changeset(%TBD{}, params)
        end
      ]
    ]

Now you can call User.confirm(params) and the params supplied will get applied to the transition functions.

It would be a nice idea to return in happy path:

{:ok, updated_changset}

and

{:error, error}

Mostly because that's industry standard and it would nicely integrate with Phoenix Fallback controllers.

Ho about creating a export so files like this could be generated?

http://www.graphviz.org/Gallery/directed/fsm.html

Is it possible to mimick the https://github.com/ericentin/gen_state_machine api?

The only difference between that lib and this lib seems to be this stores the state in ecto.

I may be misunderstanding the purpose of this lib.