BigW Consortium Gitlab

base_template.rb 2.56 KB
Newer Older
1 2 3
module Gitlab
  module Template
    class BaseTemplate
4
      def initialize(path, project = nil)
5
        @path = path
6
        @finder = self.class.finder(project)
7 8 9 10 11 12 13
      end

      def name
        File.basename(@path, self.class.extension)
      end

      def content
14 15 16 17 18
        @finder.read(@path)
      end

      def to_json
        { name: name, content: content }
19 20
      end

21
      class << self
22 23 24 25 26 27
        def all(project = nil)
          if categories.any?
            categories.keys.flat_map { |cat| by_category(cat, project) }
          else
            by_category("", project)
          end
28 29
        end

30 31 32
        def find(key, project = nil)
          path = self.finder(project).find(key)
          path.present? ? new(path, project) : nil
33 34
        end

35 36 37
        # Set categories as sub directories
        # Example: { "category_name_1" => "directory_path_1", "category_name_2" => "directory_name_2" }
        # Default is no category with all files in base dir of each class
38
        def categories
39
          {}
40 41 42 43 44 45 46 47 48 49
        end

        def extension
          raise NotImplementedError
        end

        def base_dir
          raise NotImplementedError
        end

50 51 52 53 54
        # Defines which strategy will be used to get templates files
        # RepoTemplateFinder - Finds templates on project repository, templates are filtered perproject
        # GlobalTemplateFinder - Finds templates on gitlab installation source, templates can be used in all projects
        def finder(project = nil)
          raise NotImplementedError
55 56
        end

57 58 59 60 61
        def by_category(category, project = nil)
          directory = category_directory(category)
          files = finder(project).list_files_for(directory)

          files.map { |f| new(f, project) }
62 63
        end

64 65
        def category_directory(category)
          return base_dir unless category.present?
66

67
          File.join(base_dir, categories[category])
68 69
        end

70 71 72 73
        # If template is organized by category it returns { category_name: [{ name: template_name }, { name: template2_name }] }
        # If no category is present returns [{ name: template_name }, { name: template2_name}]
        def dropdown_names(project = nil)
          return [] if project && !project.repository.exists?
74

75 76 77 78 79 80 81 82 83
          if categories.any?
            categories.keys.map do |category|
              files = self.by_category(category, project)
              [category, files.map { |t| { name: t.name } }]
            end.to_h
          else
            files = self.all(project)
            files.map { |t| { name: t.name } }
          end
84 85 86 87 88
        end
      end
    end
  end
end