Migration from Ruby on Rails model

Sample1

####Ruby ActiveRecord

class User < ActiveRecord::Base
  has_many :comments, :foreign_key => "author_id"
end

class Comment < ActiveRecord::Base
  belongs_to :author, :class_name => "User"
end

# ---
# schema.rb
#
create_table "users", :force => true do |t|
  t.string "name"
  t.integer "age"
end

create_table "comments", :force => true do |t|
  t.text "body"
  t.integer "author_id"
end

Scala ActiveRecord

case class User(name: String, age: Int) extends ActiveRecord {
  lazy val comments = hasMany[Comment](foreignKey = "authorId")
}

object User extends ActiveRecordCompanion[User]

case class Comment(body: String) extends ActiveRecord {
  val authorId: Long = 0
  lazy val author = belongsTo[User](foreignKey = "authorId")
}

object Comment extends ActiveRecordCompanion[Comment]

object Tables extends ActiveRecordTables {
  val users = table[User]
  val comments = table[Comment]
}

###Sample2 (HABTM)

Ruby ActiveRecord

class User < ActiveRecord::Base
  has_and_belongs_to_many :roles
end

class Role < ActiveRecord::Base
  has_and_belongs_to_many :users
end

# ---
# schema.rb
#
create_table "users", :force => true do |t|
  t.string "name"
  t.integer "age"
end

create_table "roles", :force => true do |t|
  t.string "name"
end

create_table "roles_users", :id => false do |t|
  t.integer "role_id", :null => false
  t.integer "user_id", :null => false
end

Scala ActiveRecord

case class User(name: String, age: Int) extends ActiveRecord {
  lazy val rolesUsers = hasMany[RolesUsers]
  lazy val roles = hasManyThrough[Comment](rolesUsers)
}

object User extends ActiveRecordCompanion[User]

case class Role(name: String) extends ActiveRecord {
  lazy val rolesUsers = hasMany[RolesUsers]
  lazy val users = hasManyThrough[User](rolesUsers)
}

object Role extends ActiveRecordCompanion[Role]

case class RolesUsers(roleId: Long, userId: Long) 
  extends ActiveRecordBase[CompositeKey2[Long, Long]] with KeyedEntity[CompositeKey2[Long, Long]] {
  lazy val role = belongsTo[Role]
  lazy val user = belongsTo[User]
}

object RolesUsers extends ActiveRecordBaseCompanion[CompositeKey2[Long, Long], RolesUsers] 

object Tables extends ActiveRecordTables {
  val users = table[User]
  val roles = table[Role]
  val rolesUsers = table[RolesUsers]
}