Merge pull request #11 from 0xAX/taggable-support

[ecto_migrate] Tags support

Author: Dmitry Aleksandrov(Russ)

README.md

@@ -84,7 +84,34 @@ Ecto.Migration.Auto.migrate(Repo, Comment)
 
 ```
 
-`ecto_migrate` also supports indexes
+`ecto_migrate` also provides additional `migrate/3` API. For example use it with [ecto_taggable](https://github.com/xerions/ecto_taggable). For example we have model:
+
+```elixir
+defmodule Weather do # is for later at now
+  use Ecto.Model
+
+  schema "weather" do
+    field :city
+    field :temp_lo, :integer
+    field :temp_hi, :integer
+    field :prcp,    :float, default: 0.0
+    has_many :weather_tags, {"weather_tags", Ecto.Taggable}, [foreign_key: :tag_id] # foreign_key `tag_id` is mandatory.
+  end
+end
+```
+
+Now we can migrate `weather_tag` table with:
+
+```elixir
+Ecto.Migration.Auto.migrate(Repo, Ecto.Taggable, [for: Weather])
+```
+
+It will generate and migrate `weather_tags` table to the database which will be associated with `weather` table.
+
+Indexes
+--------------------
+
+`ecto_migrate` has support of indexes:
 
 ```elixir
 defmodule Weather do # is for later at now

lib/ecto/migration/auto.ex

@@ -3,44 +3,52 @@ defmodule Ecto.Migration.Auto do
   alias Ecto.Migration.Index
   alias Ecto.Migration.SystemTable
 
-  def migrate(repo, module) do
-    table_name = module.__schema__(:source)
+  def migrate(repo, module, opts \\ []) do
+    {tag_field, tablename} = case opts do
+                  [] ->
+                    {:nothing, module.__schema__(:source)}
+                  [for: mod] ->
+                    [{field, _, tablename}] = get_associations(mod)
+                    {field, tablename}
+                end
     # already stored fields of the model in the system table
-    all_system_fields = get_existings_fields(repo, table_name)
+    all_system_fields = get_existings_fields(repo, tablename)
     # already stored indexes of the model in the system table
-    all_system_indexes = get_existings_indexes(repo, table_name)
-    if execute(module, all_system_fields, all_system_indexes, repo) do
-      Ecto.Migrator.up(repo, random, extend_module_name(module, ".Migration"))
-    end
+    all_system_indexes = get_existings_indexes(repo, tablename)
+    # execute migration
+    if execute(tablename |> to_string, module, all_system_fields, all_system_indexes, tag_field, repo, opts) do
+      Ecto.Migrator.up(repo, random, migration_module_name(module, opts))
+    end   
   end
 
-  defp execute(module, all_system_fields, all_system_indexes, repo) do
-    metainfo =  all_system_fields[:metainfo] |> transform_existing_keys()
+  defp execute(tablename, module, all_system_fields, all_system_indexes, tag_field, repo, opts) do
     assocs = get_associations(module)
+    metainfo = all_system_fields[:metainfo] |> transform_existing_keys()
     all_fields = module.__schema__(:fields)
-    add_fields = add_fields(module, all_fields, metainfo, assocs)
+    add_fields = [assoc_field(tag_field, tablename, all_system_fields, opts) | add_fields(module, all_fields, metainfo, assocs)] |> :lists.flatten
     remove_fields = remove_fields(all_fields, metainfo)
     all_indexes = Index.get_all(module)
     update_index = Index.updated?(all_indexes, all_system_indexes)
     all_changes = remove_fields ++ add_fields
-    update_metainfo(module, all_fields, assocs, repo)
-    do_execute(module, all_changes, metainfo, update_index, all_indexes, all_system_indexes, repo)
+    update_metainfo(module, tablename, all_fields, assocs, repo)
+    update_index_info(tablename, module, repo)
+    index_info = {update_index, all_indexes, all_system_indexes}
+    do_execute(repo, tablename, module, all_changes, metainfo, index_info, opts)
   end
 
-  defp do_execute(_module, [], _fields_in_db, false, _, _, _repo), do: nil
-
-  defp do_execute(module, all_changes, fields_in_db, update_index, all_indexes, all_system_indexes, repo) do
-    table_name = table_name(module)
-    module_name = extend_module_name(module, ".Migration")
-    updsl = gen_up_dsl(repo, module, table_name, all_changes, fields_in_db, all_indexes, all_system_indexes, update_index)
+  defp do_execute(_repo, _, _module, [], _fields_in_db, {false, _, _}, _), do: nil
+  defp do_execute(repo, tablename, module, all_changes, fields_in_db, index_info, opts) do
+    {update_index, all_indexes, all_system_indexes} = index_info
+    updsl = gen_up_dsl(repo, module, tablename |> String.to_atom, all_changes, fields_in_db, all_indexes, all_system_indexes, update_index)
+    migration_module_name = migration_module_name(module, opts)
     res = quote do
