redmine_plugins_helper 0.5.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 474a2a3d3fd82a0eeedd525edad8db6adaf84f1fda9785e910ffbe06046d8f47
+  data.tar.gz: 309ff8226411dadced5b3639b0bff781c8d41ed307f2451ee865317ddc2d2e08
+SHA512:
+  metadata.gz: c1714ab95b6af124afe772dbb1e196323a655ef907cd83865ceb6088915a91176f0e739ad9e172909d4141b412ef4fb129e37219cb8278f2e0c2860303488ede
+  data.tar.gz: 582161dbc0800d84c89a5ea5faa6a0f2620843123239337083878e44e92db8ad1fd406f2502cd08d51f96a37955ea62fbb98c22081b81f32f0ba599238aa19c4

data/app/assets/javascripts/plugins_autoload.js.erb

@@ -0,0 +1,5 @@
+<% Redmine::Plugin.registered_plugins.values.each do |plugin| %>
+  <% if plugin.main_javascript_asset_path %>
+    <% require_asset plugin.main_javascript_asset_path %>
+  <% end %>
+<% end %>

data/app/assets/stylesheets/plugins_autoload.scss.erb

@@ -0,0 +1,5 @@
+<% Redmine::Plugin.registered_plugins.values.each do |plugin| %>
+  <% if plugin.main_stylesheet_asset_path %>
+@import "<%= plugin.main_stylesheet_asset_path %>";
+  <% end %>
+<% end %>

data/config/initializers/assets.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+require 'redmine_plugins_helper/hooks/add_assets'
+Rails.application.config.assets.precompile += %w[plugins_autoload.css plugins_autoload.js]

