rexer 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 564e86a618538937d2e68d85f1b625a8fa3ebddc8e4891fb12a4598eb2f944a5
+  data.tar.gz: 4e21379d1dae8ee68c301ee0f4be43a1034b585af097a9713ae3b238a8795ffe
+SHA512:
+  metadata.gz: f542f39676156e026985ab85853133e0efe09681cf8671bf8f2370fa9f0c2301a5d0f7422cdc042219b7475f2e15b28ec35807ae12285c132dba8e4729fc9203
+  data.tar.gz: 4632bde598651690ce5b685d7d80b657ef6567fe074ce392575cf87f8b705a4ce6f3b75495a74b311d2a1b6949fca65b0a660c1b9c653b31a7086b7b4d3decf3

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2024 Katsuya Hidaka
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,157 @@
+# Rexer: Redmine Extension manager
+
+Rexer is a tool for managing Redmine Extension, which means Redmine [Plugin](https://www.redmine.org/projects/redmine/wiki/Plugins) and [Theme](https://www.redmine.org/projects/redmine/wiki/Themes) in this tool.
+
+It is mainly aimed at helping with the development of Redmine and its plugins, allowing you to define extensions in a Ruby DSL and install, uninstall, update, and switch between different sets of the extensions.
+
+[![Build](https://github.com/hidakatsuya/rexer/actions/workflows/build.yml/badge.svg)](https://github.com/hidakatsuya/rexer/actions/workflows/build.yml)
+[![Gem Version](https://badge.fury.io/rb/rexer.svg)](https://badge.fury.io/rb/rexer)
+
+## Installation
+
+Install the gem and add to the application's Gemfile by executing:
+
+    bundle add rexer
+
+If bundler is not being used to manage dependencies, install the gem by executing:
+
+    gem install rexer
+
+## Usage
+
+### Quick Start
+
+First, create a `.extensions.rb` file in the root directory of the Redmine application.
+
+```ruby
+theme :bleuclair, github: { repo: "farend/redmine_theme_farend_bleuclair", branch: "support-propshaft" }
+
+plugin :view_customize, github: { repo: "onozaty/redmine-view-customize", tag: "v3.5.2" }
+plugin :redmine_issues_panel, git: { url: "https://github.com/redmica/redmine_issues_panel", tag: "v1.0.2" }
+```
+
+Then, run the following command in the root directory of the Redmine application.
+
+```
+rex install
+```
+
+This command installs plugins and themes defined in the `.extensions.rb` file and generates the `.extensions.lock` file.
+
+> [!NOTE]
+> The `.extensions.lock` file is a file that locks the state of the installed extensions, but it's NOT a file that locks the version of the extensions.
+
+If you want to uninstall the extensions, run the following command.
+
+```
+rex uninstall
+```
+
+This command uninstalls the extensions and deletes the `.extensions.lock` file.
+
+### Commands
+
+```
+$ rex
+Commands:
+  rex help [COMMAND]  # Describe available commands or one specific command
+  rex install [ENV]   # Install extensions for the specified environment
+  rex state           # Show the current state of the installed extensions
+  rex switch [ENV]    # Uninstall extensions for the currently installed environment and install extensions for the specified environment
+  rex uninstall       # Uninstall extensions for the currently installed environment
+  rex update          # Update extensions for the currently installed environment to the latest version
+  rex version         # Show Rexer version
+```
+
+### Defining environments and extensions for the environment
+
+```ruby
+theme :bleuclair, github: { repo: "farend/redmine_theme_farend_bleuclair" }
+plugin :redmine_issues_panel, git: { url: "https://github.com/redmica/redmine_issues_panel" }
+
+env :stable do
+  theme :bleuclair, github: { repo: "farend/redmine_theme_farend_bleuclair", branch: "support-propshaft" }
+  plugin :redmine_issues_panel, git: { url: "https://github.com/redmica/redmine_issues_panel", tag: "v1.0.2" }
+end
+```
+
+In above example, the `bleuclair` theme and the `redmine_issues_panel` plugin are defined for the `default` environment. The `bleuclair` theme and the `redmine_issues_panel` plugin are defined for the `stable` environment.
+
+If you want to install extensions for the `default` environment, run the following command.
+
+```
+rex install
+or
+rex install default
+```
+
+Similarly, if you want to install extensions for the `stable` environment, run the following command.
+
+```
+rex install stable
+```
+
+In addition, you can switch between environments.
+
+```
+rex switch stable
+or
+rex install stable
+```
+
+The above command uninstalls the extensions for the currently installed environment and installs the extensions for the `stable` environment.
+
+### Defining hooks
+
+You can define hooks for each extension.
+
+```ruby
+plugin :redmica_s3, github: { repo: "redmica/redmica_s3" } do
+  installed do
+    Pathname.new("config", "s3.yml").write <<~YAML
+      access_key_id: ...
+    YAML
+  end
+
+  uninstalled do
+    Pathname.new("config", "s3.yml").delete
+  end
+
+  updated do
+    puts "updated"
+  end
+end
+```
+
+## Developing
+
+### Running integration tests
+
+First, you need to build the docker image for the integration tests.
+
+```
+rake rexer:test:build_integration_test_image
+```
+
+Then, you can run the integration tests.
+
+```
+rake test
+```
+
+### Formatting and Linting code
+
+This project uses [Standard](https://github.com/standardrb/standard) for code formatting and linting. You can format and check the code by running the following commands.
+
+```
+rake standard
+rake standard:fix
+```
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/hidakatsuya/rexer.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/bin/console

@@ -0,0 +1,10 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "rexer"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+require "irb"
+IRB.start(__FILE__)

data/bin/dev

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+
+require_relative "../lib/rexer"
+
+Rexer::Cli.start(ARGV)

data/exe/rex

@@ -0,0 +1,11 @@
+#!/usr/bin/env ruby
+
+require "rexer"
+
+begin
+  Rexer::Cli.start(ARGV)
+rescue => e
+  puts "ERROR (#{e.class}): #{e.message}"
+  puts e.backtrace if ENV["VERBOSE"]
+  exit 1
+end

data/lib/rexer/cli.rb

@@ -0,0 +1,50 @@
+require "thor"
+
+module Rexer
+  class Cli < Thor
+    def self.exit_on_failure? = true
+
+    class_option :verbose, type: :boolean, aliases: "-v", desc: "Detailed output"
+
+    desc "install [ENV]", "Install the definitions in .extensions.rb for the specified environment"
+    def install(env = "default")
+      Commands::Install.new.call(env&.to_sym)
+    end
+
+    desc "uninstall", "Uninstall extensions for the currently installed environment based on the state in .extensions.lock and remove the lock file"
+    def uninstall
+      Commands::Uninstall.new.call
+    end
+
+    desc "switch [ENV]", "Uninstall extensions for the currently installed environment and install extensions for the specified environment"
+    def switch(env = "default")
+      Commands::Switch.new.call(env&.to_sym)
+    end
+
+    desc "update", "Update extensions for the currently installed environment to the latest version"
+    def update
+      Commands::Update.new.call
+    end
+
+    desc "state", "Show the current state of the installed extensions"
+    def state
+      Commands::State.new.call
+    end
+
+    desc "version", "Show Rexer version"
+    def version
+      puts Rexer::VERSION
+    end
+
+    def initialize(*)
+      super
+      initialize_options
+    end
+
+    private
+
+    def initialize_options
+      ENV["VERBOSE"] = "1" if options[:verbose]
+    end
+  end
+end

data/lib/rexer/commands/install.rb

@@ -0,0 +1,86 @@
+module Rexer
+  module Commands
+    class Install
+      def call(env)
+        definition = load_definition(env)
+        lock_definition = load_lock_definition
+
+        if lock_definition.nil?
+          install_initially(definition)
+        elsif lock_definition.env != definition.env
+          Switch.new.call(env)
+        else
+          apply_diff(lock_definition, definition)
+        end
+      end
+
+      private
+
+      def install_initially(definition)
+        install(definition.themes, definition.plugins)
+
+        create_lock_file(definition.env)
+        print_state
+      end
+
+      def apply_diff(lock_definition, definition)
+        diff = lock_definition.diff(definition)
+
+        install(diff.added_themes, diff.added_plugins)
+        uninstall(diff.deleted_themes, diff.deleted_plugins)
+        update(diff.changed_themes, diff.changed_plugins)
+
+        create_lock_file(definition.env)
+        print_state
+      end
+
+      def load_definition(env)
+        Definition.load_data.tap { |data|
+          data.env = env
+        }
+      end
+
+      def load_lock_definition
+        Definition::Lock.load_data if Definition::Lock.file.exist?
+      end
+
+      def install(themes, plugins)
+        themes.each do
+          Extension::Theme::Installer.new(_1).install
+        end
+
+        plugins.each do
+          Extension::Plugin::Installer.new(_1).install
+        end
+      end
+
+      def uninstall(themes, plugins)
+        themes.each do
+          Extension::Theme::Uninstaller.new(_1).uninstall
+        end
+
+        plugins.each do
+          Extension::Plugin::Uninstaller.new(_1).uninstall
+        end
+      end
+
+      def update(themes, plugins)
+        themes.each do
+          Extension::Theme::Updater.new(_1).update
+        end
+
+        plugins.each do
+          Extension::Plugin::Updater.new(_1).update
+        end
+      end
+
+      def create_lock_file(env)
+        Definition::Lock.create_file(env)
+      end
+
+      def print_state
+        State.new.call
+      end
+    end
+  end
+end

data/lib/rexer/commands/state.rb

@@ -0,0 +1,55 @@
+module Rexer
+  module Commands
+    class State
+      def initialize
+        @lock_definition = Definition::Lock.load_data
+      end
+
+      def call
+        return if no_lock_file_found
+
+        puts "Rexer: #{lock_definition.version}"
+        puts "Env: #{lock_definition.env}"
+
+        print_themes
+        print_plugins
+      end
+
+      private
+
+      attr_reader :lock_definition
+
+      def print_plugins
+        plugins = lock_definition.plugins
+        return if plugins.empty?
+
+        puts "\nPlugins:"
+        plugins.each do
+          puts " * #{_1.name} (#{source_info(_1.source)})"
+        end
+      end
+
+      def print_themes
+        themes = lock_definition.themes
+        return if themes.empty?
+
+        puts "\nThemes:"
+        themes.each do
+          puts " * #{_1.name} (#{source_info(_1.source)})"
+        end
+      end
+
+      def source_info(source_def)
+        source_def.then {
+          Source.const_get(_1.type.capitalize).new(**_1.options).info
+        }
+      end
+
+      def no_lock_file_found
+        lock_definition.nil?.tap { |result|
+          puts "No lock file found" if result
+        }
+      end
+    end
+  end
+end

data/lib/rexer/commands/switch.rb

@@ -0,0 +1,33 @@
+module Rexer
+  module Commands
+    class Switch
+      def initialize
+        @lock_definition = Definition::Lock.load_data
+      end
+
+      def call(env)
+        return if no_lock_file_found
+        return if already_on(env)
+
+        Uninstall.new.call
+        Install.new.call(env)
+      end
+
+      private
+
+      attr_reader :lock_definition
+
+      def no_lock_file_found
+        lock_definition.nil?.tap { |result|
+          puts "No lock file found" if result
+        }
+      end
+
+      def already_on(env)
+        (lock_definition.env == env).tap do |result|
+          puts "Already on #{env} environment" if result
+        end
+      end
+    end
+  end
+end

data/lib/rexer/commands/uninstall.rb

@@ -0,0 +1,46 @@
+module Rexer
+  module Commands
+    class Uninstall
+      def initialize
+        @lock_definition = Definition::Lock.load_data
+      end
+
+      def call
+        return if no_lock_file_found
+
+        uninstall_themes
+        uninstall_plugins
+
+        delete_lock_file
+      end
+
+      private
+
+      attr_reader :lock_definition
+
+      def uninstall_plugins
+        lock_definition.plugins.each do
+          Extension::Plugin::Uninstaller.new(_1).uninstall
+        end
+      end
+
+      def uninstall_themes
+        lock_definition.themes.each do
+          Extension::Theme::Uninstaller.new(_1).uninstall
+        end
+      end
+
+      def delete_lock_file
+        Definition::Lock.file.then { |file|
+          file.delete if file.exist?
+        }
+      end
+
+      def no_lock_file_found
+        lock_definition.nil?.tap { |result|
+          puts "No lock file found" if result
+        }
+      end
+    end
+  end
+end

data/lib/rexer/commands/update.rb

@@ -0,0 +1,38 @@
+module Rexer
+  module Commands
+    class Update
+      def initialize
+        @lock_definition = Definition::Lock.load_data
+      end
+
+      def call
+        return if no_lock_file_found
+
+        update_themes
+        update_plugins
+      end
+
+      private
+
+      attr_reader :lock_definition
+
+      def update_plugins
+        lock_definition.plugins.each do
+          Extension::Plugin::Updater.new(_1).update
+        end
+      end
+
+      def update_themes
+        lock_definition.themes.each do
+          Extension::Theme::Updater.new(_1).update
+        end
+      end
+
+      def no_lock_file_found
+        lock_definition.nil?.tap { |result|
+          puts "No lock file found" if result
+        }
+      end
+    end
+  end
+end

data/lib/rexer/definition/data.rb

@@ -0,0 +1,27 @@
+module Rexer
+  module Definition
+    class Data
+      attr_accessor :env
+      attr_reader :version
+
+      def initialize(plugins, themes, env: nil, version: nil)
+        @plugins = plugins
+        @themes = themes
+        @env = env
+        @version = version
+      end
+
+      def plugins
+        env ? @plugins.select { _1.env == env } : @plugins
+      end
+
+      def themes
+        env ? @themes.select { _1.env == env } : @themes
+      end
+
+      def diff(other)
+        Definition::Diff.new(self, other)
+      end
+    end
+  end
+end

data/lib/rexer/definition/diff.rb

@@ -0,0 +1,56 @@
+module Rexer
+  module Definition
+    class Diff
+      def initialize(old_data, new_data)
+        @old_data = old_data
+        @new_data = new_data
+      end
+
+      def added_plugins
+        new_data.plugins - old_data.plugins
+      end
+
+      def added_themes
+        new_data.themes - old_data.themes
+      end
+
+      def deleted_plugins
+        old_data.plugins - new_data.plugins
+      end
+
+      def deleted_themes
+        old_data.themes - new_data.themes
+      end
+
+      def changed_plugins
+        old_plugins = old_data.plugins
+
+        (new_data.plugins & old_plugins).select do |new_plugin|
+          old_plugin = old_plugins.find { _1.name == new_plugin.name }
+          plugin_changed?(old_plugin, new_plugin)
+        end
+      end
+
+      def changed_themes
+        old_themes = old_data.themes
+
+        (new_data.themes & old_themes).select do |new_theme|
+          old_theme = old_themes.find { _1.name == new_theme.name }
+          theme_changed?(old_theme, new_theme)
+        end
+      end
+
+      private
+
+      attr_reader :old_data, :new_data
+
+      def plugin_changed?(old_plugin, new_plugin)
+        old_plugin.source != new_plugin.source
+      end
+
+      def theme_changed?(old_theme, new_theme)
+        old_theme.source != new_theme.source
+      end
+    end
+  end
+end

data/lib/rexer/definition/dsl.rb

@@ -0,0 +1,62 @@
+module Rexer
+  module Definition
+    class Dsl
+      def initialize(env = :default)
+        @plugins = []
+        @themes = []
+        @env = env
+      end
+
+      def plugin(name, **opts, &hooks)
+        @plugins << Definition::Plugin.new(
+          name: name,
+          source: build_source(opts),
+          hooks: build_hooks(hooks, %i[installed uninstalled updated]),
+          env: @env
+        )
+      end
+
+      def theme(name, **opts, &hooks)
+        @themes << Definition::Theme.new(
+          name: name,
+          source: build_source(opts),
+          hooks: build_hooks(hooks, %i[installed uninstalled updated]),
+          env: @env
+        )
+      end
+
+      def env(env_name, &dsl)
+        data = self.class.new(env_name).tap { _1.instance_eval(&dsl) }.to_data
+
+        @plugins += data.plugins
+        @themes += data.themes
+      end
+
+      def to_data
+        Definition::Data.new(@plugins, @themes)
+      end
+
+      private
+
+      def build_hooks(definition_hooks, availabe_hooks)
+        return nil if definition_hooks.nil?
+
+        hook_dsl = Class.new do
+          def hooks = @hooks ||= {}
+
+          availabe_hooks.each do |hook_name|
+            define_method(hook_name) { |&block| hooks[hook_name] = block }
+          end
+        end.new
+
+        hook_dsl.instance_eval(&definition_hooks)
+        hook_dsl.hooks
+      end
+
+      def build_source(opts)
+        type = opts.keys.find { Rexer::Source::Base.source_names.include?(_1) }
+        Source.new(type, opts[type]) if type
+      end
+    end
+  end
+end

data/lib/rexer/definition/lock.rb

@@ -0,0 +1,41 @@
+module Rexer
+  module Definition
+    module Lock
+      def self.file
+        @file ||= Pathname.new(Rexer.definition_lock_file)
+      end
+
+      def self.load_data
+        return nil unless file.exist?
+
+        dsl = Dsl.new.tap { _1.instance_eval(file.read) }
+        dsl.to_data
+      end
+
+      def self.create_file(env)
+        dsl = <<~DSL
+          lock version: "#{Rexer::VERSION}", env: :#{env}
+
+          #{Definition.file.read}
+        DSL
+        file.write(dsl)
+      end
+
+      class Dsl < Definition::Dsl
+        def lock(env:, version:)
+          lock_state.update(env:, version:)
+        end
+
+        def to_data
+          Definition::Data.new(@plugins, @themes, **lock_state)
+        end
+
+        private
+
+        def lock_state
+          @lock_state ||= {}
+        end
+      end
+    end
+  end
+end

data/lib/rexer/definition.rb

@@ -0,0 +1,32 @@
+module Rexer
+  module Definition
+    module ExtensionComparable
+      def eql?(other)
+        name == other.name
+      end
+
+      def hash
+        name.hash
+      end
+    end
+
+    Source = ::Data.define(:type, :options)
+
+    Plugin = ::Data.define(:name, :source, :hooks, :env) do
+      include ExtensionComparable
+    end
+
+    Theme = ::Data.define(:name, :source, :hooks, :env) do
+      include ExtensionComparable
+    end
+
+    def self.file
+      @file ||= Pathname.new(Rexer.definition_file)
+    end
+
+    def self.load_data
+      dsl = Dsl.new.tap { _1.instance_eval(file.read) }
+      dsl.to_data
+    end
+  end
+end

data/lib/rexer/extension/plugin.rb

@@ -0,0 +1,104 @@
+require "open3"
+
+module Rexer
+  module Extension
+    module Plugin
+      def self.dir
+        Pathname.new("plugins")
+      end
+
+      class Base
+        def initialize(definition)
+          @definition = definition
+          @name = definition.name
+          @hooks = definition.hooks || {}
+        end
+
+        private
+
+        attr_reader :name, :hooks, :definition
+
+        def plugin_dir
+          @plugin_dir ||= Plugin.dir.join(name.to_s)
+        end
+
+        def plugin_exists?
+          plugin_dir.exist? && !plugin_dir.empty?
+        end
+
+        def needs_db_migration?
+          plugin_dir.join("db", "migrate").then {
+            _1.exist? && !_1.empty?
+          }
+        end
+
+        def run_db_migrate(extra_envs = {})
+          return unless needs_db_migration?
+
+          envs = {"NAME" => name.to_s}.merge(extra_envs)
+          _, error, status = Open3.capture3(envs, "bin/rails redmine:plugins:migrate")
+
+          raise error unless status.success?
+        end
+
+        def source
+          @source ||= definition.source.then do |src|
+            Source.const_get(src.type.capitalize).new(**src.options)
+          end
+        end
+      end
+
+      class Installer < Base
+        def install
+          return if plugin_exists?
+
+          load_from_source
+          run_db_migrate
+          hooks[:installed]&.call
+        end
+
+        private
+
+        def load_from_source
+          source.load(plugin_dir.to_s)
+        end
+      end
+
+      class Uninstaller < Base
+        def uninstall
+          return unless plugin_exists?
+
+          reset_db_migration
+          remove_plugin
+          hooks[:uninstalled]&.call
+        end
+
+        private
+
+        def reset_db_migration
+          run_db_migrate("VERSION" => "0")
+        end
+
+        def remove_plugin
+          plugin_dir.rmtree
+        end
+      end
+
+      class Updater < Base
+        def update
+          return unless plugin_exists?
+
+          update_source
+          run_db_migrate
+          hooks[:updated]&.call
+        end
+
+        private
+
+        def update_source
+          source.update(plugin_dir.to_s)
+        end
+      end
+    end
+  end
+end

data/lib/rexer/extension/theme.rb

@@ -0,0 +1,80 @@
+module Rexer
+  module Extension
+    module Theme
+      def self.dir
+        Pathname.new("themes")
+      end
+
+      class Base
+        def initialize(definition)
+          @definition = definition
+          @name = definition.name
+          @hooks = definition.hooks || {}
+        end
+
+        private
+
+        attr_reader :name, :hooks, :definition
+
+        def theme_dir
+          @theme_dir ||= Theme.dir.join(name.to_s)
+        end
+
+        def theme_exists?
+          theme_dir.exist? && !theme_dir.empty?
+        end
+
+        def source
+          @source ||= definition.source.then do |src|
+            Source.const_get(src.type.capitalize).new(**src.options)
+          end
+        end
+      end
+
+      class Installer < Base
+        def install
+          return if theme_exists?
+
+          load_from_source
+          hooks[:installed]&.call
+        end
+
+        private
+
+        def load_from_source
+          source.load(theme_dir.to_s)
+        end
+      end
+
+      class Uninstaller < Base
+        def uninstall
+          return unless theme_exists?
+
+          remove_theme
+          hooks[:uninstalled]&.call
+        end
+
+        private
+
+        def remove_theme
+          theme_dir.rmtree
+        end
+      end
+
+      class Updater < Base
+        def update
+          return unless theme_exists?
+
+          update_source
+          hooks[:updated]&.call
+        end
+
+        private
+
+        def update_source
+          source.update(theme_dir.to_s)
+        end
+      end
+    end
+  end
+end

data/lib/rexer/source/base.rb

@@ -0,0 +1,21 @@
+module Rexer
+  module Source
+    class Base
+      def self.source_names = @source_names ||= []
+
+      def self.inherited(subclass)
+        source_names << subclass.name.split("::").last.downcase.to_sym
+      end
+
+      def load(_path)
+        raise "Not implemented"
+      end
+
+      def update(_path)
+        raise "Not implemented"
+      end
+
+      def info = ""
+    end
+  end
+end

data/lib/rexer/source/git.rb

@@ -0,0 +1,35 @@
+require "git"
+
+module Rexer
+  module Source
+    class Git < Base
+      def initialize(url:, branch: nil, tag: nil, ref: nil)
+        @url = url
+        @branch = branch
+        @tag = tag
+        @ref = ref
+      end
+
+      def load(path)
+        ::Git.clone(url, path).then { checkout(_1) }
+      end
+
+      def update(path)
+        FileUtils.rm_rf(path)
+        load(path)
+      end
+
+      def info
+        branch || tag || ref || "master"
+      end
+
+      private
+
+      attr_reader :url, :branch, :tag, :ref
+
+      def checkout(git)
+        (branch || tag || ref)&.then { git.checkout(_1) }
+      end
+    end
+  end
+end

data/lib/rexer/source/github.rb

@@ -0,0 +1,9 @@
+module Rexer
+  module Source
+    class Github < Git
+      def initialize(repo:, branch: nil, tag: nil, ref: nil)
+        super(url: "https://github.com/#{repo}", branch: branch, tag: tag, ref: ref)
+      end
+    end
+  end
+end

data/lib/rexer/version.rb

@@ -0,0 +1,3 @@
+module Rexer
+  VERSION = "0.1.0"
+end

data/lib/rexer.rb

@@ -0,0 +1,16 @@
+module Rexer
+  def self.definition_file
+    ".extensions.rb"
+  end
+
+  def self.definition_lock_file
+    ".extensions.lock"
+  end
+end
+
+require "pathname"
+require "zeitwerk"
+
+loader = Zeitwerk::Loader.for_gem
+loader.setup
+loader.eager_load

metadata

@@ -0,0 +1,112 @@
+--- !ruby/object:Gem::Specification
+name: rexer
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Katsuya Hidaka
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2024-08-14 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: thor
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: git
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.1'
+- !ruby/object:Gem::Dependency
+  name: zeitwerk
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.6'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.6'
+description: Rexer is a tool for managing Redmine Extension (Plugin and Themes). It
+  allows you to define extensions in a Ruby DSL and install, uninstall, update, and
+  switch between different sets of the extensions.
+email:
+- hidakatsuya@gmail.com
+executables:
+- rex
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE.txt
+- README.md
+- bin/console
+- bin/dev
+- exe/rex
+- lib/rexer.rb
+- lib/rexer/cli.rb
+- lib/rexer/commands/install.rb
+- lib/rexer/commands/state.rb
+- lib/rexer/commands/switch.rb
+- lib/rexer/commands/uninstall.rb
+- lib/rexer/commands/update.rb
+- lib/rexer/definition.rb
+- lib/rexer/definition/data.rb
+- lib/rexer/definition/diff.rb
+- lib/rexer/definition/dsl.rb
+- lib/rexer/definition/lock.rb
+- lib/rexer/extension/plugin.rb
+- lib/rexer/extension/theme.rb
+- lib/rexer/source/base.rb
+- lib/rexer/source/git.rb
+- lib/rexer/source/github.rb
+- lib/rexer/version.rb
+homepage: https://github.com/hidakatsuya/rexer
+licenses:
+- MIT
+metadata:
+  source_code_uri: https://github.com/hidakatsuya/rexer
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.11
+signing_key:
+specification_version: 4
+summary: A tool for managing Redmine Plugins and Themes
+test_files: []