Redmine

/Gemfile.extension

Dir.glob(File.expand_path("plugins/*/", __dir__)) do |entry|

  next unless File.directory?(entry)

  plugin_dir = File.expand_path(entry, __dir__)

  spec = File.join plugin_dir, '*.gemspec'

  files =

    if Dir.exist? spec

      Dir.glob(File.join(plugin_dir, "PluginGemfile"))

    else

      Dir.glob(File.join(plugin_dir, "{Gemfile,PluginGemfile}"))

    end

  files.each do |file|

    eval_gemfile file

  end

end

extension_gemfile = File.join(File.dirname(__FILE__), "Gemfile.extension")

if File.exist?(extension_gemfile)

  group :redmine_extension do

    eval_gemfile extension_gemfile

  end

# vim: set ft=ruby

# Copy this file to Gemfile.extension and add any rubygem plugins

# Example:

#   gem 'redmine_sample_plugin', '~> 1.1.0'

  Redmine::PluginLoader.directories.each do |plugin_path|

    next unless plugin_path.routes

    instance_eval plugin_path.routes.read, plugin_path.routes.to_s

    plugin_name = File.basename plugin_path.to_s

    puts "An error occurred while loading the routes definition of #{plugin_name} plugin (#{plugin_path.routes}): #{e.message}."

To test if a gem plugin or gem theme is loaded, do the following

`export BUNDLE_GEMFILE=./test/fixtures/gem_extensions/Gemfile`

`bundle install`

`bin/rails test test/unit/lib/redmine/plugin_test.rb`

`bin/rails test test/unit/lib/redmine/theme_test.rb`

  # Exception raised when plugin id and gemspec metadata is not met.

  class InvalidPluginId < StandardError; end

      # Set a default attributes if it was not provided during registration

      p.set_default_attrs File.join(self.directory, id.to_s)

      loc =  caller_locations(1, 1).first.absolute_path

      if p.has_initializer? && (File.dirname(loc) != p.directory)

        raise InvalidPluginId, "The location of init.rb is different from #{p.directory}. It called from #{loc}"

      end

      # Load dependencies

      if p.gem?

        p.path.gemspec.dependencies.each do |d|

          PluginLoader.dependencies << d.name

        end

      end

    def set_default_attrs(default_dir)

      dir = directory || default_dir

      self.path = PluginLoader.find_path(plugin_id: id, plugin_dir: dir)

      if gem?

        spec = path.gemspec

        name spec.summary if spec.summary

        author spec.authors.join(",") if spec.authors

        description spec.description if spec.description

        version spec.version.to_s if spec.version

        url spec.homepage if spec.homepage

        author_url spec.metadata["author_url"] if spec.metadata["author_url"]

      end

      # Set a default name if it was not provided during registration

      name(id.to_s.humanize) if name.nil?

      # Set a default directory if it was not provided during registration

      if directory.nil?

        if path.present?

          directory(path.to_s)

        else

          directory(default_dir)

        end

      end

    end

    def gem?

      path && path.gemspec.present?

    end

    def has_initializer?

      path.present? && path.has_initializer?

    end

    attr_reader :assets_dir, :initializer, :gemspec

    def initialize(dir, gemspec = nil)

      @gemspec = gemspec

      add_autoload_paths

    end

    def add_autoload_paths

      # Add the plugin directories to rails autoload paths

      engine_cfg = Rails::Engine::Configuration.new(self.to_s)

      engine_cfg.paths.add 'lib', eager_load: true

      engine_cfg.all_eager_load_paths.each do |dir|

        Rails.autoloaders.main.push_dir dir

        Rails.application.config.watchable_dirs[dir] = [:rb]

      end

    def routes

      file = Pathname.new(@dir).join('config/routes.rb')

      if file.exist?

        file

      else

        nil

      end

    end

    class PluginIdDuplicated < StandardError; end

        PluginLoader.require_dependencies

      Dir.glob(File.join(directory, '*')).each do |dir|

        next unless File.directory?(dir)

        @plugin_directories << PluginPath.new(dir)

      # If there are plugins under plugins/, do not register a gem with the same name.

      plugin_specs.each do |spec|

        dir = File.join(directory, spec.name)

        if File.directory?(dir)

          warn "WARN: \"#{spec.name}\" plugin installed as gems also exist in the \"#{dir}\" directory; use the ones in \"#{dir}\"."

          next

        @plugin_directories << PluginPath.new(spec.full_gem_path, spec)

      end

    end

    def self.plugin_specs

      specs = Bundler.definition

                     .specs_for([:redmine_extension])

                     .to_a

                     .select{|s| s.name != 'bundler' && !s.metadata['redmine_plugin_id'].nil?}

      duplicates = specs.group_by{|s| s.metadata['redmine_plugin_id']}.reject{|k, v| v.one?}.keys

      raise PluginIdDuplicated.new("#{duplicates.join(',')} Duplicate plugin id") unless duplicates.empty?

      specs

    end

    cattr_accessor :dependencies

    self.dependencies = []

    def self.require_dependencies

      # Load dependencies. If the dependency is a redmine plugin, do not load it

      # (it should already be initialized)

      deps = dependencies - plugin_specs.map(&:name)

      deps.uniq.each do |d|

        require d

      end

    end

    def self.find_path(plugin_id:, plugin_dir:)

      path = directories.find {|d| d.gemspec.present? && d.gemspec.metadata['redmine_plugin_id'] == plugin_id.to_s }

      if path.nil?

        path = directories.find {|d| d.to_s == plugin_dir}

      path

    class ThemeIdDuplicated < StandardError; end

      attr_reader :path, :name, :dir, :gemspec

      def initialize(path, gemspec = nil)

        @gemspec = gemspec

      theme_dirs = ['app/assets/themes', 'themes']

      themes = theme_dirs.map do |theme_dir|

        Rails.root.join(theme_dir).children.select{|dir| valid_theme?(dir)}.map{|dir| Theme.new(dir)}

      directories = themes.flatten

      # If there are theme under the public dir, do not register a gem with the same name.

      gemspecs.each do |spec|

        if dir = theme_dirs.find{|theme_dir| Rails.root.join(theme_dir, spec.name).directory?}

          warn "WARN: \"#{spec.name}\" theme installed as gems also exist in the \"#{dir}\" directory; the theme in \"#{dir}\" is used."

          next

        end

        directories << Theme.new(spec.full_gem_path, spec)

      end

      directories.sort

    end

    def self.gemspecs

      specs = Bundler.definition

                     .specs_for([:redmine_extension])

                     .to_a

                     .select{|s| s.name != 'bundler' && !s.metadata['redmine_theme_id'].nil? && valid_theme?(s.full_gem_path)}

      duplicates = specs.group_by{|s| s.metadata['redmine_theme_id']}.reject{|k, v| v.one?}.keys

      raise ThemeIdDuplicated.new("#{duplicates.join(',')} Duplicate theme id") unless duplicates.empty?

      specs

    end

    def self.valid_theme?(dir)

      # A theme should at least override application.css

      File.directory?(dir) && File.exist?("#{dir}/stylesheets/application.css")

    private_class_method :scan_themes, :gemspecs, :valid_theme?

