Submin2のデータベースをRepoMatの設定ファイルに変換してみました

  # sqlite3 submin.db
  sqlite> .schema
  
  CREATE TABLE users
                  (
                          id       integer primary key autoincrement,
                          name     text not null unique,
                          password text not null,
                          email    text,
                          fullname text,
                          is_admin bool default 0
                  );
  CREATE TABLE groups
                  (
                          id   integer primary key autoincrement,
                          name text not null unique
                  );
  CREATE TABLE group_members
                  (
                          groupid integer not null references groups(id),
                          userid  integer not null references user(id),
                          PRIMARY KEY(groupid, userid)
                  );
  CREATE TABLE options
                  (
                          key   text primary key not null unique,
                          value text not null
                  );
  CREATE TABLE notifications
                  (
                          userid       integer references users(id),
                          repository   text,
                          allowed      bool default 0,
                          enabled      bool default 0,
                          PRIMARY KEY(userid, repository)
                  );
  CREATE TABLE permissions
                  (
                          repository     text,
                          repositorytype text,
                          path           text not null,
                          subjecttype    text not null,   -- user, group or all
                          subjectid      integer,         -- only null if subjecttype is all
                          type           text default '', -- '', 'r' or 'rw'
                          UNIQUE(repository, path, subjecttype, subjectid)
                  );
  CREATE TABLE managers
                  (
                          id          integer primary key autoincrement,
                          managertype text not null, -- user or group
                          managerid   integer,
                          objecttype  text not null, -- group or repository
                          objectid    integer, -- groupid if objecttype is group
                          objectname  text -- name of repository if objecttype is repository
                  );
  CREATE TABLE ssh_keys
                  (
                          id      integer primary key autoincrement,
                          userid  integer not null references user(id),
                          title   text,
                          ssh_key text not null
                  );
  CREATE TABLE password_reset (
                          userid  integer not null references user(id) primary key, -- valid for this user
                          expires integer not null, -- this entry expires at Unix Time
                          key     text not null -- random secret
                  );
  CREATE TABLE sessions
          (
                  key   text not null primary key not null unique,
                  value text not null -- pickled dictionary
          );
  sqlite>

    class Option < ActiveRecord::Base
      self.primary_key = :key
    end

    class Notification < ActiveRecord::Base
      self.primary_key = [:userid, :repository]
    end

    class User < ActiveRecord::Base
      self.primary_key = :id

      has_many :group_user_relationships, class_name: "GroupMember", foreign_key: "userid"
      has_many :groups, through: :group_user_relationships
      has_many :notifications, class_name: "Notification", foreign_key: "userid"

      def notifications_allowed_repos
        notifications.where(allowed: 1).pluck(:repository)
      end

      def notifications_enabled_repos
        notifications.where(enabled: 1).pluck(:repository)
      end
    end

    class Group < ActiveRecord::Base
      self.primary_key = :id

      has_many :group_user_relationships, class_name: "GroupMember", foreign_key: "groupid"
      has_many :members, through: :group_user_relationships
    end

    class GroupMember < ActiveRecord::Base
      self.primary_key = [:groupid, :userid]

      belongs_to :group, class_name: "Group", foreign_key: "groupid"
      belongs_to :member, class_name: "User", foreign_key: "userid"
    end

    class Permission < ActiveRecord::Base
      self.primary_key = [:repository, :repositorytype, :path, :subjecttype, :subjectid]
      self.inheritance_column = :_type_disabled

      scope :svn, ->{ where(repositorytype: 'svn') }
      scope :order_repo_path, ->{ order(repositorytype: :asc, repository: :asc, path: :asc, subjecttype: :asc, subjectid: :asc) }

      belongs_to :subject_group, class_name: "Group", foreign_key: "subjectid", optional: true
      belongs_to :subject_user, class_name: "User", foreign_key: "subjectid", optional: true

      def group?
        subjecttype == 'group'
      end

      def user?
        subjecttype == 'user'
      end

      def all?
        subjecttype == 'all'
      end

      def subject
        if group?
          subject_group
        elsif user?
          subject_user
        else
          nil
        end
      end
    end
  

    # Generate htpasswd
    File.open("#{ENV['OUTDIR']}/htpasswd", 'w') do |f|
      User.find_each do |user|
        f.puts "#{user.name}:#{user.password}"
      end
    end

    # Generate userproperties.conf
    File.open("#{ENV['OUTDIR']}/userproperties.conf", 'w') do |f|
      User.find_each do |user|
        f.puts "[#{user.name}]"
        f.puts "fullname = #{user.fullname}"
        f.puts "email = #{user.email}"

        f.puts "notifications_allowed = #{user.notifications_allowed_repos.join(',')}"
        f.puts "notifications_enabled = #{user.notifications_enabled_repos.join(',')}"

        f.puts
      end
    end

    # Generate authz
    File.open("#{ENV['OUTDIR']}/authz", 'w') do |f|
      f.puts "[groups]"
      Group.find_each do |group|
        members = group.members.pluck(:name).join(',')
        f.puts "#{group.name} = #{members}"
      end
      f.puts

      perms = {}
      Permission.svn.order_repo_path.find_each do |perm|
        key = "#{perm.repository}:#{perm.path}"
        perms[key] ||= []
        role =
          if perm.all?
            '*'
          elsif perm.group?
            "@#{perm.subject.name}"
          else
            perm.subject.name
          end
        perms[key] << "#{role} = #{perm.type}"
      end

      perms.each do |repo_path, arr|
        f.puts "[#{repo_path}]"
        arr.each do |role_perm|
          f.puts role_perm
        end
        f.puts
      end
    end