-      defmodule unquote(module_name) do
+      defmodule unquote(migration_module_name) do
         use Ecto.Migration
         def up do
           unquote(updsl)
         end
         def down do
-          drop table(unquote table_name)
+          drop table(unquote tablename)
         end
       end
     end
@@ -49,22 +57,22 @@ defmodule Ecto.Migration.Auto do
   end
 
   # create new table
-  defp gen_up_dsl(_repo, module, table_name, all_changes, [], all_indexes, _, update_index) do
+  defp gen_up_dsl(_repo, module, tablename, all_changes, [], all_indexes, _, update_index) do
     key? = module.__schema__(:primary_key) == [:id]
-    index_creation = Index.create(module, all_indexes, update_index)
+    index_creation = Index.create(tablename, all_indexes, update_index)
     quote do
-      create table(unquote(table_name), primary_key: unquote(key?)) do
+      create table(unquote(tablename), primary_key: unquote(key?)) do
         unquote(all_changes)
       end
       unquote(index_creation)
     end
   end
 
   # updated or table or index or both
-  defp gen_up_dsl(repo, module, table_name, all_changes, _, all_indexes, all_system_indexes, update_index) do
-    index_deletion = Index.delete(update_index, table_name |> Atom.to_string, module, repo, all_system_indexes)
-    index_creation = Index.create(module, all_indexes, update_index)
-    alter = alter_table(all_changes, table_name)
+  defp gen_up_dsl(repo, module, tablename, all_changes, _, all_indexes, all_system_indexes, update_index) do
+    index_deletion = Index.delete(update_index, tablename |> Atom.to_string, module, repo, all_system_indexes)
+    index_creation = Index.create(tablename, all_indexes, update_index)
+    alter = alter_table(all_changes, tablename)
     quote do
       unquote(alter)
       unquote(index_deletion)
@@ -81,25 +89,26 @@ defmodule Ecto.Migration.Auto do
     end
   end
 
-  defp update_metainfo(module, all_fields, assocs, repo) do
-    table_name = module.__schema__(:source)
+  defp update_metainfo(module, tablename, all_fields, assocs, repo) do
     metainfo = system_table_meta(module, all_fields, assocs)
-    case repo.get(SystemTable, table_name) do
+    case repo.get(SystemTable, tablename) do
       nil ->
-        repo.insert(%SystemTable{tablename: table_name, metainfo: metainfo})
-    table ->
+        repo.insert(%SystemTable{tablename: tablename, metainfo: metainfo})
+      table ->
         repo.update(%SystemTable{table | metainfo: metainfo})
     end
+  end
 
-    query = from s in SystemTable.Index, where: s.tablename == ^table_name, select: s
-    # insert index info if need
+  defp update_index_info(tablename, module, repo) do
+    query = from s in SystemTable.Index, where: s.tablename == ^tablename, select: s
+    # insert index info into system table, if need
     case repo.all(query) do
       [] ->
-        # we have no anything with 'table_name' record in the SystemTable.Index
+        # we have no anything with 'tablename' record in the SystemTable.Index
         # table, let's insert records about it
         all_indexes = Index.get_all(module)
         for {fields, opts} <- all_indexes do
-          repo.insert(Map.merge(%SystemTable.Index{tablename: table_name, index: Enum.join(fields, ",")}, :maps.from_list(opts)))
+          repo.insert(Map.merge(%SystemTable.Index{tablename: tablename, index: Enum.join(fields, ",")}, :maps.from_list(opts)))
         end
       _ ->
         # we can't update index information here, because table is not empty and
@@ -108,19 +117,19 @@ defmodule Ecto.Migration.Auto do
     end
   end
 
-  def get_existings_indexes(repo, table_name) do
+  def get_existings_indexes(repo, tablename) do
     try do
-      repo.all(from s in SystemTable.Index, where: ^table_name == s.tablename)
+      repo.all(from s in SystemTable.Index, where: ^tablename == s.tablename)
     catch
       _x, _y ->
         Ecto.Migrator.up(repo, random, SystemTable.Index.Migration) # we have no system table - 'ecto_migration_auto_index', let's create it
         nil
     end
   end
 
-  def get_existings_fields(repo, table_name) do
+  def get_existings_fields(repo, tablename) do
     try do
-      repo.get(SystemTable, table_name)
+      repo.get(SystemTable, tablename)
     catch
       _x, _y ->
         Ecto.Migrator.up(repo, random, SystemTable.Migration) # we have no system table - 'ecto_migration_auto', let's create it