Gemfile.lock

# frozen_string_literal: true

original_gemfile = File.join(File.dirname(__FILE__), "../../../Gemfile")

eval_gemfile original_gemfile

gem 'quux', path: './quux', require: false

group :redmine_extension do

  gem 'baz', path: './baz'

  gem 'foobar', path: './foobar'

end

# frozen_string_literal: true

source "https://rubygems.org"

# Specify your gem's dependencies in baz_plugin.gemspec

gemspec

# frozen_string_literal: true

Gem::Specification.new do |spec|

  spec.name = "baz"

  spec.version = "0.0.1"

  spec.authors = ['johndoe', 'janedoe']

  spec.email = ['johndoe@example.org']

  spec.summary = "Baz Plugin"

  spec.description = "This is a gemified plugin for Redmine"

  spec.homepage = "https://example.org/plugins/baz"

  spec.required_ruby_version = ">= 3.2.0"

  spec.metadata['allowed_push_host'] = "https://example.org"

  spec.metadata['redmine_plugin_id'] = "baz_plugin"

  spec.metadata['rubygems_mfa_required'] = "true"

  spec.files = Dir["{app,lib,config,assets,db}/**/*", "init.rb", "Gemfile", "README.rdoc"]

  spec.add_dependency 'quux'

end

# frozen_string_literal: true

Redmine::Plugin.register :baz_plugin do

  name "This name should be overwritten with gemspec 'summary'"

  author_url "https://example.org/this_url_should_not_be_overwritten_with_gemspec"

end

# frozen_string_literal: true

module BazPlugin

  class Error < StandardError; end

end

# frozen_string_literal: true

source "https://rubygems.org"

# Specify your gem's dependencies in baz_plugin.gemspec

gemspec

# frozen_string_literal: true

