Updates Registry and Raw Command loader to allow loading plugins from command files

Author: codenamev

lib/git_commander/command/loaders/raw.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative "../../loader"
+require_relative "../../plugin/loader"
 
 module GitCommander
   class Command
@@ -35,6 +36,11 @@ def command(name, &block)
           configuration_error.set_backtrace e.backtrace
           result.errors << configuration_error
         end
+
+        def plugin(name, **options)
+          plugin_result = GitCommander::Plugin::Loader.new(registry).load(name, **options)
+          result.plugins |= plugin_result.plugins
+        end
       end
     end
   end

lib/git_commander/registry.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative "loader"
+require_relative "plugin/loader"
 require_relative "command/loaders/file_loader"
 require_relative "command/loaders/raw"
 
@@ -10,10 +11,11 @@ class Registry
     class CommandNotFound < StandardError; end
     class LoadError < StandardError; end
 
-    attr_accessor :commands, :name
+    attr_accessor :commands, :name, :plugins
 
     def initialize
       @commands = {}
+      @plugins = {}
     end
 
     # Adds a command to the registry
@@ -33,12 +35,24 @@ def register_command(command)
       commands[command.name] = command
     end
 
+    # Adds a pre-built Plugin to the registry
+    # @param [Plugin] plugin the Plugin instance to add to the registry
+    def register_plugin(plugin)
+      GitCommander.logger.debug "[#{logger_tag}] Registering plugin `#{plugin.name}`..."
+
+      plugins[plugin.name] = plugin
+    end
+
     # Adds command(s) to the registry using the given loader
     #
     # @param [CommandLoader] loader the class to use to load with
     def load(loader, *args)
       result = loader.new(self).load(*args)
-      result.commands.each { |cmd| register_command(cmd) } if result.success?
+
+      if result.success?
+        result.plugins.each { |plugin| register_plugin(plugin) }
+        result.commands.each { |cmd| register_command(cmd) }
+      end
 
       result
     end

spec/lib/git_commander/command/loaders/raw_spec.rb

@@ -100,5 +100,42 @@
       expect(resulting_error.message).to include "undefined method \`danger!"
       expect(resulting_error.backtrace).to_not be_empty
     end
+
+    context "with plugins" do
+      it "registers comamnds with native plugins" do
+        raw_command_string = <<~COMMANDS
+          plugin :git
+
+          command :local_branches do |cmd = nil|
+            cmd.on_run do |options|
+              say git.branches.local.map(&:name)
+            end
+          end
+
+          command :love do
+          end
+        COMMANDS
+
+        native_plugin_loader_spy = spy("Native Plugin Loader")
+        native_plugin_loader_result = GitCommander::LoaderResult.new
+        native_plugin_loader_result.plugins << GitCommander::Plugin.new(:git, registry: registry)
+        expect(loader.result.commands).to be_empty
+        expect(GitCommander::Plugin::Loader).to receive(:new).with(registry).and_return(native_plugin_loader_spy)
+        expect(native_plugin_loader_spy).to receive(:load).with(:git, {}).and_return(native_plugin_loader_result)
+
+        loader.load(raw_command_string)
+
+        expect(loader.result.plugins.size).to eq 1
+        expect(loader.result.commands.size).to eq 2
+
+        (loader.result.commands + loader.result.plugins).flatten.each do |command_or_plugin|
+          expect(command_or_plugin.registry).to eq registry
+        end
+
+        registered_command = loader.result.commands.first
+        output = spy("output")
+        registered_command.output = output
+      end
+    end
   end
 end

spec/lib/git_commander/registry_spec.rb

@@ -97,6 +97,12 @@
     expect { registry.find(:wtf) }.to raise_error GitCommander::Registry::CommandNotFound
   end
 
+  it "allows registering pre-built plugins" do
+    plugin = GitCommander::Plugin.new(:wtf)
+    registry.register_plugin plugin
+    expect(registry.plugins[:wtf]).to eq(plugin)
+  end
+
   describe "#load(loader, options = {})" do
     it "uses the provided loader to load the given options" do
       options = { content: "command :hello do |cmd|; cmd.on_run { say 'hello' }; end" }
@@ -108,5 +114,37 @@
 
       registry.load(loader_class_spy, options)
     end
+
+    it "registers commands that are successfully loaded" do
+      options = { content: "command :hello do |cmd|; cmd.on_run { say 'hello' }; end" }
+      loader_class_spy = spy("loader class")
+      loader_instance_spy = spy("loader instance")
+      results = GitCommander::LoaderResult.new
+      results.commands = [GitCommander::Command.new(:hello)]
+
+      expect(loader_class_spy).to receive(:new).with(registry).and_return(loader_instance_spy)
+      expect(loader_instance_spy).to receive(:load).with(options).and_return(results)
+      results.commands.each do |cmd|
+        expect(registry).to receive(:register_command).with(cmd)
+      end
+
+      registry.load(loader_class_spy, options)
+    end
+
+    it "registers plugins that are successfully loaded" do
+      options = { content: "plugin :git;" }
+      loader_class_spy = spy("loader class")
+      loader_instance_spy = spy("loader instance")
+      results = GitCommander::LoaderResult.new
+      results.plugins = [GitCommander::Plugin.new(:git)]
+
+      expect(loader_class_spy).to receive(:new).with(registry).and_return(loader_instance_spy)
+      expect(loader_instance_spy).to receive(:load).with(options).and_return(results)
+      results.plugins.each do |plugin|
+        expect(registry).to receive(:register_plugin).with(plugin)
+      end
+
+      registry.load(loader_class_spy, options)
+    end
   end
 end