@@ -132,7 +141,9 @@ defmodule Ecto.Migration.Auto do
     module.__schema__(:associations) |> Enum.flat_map(fn(association) ->
       case module.__schema__(:association, association) do
         %Ecto.Association.BelongsTo{owner_key: field, assoc: assoc_module} ->
-          [{field, table_name(assoc_module), assoc_module}]
+          [{field, assoc_module.__schema__(:source) |> String.to_atom, assoc_module}]
+        %Ecto.Association.Has{field: field, assoc: assoc, queryable: {tablename, _}} ->
+          [{field, assoc, tablename}]
         _ ->
           []
       end
@@ -203,11 +214,11 @@ defmodule Ecto.Migration.Auto do
 
   defp random, do: :crypto.rand_uniform(0, 1099511627775)
 
-  defp extend_module_name(module, str) do
-    ((module |> to_string) <> str) |> String.to_atom
-  end
+  defp assoc_field(_, _, system_fields, _)
+    when system_fields != nil, do: []
+  defp assoc_field(_, _, _, []), do: []
+  defp assoc_field(tag_field, tablename, _, _opts), do: quote do: (add unquote(tag_field), references(unquote(tablename) |> String.to_atom))
 
-  defp table_name(module) do
-    module.__schema__(:source) |> String.to_atom
-  end
+  defp migration_module_name(module, []), do: ((module |> Atom.to_string) <> ".Migration") |> String.to_atom
+  defp migration_module_name(module, [for: mod]), do: ((module |> Atom.to_string) <> "." <> (mod |> Atom.to_string) <> ".Migration") |> String.to_atom
 end

lib/ecto/migration/index.ex

@@ -22,9 +22,8 @@ defmodule Ecto.Migration.Index do
     end
   end
 
-  def create(module, all_indexes, true) when length(all_indexes) > 0 do
+  def create(tablename, all_indexes, true) when length(all_indexes) > 0 do
     for {fields, opts} <- all_indexes do
-      tablename =  module.__schema__(:source) |> String.to_atom
       quote do
         create index(unquote(tablename), unquote(fields), unquote(opts))
       end

test/ecto_migrate_test.exs

@@ -1,6 +1,7 @@
 defmodule TestModel do
   use Ecto.Schema
   use Ecto.Migration.Index
+
   index(:l, using: "hash")
   index(:f)
   schema "ecto_migrate_test_table" do
@@ -10,16 +11,59 @@ defmodule TestModel do
   end
 end
 
+defmodule Ecto.Taggable do
+  use Ecto.Model
+  use Ecto.Migration.Index
+
+  index(:tag_id, using: "hash")
+  schema "this is not a valid schema name and it will never be used" do
+    field :name, :string
+    field :model, :string
+    field :tag_id, :integer
+  end
+end
+
+defmodule MyModel do
+  use Ecto.Model
+  schema "my_model" do
+    field :a, :string
+    field :b, :integer
+    has_many :my_model_tags, {"my_model_tags", Ecto.Taggable}, [foreign_key: :tag_id]
+  end
+end
+
 defmodule EctoMigrateTest do
   use ExUnit.Case
   import Ecto.Query
-  test "ecto_migrate test" do
+
+  test "ecto_migrate with tags test" do
     :ok = :application.start(:ecto_it)
+ 
     Ecto.Migration.Auto.migrate(EctoIt.Repo, TestModel)
     query = from t in Ecto.Migration.SystemTable, select: t
     [result] = EctoIt.Repo.all(query)
     assert result.metainfo == "f:string,i:integer,l:boolean"
     assert result.tablename == "ecto_migrate_test_table"
+
+    Ecto.Migration.Auto.migrate(EctoIt.Repo, MyModel)
+    Ecto.Migration.Auto.migrate(EctoIt.Repo, Ecto.Taggable, [for: MyModel])
+    
+    EctoIt.Repo.insert(%MyModel{a: "foo"})
+    EctoIt.Repo.insert(%MyModel{a: "bar"})
+
+    model = %MyModel{}
+    new_tag = Ecto.Model.build(model, :my_model_tags)
+    new_tag = %{new_tag | tag_id: 2, name: "test_tag", model: MyModel |> to_string}
+    EctoIt.Repo.insert(new_tag)
+
+    query = from c in MyModel, where: c.id == 2, preload: [:my_model_tags]
+    [result] = EctoIt.Repo.all(query)
+    [tags] = result.my_model_tags
+
+    assert tags.id == 1
+    assert tags.model == "Elixir.MyModel"
+    assert tags.name  == "test_tag"
+ 
     :ok = :application.stop(:ecto_it)
   end
 end