Gem::Specification.new do |spec|

  spec.name = "foobar"

  spec.version = "0.0.1"

  spec.authors = ['johndoe', 'janedoe']

  spec.email = ['johndoe@example.org']

  spec.summary = "Foobar theme"

  spec.description = "This is a gemified theme for Redmine"

  spec.homepage = "https://example.org/themes/foobar"

  spec.required_ruby_version = ">= 3.2.0"

  spec.metadata['allowed_push_host'] = "https://example.org"

  spec.metadata['redmine_theme_id'] = "foobar_theme"

  spec.metadata['rubygems_mfa_required'] = "true"

  spec.files = Dir["{app,lib,config,assets,db}/**/*", "Gemfile"]

end

# frozen_string_literal: true

source "https://rubygems.org"

# Specify your gem's dependencies in quux.gemspec

gemspec

# frozen_string_literal: true

Redmine::Plugin.register :quux_plugin do

  # For gemmed plugins, the attributes of the plugin are described in the gemspec.

  # The correspondence between plugin attributes and gemspec is as follows

  name "This name should be overwritten with gemspec 'summary'"

  author_url "https://example.org/this_url_should_not_be_overwritten_with_gemspec"

end

# frozen_string_literal: true

module QuuxPlugin

  class Error < StandardError; end

end

# frozen_string_literal: true

Gem::Specification.new do |spec|

  # Do not use constants or variables from the gem's own code in this block, as is normally

  # done with gems. (e.g. Foo::VERSION)

  # Specify the version of redmine or dependencies between plugins in the init.rb file.

  spec.name = "quux"

  spec.version = "0.0.1"

  spec.authors = ["johndoe"]

  spec.email = ["johndoe@example.org"]

  spec.summary = "Quux plugin"

  spec.description = "This is a plugin for Redmine"

  spec.homepage = "https://example.org"

  spec.required_ruby_version = ">= 3.2.0"

  spec.metadata["author_url"] = spec.homepage

  spec.files = Dir["{lib}/**/*", "init.rb", "Gemfile"]

  # DO NOT DELETE this attribute

  spec.metadata["redmine_plugin_id"] = "quux_plugin"

  spec.metadata['rubygems_mfa_required'] = 'true'

end

# frozen_string_literal: true

Redmine::Plugin.register :baz_plugin do

  name "This name should be overwritten with gemspec 'summary'"

end

  def gemfile_for_test?

    File.expand_path(ENV['BUNDLE_GEMFILE']) == Rails.root.join('test/fixtures/gem_extensions/Gemfile').expand_path.to_s

  end

  def test_gemified_plugin

    skip unless gemfile_for_test?

    path = Redmine::PluginLoader.find_path(plugin_id: "baz_plugin", plugin_dir: nil)

    path.run_initializer

    plugin = @klass.find('baz_plugin')

    assert_equal :baz_plugin, plugin.id

    assert_equal 'Baz Plugin', plugin.name

    assert_equal 'https://example.org/plugins/baz', plugin.url

    assert_equal 'johndoe,janedoe', plugin.author

    assert_equal 'https://example.org/this_url_should_not_be_overwritten_with_gemspec', plugin.author_url

    assert_equal 'This is a gemified plugin for Redmine', plugin.description

    assert_equal '0.0.1', plugin.version

  end

  def test_gemified_plugin_depended_by_other_plugin

    skip unless gemfile_for_test?

    path = Redmine::PluginLoader.find_path(plugin_id: "quux_plugin", plugin_dir: nil)

    path.run_initializer

    plugin = @klass.find('quux_plugin')

    assert_equal :quux_plugin, plugin.id

  end

  def test_invalid_gemified_plugin

    skip unless gemfile_for_test?

    @klass.directory = Rails.root.join('test/fixtures/invalid_plugins')

    @klass.clear

    Redmine::PluginLoader.directory = @klass.directory

    Redmine::PluginLoader.setup

    plugin_dir = File.join(@klass.directory, 'qux_plugin')

    path = Redmine::PluginLoader.find_path(plugin_id: nil, plugin_dir: plugin_dir)

    e = assert_raises Redmine::InvalidPluginId do

      path.run_initializer

    end

    assert_equal "The location of init.rb is different from #{Rails.root.join('test/fixtures/gem_extensions/baz')}. It called from #{path.initializer}", e.message

  end

  def gemfile_for_test?

    File.expand_path(ENV['BUNDLE_GEMFILE']) == Rails.root.join('test/fixtures/gem_extensions/Gemfile').expand_path.to_s

  end

  def test_gemified_theme

    skip unless gemfile_for_test?

    themes = Redmine::Themes.themes

    theme = themes.find {|t| t.id == 'foobar'}

    gemspec = theme.gemspec

    assert_equal 'Foobar', theme.name

    assert_equal 'foobar', gemspec.name

    assert_equal '0.0.1', gemspec.version.to_s

  end