data/config/initializers/backport_pg_10_support_to_rails_4.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require 'active_record/connection_adapters/postgresql/schema_statements'
+
+#
+# Monkey-patch the refused Rails 4.2 patch at https://github.com/rails/rails/pull/31330
+#
+# Updates sequence logic to support PostgreSQL 10.
+#
+
+module ActiveRecord
+  module ConnectionAdapters
+    module PostgreSQL
+      module SchemaStatements
+        # Resets the sequence of a table's primary key to the maximum value.
+        def reset_pk_sequence!(table, pkey = nil, sequence = nil) #:nodoc:
+          unless pkey && sequence
+            default_pk, default_sequence = pk_and_sequence_for(table)
+            pkey ||= default_pk
+            sequence ||= default_sequence
+          end
+          reset_pk_sequence_log(sequence, table, pkey)
+          return unless pkey && sequence
+
+          reset_pk_sequence_select_value(sequence, table, pkey)
+        end
+
+        private
+
+        def reset_pk_sequence_max_pk(table, pkey)
+          select_value("SELECT MAX(#{quote_column_name pkey}) FROM #{quote_table_name(table)}")
+        end
+
+        def reset_pk_sequence_minvalue(max_pk, quoted_sequence)
+          return nil unless max_pk.nil?
+
+          if postgresql_version >= 100_000
+            select_value('SELECT seqmin FROM pg_sequence WHERE seqrelid = ' \
+                "#{quote(quoted_sequence)}::regclass")
+          else
+            select_value("SELECT min_value FROM #{quoted_sequence}")
+          end
+        end
+
+        def reset_pk_sequence_log(sequence, table, pkey)
+          return unless @logger && pkey && !sequence
+
+          @logger.warn "#{table} has primary key #{pkey} with no default sequence"
+        end
+
+        def reset_pk_sequence_select_value(sequence, table, pkey)
+          quoted_sequence = quote_table_name(sequence)
+          max_pk = reset_pk_sequence_max_pk(table, pkey)
+          minvalue = reset_pk_sequence_minvalue(max_pk, quoted_sequence)
+          select_value <<-END_SQL, 'SCHEMA'
+            SELECT setval(#{quote(quoted_sequence)}, #{max_pk || minvalue}, #{max_pk ? true : false})
+          END_SQL
+        end
+      end
+    end
+  end
+end

data/init.rb

@@ -0,0 +1,18 @@
+# coding: utf-8
+
+require 'redmine'
+require 'redmine_plugins_helper/version'
+require 'redmine_plugins_helper/patches/test_case_patch'
+
+Redmine::Plugin.register :redmine_plugins_helper do
+  name 'Redmine Plugins\' Helper'
+  author ::RedminePluginsHelper::AUTHOR
+  description ::RedminePluginsHelper::SUMMARY
+  version ::RedminePluginsHelper::VERSION
+end
+
+Rails.configuration.to_prepare do
+  require_dependency 'redmine_plugins_helper/patches/redmine/plugin_patch'
+  ::Redmine::Plugin.registered_plugins.values.each(&:add_assets_paths)
+  ::Redmine::Plugin.registered_plugins.values.each(&:load_initializers)
+end

data/lib/redmine_plugins_helper/fix_migrations.rb

@@ -0,0 +1,100 @@
+module RedminePluginsHelper
+  class FixMigrations
+    def initialize
+      run
+    end
+
+    private
+
+    def run
+      database_plugins_versions.each do |dbv|
+        check_database_version(dbv)
+      end
+      Rails.logger.info("Database versions checked: #{database_plugins_versions.count}")
+      Rails.logger.info("Local versions found: #{local_versions.count}")
+    end
+
+    def check_database_version(dbv)
+      lv = local_version(dbv[:timestamp])
+      return unless lv && lv.count == 1 && dbv[:plugin] != lv.first[:plugin]
+      fix_plugin_version(dbv, lv.first[:plugin])
+    end
+
+    def fix_plugin_version(dbv, target_plugin)
+      target_version = plugin_version(target_plugin, dbv[:timestamp])
+      if database_version?(target_version)
+        remove_plugin_version(dbv[:version])
+      else
+        move_plugin_version(dbv[:version], target_version)
+      end
+    end
+
+    def database_version?(version)
+      r = ::ActiveRecord::Base.connection.execute(<<EOS.strip_heredoc)
+        select exists(
+          select 1
+          from #{ActiveRecord::Migrator.schema_migrations_table_name}
+          where version=#{ActiveRecord::Base.sanitize(version)}
+        )
+EOS
+      r.getvalue(0, 0) == 't'
+    end
+
+    def remove_plugin_version(source_version)
+      Rails.logger.info("Removing #{source_version}")
+      ::ActiveRecord::Base.connection.execute(<<EOS.strip_heredoc)
+        delete from #{ActiveRecord::Migrator.schema_migrations_table_name}
+        where version=#{ActiveRecord::Base.sanitize(source_version)}
+EOS
+    end
+
+    def move_plugin_version(source_version, target_version)
+      Rails.logger.info("Moving #{source_version} to plugin \"#{target_version}\"")
+      ::ActiveRecord::Base.connection.execute(<<EOS.strip_heredoc)
+        update #{ActiveRecord::Migrator.schema_migrations_table_name}
+        set version=#{ActiveRecord::Base.sanitize(target_version)}
+        where version=#{ActiveRecord::Base.sanitize(source_version)}
+EOS
+    end
+
+    def local_version(timestamp)
+      return [] unless local_versions.key?(timestamp)
+      local_versions[timestamp]
+    end
+
+    def local_versions
+      @local_versions = begin
+        r = {}
+        Redmine::Plugin.registered_plugins.values.each do |p|
+          p.migrations.each do |m|
+            r[m] ||= []
+            r[m] << { plugin: p.id, timestamp: m, version: plugin_version(p.id, m) }
+          end
+        end
+        r
+      end
+    end
+
+    def database_plugins_versions
+      @database_plugins_versions = begin
+        r = []
+        ::RedminePluginsHelper::Migrations.db_all_versions.each do |v|
+          pv = parse_plugin_version(v)
+          next unless pv
+          r << pv
+        end
+        r
+      end
+    end
+
+    def parse_plugin_version(v)
+      h = ::RedminePluginsHelper::Migrations.parse_plugin_version(v)
+      h[:version] = v if h.is_a?(Hash)
+      h
+    end
+
+    def plugin_version(plugin_id, timestamp)
+      "#{timestamp}-#{plugin_id}"
+    end
+  end
+end

data/lib/redmine_plugins_helper/hooks/add_assets.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module RedminePluginsHelper
+  module Hooks
+    class AddAssets < Redmine::Hook::ViewListener
+      def view_layouts_base_html_head(_context = {})
+        safe_join([plugins_autoload_stylesheet_tag, plugins_autoload_script_tag])
+      end
+
+      private
+
+      def plugins_autoload_stylesheet_tag
+        tag('link', media: 'all', rel: 'stylesheet',
+                    href: asset_path('assets/plugins_autoload.css'))
+      end
+
+      def plugins_autoload_script_tag
+        content_tag('script', "\n", src: asset_path('assets/plugins_autoload.js'))
+      end
+    end
+  end
+end

data/lib/redmine_plugins_helper/migrate.rb

@@ -0,0 +1,41 @@
+module RedminePluginsHelper
+  class Migrate
+    def initialize
+      run
+    end
+
+    private
+
+    def run
+      versions_sorted.each do |v|
+        migrate_plugin_version(v)
+      end
+    end
+
+    def migrate_plugin_version(v)
+      return if migrated?(v)
+      ::Redmine::Plugin.registered_plugins[v[:plugin]].migrate(v[:timestamp])
+    end
+
+    def versions_sorted
+      versions.sort_by { |e| [e[:timestamp]] }
+    end
+
+    def versions
+      r = []
+      ::RedminePluginsHelper::Migrations.local_versions.each do |plugin, ts|
+        ts.each { |t| r << { plugin: plugin, timestamp: t } }
+      end
+      r
+    end
+
+    def migrated?(v)
+      return false unless db_versions.key?(v[:plugin])
+      db_versions[v[:plugin]].include?(v[:timestamp])
+    end
+
+    def db_versions
+      @db_versions ||= ::RedminePluginsHelper::Migrations.db_versions
+    end
+  end
+end

data/lib/redmine_plugins_helper/migrations.rb

@@ -0,0 +1,38 @@
+module RedminePluginsHelper
+  class Migrations
+    class << self
+      def local_versions
+        r = {}
+        Redmine::Plugin.registered_plugins.values.each do |p|
+          p.migrations.each do |ts|
+            r[p.id] ||= []
+            r[p.id] << ts
+          end
+        end
+        r
+      end
+
+      def db_versions
+        r = {}
+        db_all_versions.each do |v|
+          pv = parse_plugin_version(v)
+          next unless pv
+          r[pv[:plugin]] ||= []
+          r[pv[:plugin]] << pv[:timestamp]
+        end
+        r
+      end
+
+      def db_all_versions
+        ::ActiveRecord::SchemaMigration.create_table
+        ::ActiveRecord::SchemaMigration.all.pluck(:version)
+      end
+
+      def parse_plugin_version(v)
+        m = v.match(/^(\d+)\-(\S+)$/)
+        return nil unless m
+        { plugin: m[2].to_sym, timestamp: m[1].to_i }
+      end
+    end
+  end
+end

data/lib/redmine_plugins_helper/patches/redmine/plugin_patch.rb

@@ -0,0 +1,76 @@
+module RedminePluginsHelper
+  module Patches
+    module Redmine
+      module PluginPatch
+        extend ActiveSupport::Concern
+
+        included do
+          extend ClassMethods
+          include InstanceMethods
+        end
+
+        ASSETS_SUBDIRS = %w[stylesheets javascripts images].freeze
+
+        module ClassMethods
+          def post_register(plugin_name, &block)
+            plugin = registered_plugins[plugin_name]
+            raise "Plugin not registered: #{plugin_name}" unless plugin
+
+            plugin.instance_eval(&block)
+          end
+        end
+
+        module InstanceMethods
+          def load_initializers
+            Dir["#{initializers_directory}/*.rb"].each { |f| require f }
+          end
+
+          ASSETS_SUBDIRS.each do |assert_subdir|
+            class_eval <<-RUBY_EVAL, __FILE__, __LINE__ + 1
+            def #{assert_subdir}_directory
+              ::File.join(directory, 'app', 'assets', '#{assert_subdir}')
+            end
+            RUBY_EVAL
+          end
+
+          def add_assets_paths
+            ASSETS_SUBDIRS.each do |assert_subdir|
+              assets_directory = send("#{assert_subdir}_directory")
+              next unless ::File.directory?(assets_directory)
+
+              Rails.application.config.assets.paths << assets_directory
+            end
+          end
+
+          def main_javascript_asset_path
+            find_asset(javascripts_directory, %w[js coffee js.coffee])
+          end
+
+          def main_stylesheet_asset_path
+            find_asset(stylesheets_directory, %w[css scss])
+          end
+
+          private
+
+          def initializers_directory
+            File.join(directory, 'config', 'initializers')
+          end
+
+          def find_asset(assets_directory, extensions)
+            extensions.each do |extension|
+              ['', '.erb'].each do |erb_extension|
+                path = ::File.join(assets_directory, "#{id}.#{extension}#{erb_extension}")
+                return id if ::File.exist?(path)
+              end
+            end
+            nil
+          end
+        end
+      end
+    end
+  end
+end
+
+patch = ::RedminePluginsHelper::Patches::Redmine::PluginPatch
+target = ::Redmine::Plugin
+target.send(:include, patch) unless target.include?(patch)

data/lib/redmine_plugins_helper/patches/test_case_patch.rb

@@ -0,0 +1,30 @@
+require 'active_support'
+
+module RedminePluginsHelper
+  module Patches
+    module TestCasePatch
+      extend ActiveSupport::Concern
+
+      included do
+        extend ClassMethods
+      end
+
+      module ClassMethods
+        def plugin_fixtures(plugin_name, *files)
+          fixtures_dir = File.expand_path(
+            'test/fixtures',
+            ::Redmine::Plugin.registered_plugins[plugin_name].directory
+          )
+          ActiveRecord::FixtureSet.create_fixtures(fixtures_dir, files)
+          fixtures(*files)
+        end
+      end
+    end
+  end
+end
+
+unless ActiveSupport::TestCase.included_modules.include?(
+  RedminePluginsHelper::Patches::TestCasePatch
+)
+  ActiveSupport::TestCase.send(:include, RedminePluginsHelper::Patches::TestCasePatch)
+end

data/lib/redmine_plugins_helper/settings.rb

@@ -0,0 +1,25 @@
+require_dependency 'redmine_plugins_helper'
+
+module RedminePluginsHelper
+  class Settings
+    class << self
+      def default(plugin, default)
+        return unless ::RedminePluginsHelper.settings_table_exist?
+        p = plugin_current_setting_value(plugin)
+        default.each do |k, v|
+          p[k.to_s] = v unless p.key?(k)
+        end
+        ::Setting.send("plugin_#{plugin}=", p)
+      end
+
+      private
+
+      def plugin_current_setting_value(plugin)
+        p = ::Setting.send("plugin_#{plugin}")
+        p = {} unless p.is_a?(::Hash)
+        p = p.with_indifferent_access
+        p
+      end
+    end
+  end
+end

data/lib/redmine_plugins_helper/status_migrations.rb

@@ -0,0 +1,31 @@
+module RedminePluginsHelper
+  class StatusMigrations
+    def initialize
+      run
+    end
+
+    private
+
+    def run
+      local_versions.each do |plugin, timestamps|
+        timestamps.each do |timestamp|
+          m = migrated_version?(plugin, timestamp) ? 'up' : 'down'
+          puts "#{m}\t#{plugin}\t#{timestamp}"
+        end
+      end
+    end
+
+    def migrated_version?(plugin, timestamp)
+      db_versions.key?(plugin) &&
+        db_versions[plugin].include?(timestamp)
+    end
+
+    def local_versions
+      @local_versions ||= ::RedminePluginsHelper::Migrations.local_versions
+    end
+
+    def db_versions
+      @db_versions ||= ::RedminePluginsHelper::Migrations.db_versions
+    end
+  end
+end

data/lib/redmine_plugins_helper/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module RedminePluginsHelper
+  AUTHOR = 'Eduardo Henrique Bogoni'
+  SUMMARY = 'Helper for Redmine plugins'
+  VERSION = '0.5.2'
+end

data/lib/redmine_plugins_helper.rb

@@ -0,0 +1,9 @@
+require 'sass-rails'
+
+module RedminePluginsHelper
+  class << self
+    def settings_table_exist?
+      ActiveRecord::Base.connection.table_exists? ::Setting.table_name
+    end
+  end
+end

data/lib/tasks/redmine_plugins_helper.rake

@@ -0,0 +1,27 @@
+Rake::Task['redmine:plugins:migrate'].clear
+
+namespace :redmine do
+  desc 'Run migrations of core Redmine and installed plugins.'
+  task migrate: ['db:migrate', 'redmine:plugins:migrate:fix', 'redmine:plugins:migrate'] do
+  end
+
+  namespace :plugins do
+    desc 'Migrates installed plugins.'
+    task migrate: :environment do
+      RedminePluginsHelper::Migrate.new
+      Rake::Task['db:schema:dump'].invoke
+    end
+
+    namespace :migrate do
+      desc 'Fix migrations moved from a plugin to another'
+      task fix: :environment do
+        RedminePluginsHelper::FixMigrations.new
+      end
+
+      desc 'Show migrations status of all plugins'
+      task status: :environment do
+        RedminePluginsHelper::StatusMigrations.new
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,72 @@
+--- !ruby/object:Gem::Specification
+name: redmine_plugins_helper
+version: !ruby/object:Gem::Version
+  version: 0.5.2
+platform: ruby
+authors:
+- 0.5.2
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2019-08-26 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: sass-rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+description: 
+email: 
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- app/assets/javascripts/plugins_autoload.js.erb
+- app/assets/stylesheets/plugins_autoload.scss.erb
+- config/initializers/assets.rb
+- config/initializers/backport_pg_10_support_to_rails_4.rb
+- init.rb
+- lib/redmine_plugins_helper.rb
+- lib/redmine_plugins_helper/fix_migrations.rb
+- lib/redmine_plugins_helper/hooks/add_assets.rb
+- lib/redmine_plugins_helper/migrate.rb
+- lib/redmine_plugins_helper/migrations.rb
+- lib/redmine_plugins_helper/patches/redmine/plugin_patch.rb
+- lib/redmine_plugins_helper/patches/test_case_patch.rb
+- lib/redmine_plugins_helper/settings.rb
+- lib/redmine_plugins_helper/status_migrations.rb
+- lib/redmine_plugins_helper/version.rb
+- lib/tasks/redmine_plugins_helper.rake
+homepage: 
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.7.7
+signing_key: 
+specification_version: 4
+summary: Helper for Redmine plugins
+test_files: []