monoz 0.4.0 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e73d1688f568042f98029b57b070f6541c3a19ba0ae206c7f89a3ecb60dda061
-  data.tar.gz: 3f9a57bfc7abacf3bf67783e713d3e92bcc6bea586c0c8c53b1b298c3ecfc990
+  metadata.gz: a4b5b401a4bf7239ed13540d493ca21b270307357e9e0c6aa4eaadacb7b0a887
+  data.tar.gz: 0537ac18ffe150db50875fb8c1dd7537019792d50616cef4693f4fbf9192913d
 SHA512:
-  metadata.gz: 4d5a0d391b17475e9a5d0a05a1bacf8815d5f8d23ed79608dabd1fd31c4df491dad9fa0f33c9ae058e69ffaaa1138a4c0def0cb4e5e1a752ff13281822191fd0
-  data.tar.gz: ae0449a70ae6c4b0a8474fd4d80fc8d39e26c4316b2a6191eccf16e3a6dc55bbc310902db0a0fae04423d35ca3421b8f016e3594dcb8a72df07b585c03483d26
+  metadata.gz: d2c82d448831e9cfec6901a3dcc09b9b2531a63621849a2def1c4b50aa2f150547148ef01a454eb7f57012922da93560fd3884f497ba79a9965f227be4e78abe
+  data.tar.gz: a569b1c68211574c5e03beeb87a6d95b9cc7047d41c692c095f0e63168e5aec03fcc6bb3fe1f01c7ce0d6d980393148b7da327f9926df6e35655a32b73f18e59

data/README.md

@@ -2,7 +2,7 @@
 
 Monoz is a command-line tool that helps you manage your **ruby** monorepo. It provides an easy way to manage multiple related **ruby** projects and their dependencies in a single repository. Monoz helps you keep track of your projects and their interdependencies, making it easier to maintain and scale your codebase. 
 
-## Installation
+## Getting started
 
 You can install Monoz by running the following command:
 
@@ -10,8 +10,6 @@ You can install Monoz by running the following command:
 $ gem install monoz
 ```
 
-## Getting started
-
 To initialize a Monoz repository in the current directory, simply run:
 
 ```console
@@ -29,7 +27,9 @@ This will create a new Monoz repo with the following structure:
 └── monoz.yml
 ```
 
-### Adding projects
+## Projects
+
+### Add a project
 
 Once you've initialized your Monoz repository, you can start adding projects to it.
 
@@ -72,6 +72,13 @@ To update the dependencies of all projects in the Monoz repository, simply run:
 
 ```console
 $ monoz bundle update
+
+kiqr_core: bundle update ✓
+content_api: bundle update ✓
+core_api: bundle update ✓
+kiqr_cloud: bundle update ✓
+
+The command ran successfully in all projects without any errors.
 ```
 
 Note that when you add a new dependency to a project, you'll need to run `monoz bundle` to update its `Gemfile.lock` file before you can use the new dependency. Similarly, if you update the dependencies of a project's `Gemfile`, you'll need to run `monoz bundle` to update its `Gemfile.lock` file with the new versions.
@@ -95,6 +102,27 @@ Error: The command bundle exec rubocop failed to run in one or more project dire
 
 This will execute the `bundle exec rubocop` command in each project directory, ensuring that all the necessary dependencies are installed and loaded for each project. Similarly, you can run other bundler commands such as `bundle install`, `bundle update`, and so on, by appending the desired arguments to the `monoz bundle` command.
 
+### List projects
+
+You can inspect the projects in your Monoz repository using the `monoz projects` command. This command will display a table that shows the projects in the repository, their type (app or gem), the gem name (if it's a gem), the test framework(s) used, and the projects that depend on them.
+
+Here's an example output of the `monoz projects` command:
+
+```console
+$ monoz projects
+
+o---------------o--------o-------------o---------------------o-------------------------------------o
+|  Project      |  Type  |  Gem Name   |  Test Framework(s)  |  Dependants                         |
+o---------------o--------o-------------o---------------------o-------------------------------------o
+|  content_api  |  app   |             |  rspec              |                                     |
+|  core_api     |  app   |             |  rspec              |                                     |
+|  kiqr_cloud   |  app   |             |  rspec              |                                     |
+|  kiqr_core    |  gem   |  kiqr_core  |  rspec              |  content_api, core_api, kiqr_cloud  |
+o---------------o--------o-------------o---------------------o-------------------------------------o
+```
+
+## Runing commands
+
 ### Running commands in projects
 
 You can run any command in all projects of your Monoz repository using the `monoz run` command. Simply provide the command you want to run as an argument, and Monoz will execute it in each project directory.
@@ -144,20 +172,32 @@ example_com: bin/dev
 23:41:06 css.1  | Done in 354ms.
 ```
 
-### Filter projects
+### Filtering projects
 
 The `--filter` option in Monoz allows you to select certain projects based on specific criteria. This is useful if you only want to run a command on a specific subset of projects, rather than all of them. To use the `--filter` option, you simply specify a filter expression after the option. The filter expression is a comma-separated list of keywords that match the project names or tags in your Monoz configuration.
 
-For example, suppose you have a Monoz configuration with several projects, some of which are tagged as **apps** and some of which are tagged as **gems**. You can use the "--filter" option to select only the **apps** projects by running the following command:
+For example, suppose you have a Monoz configuration with several projects, some of which are tagged as **apps** and some of which are tagged as **gems**. You can use the `--filter` option to select only the **apps** projects by running the following command:
 
 ```console
 $ monoz bundle --filter=apps
+
+content_api: bundle ✓
+core_api: bundle ✓
+kiqr_cloud: bundle ✓
+
+The command ran successfully in all project directories without any errors.
 ```
 
 Similarly, if you only want to list only gem projects, you can use the following command:
 
 ```console
 $ monoz projects --filter=gems
+
+o-------------o--------o-------------o----------------------o-------------------------------------o
+|  Project    |  Type  |  Gem name   |  Found Framework(s)  |  Dependants                         |
+o-------------o--------o-------------o----------------------o-------------------------------------o
+|  kiqr_core  |  gem   |  kiqr_core  |  rspec               |  content_api, core_api, kiqr_cloud  |
+o-------------o--------o-------------o----------------------o-------------------------------------o
 ```
 
 You can also use multiple keywords in the filter expression to select projects that match any of the keywords. For example, to run the `mrsk deploy` command on all **apps** and **apis** projects, you can use the following command:
@@ -172,25 +212,6 @@ Finally, you can also specify individual project names in the filter expression.
 $ monoz run rubocop --filter="gem1,gem2"
 ```
 
-### List projects
-
-You can inspect the projects in your Monoz repository using the `monoz projects` command. This command will display a table that shows the projects in the repository, their type (app or gem), the gem name (if it's a gem), the test framework(s) used, and the projects that depend on them.
-
-Here's an example output of the `monoz projects` command:
-
-```console
-$ monoz projects
-
-o---------------o--------o-------------o---------------------o-------------------------------------o
-|  Project      |  Type  |  Gem Name   |  Test Framework(s)  |  Dependants                         |
-o---------------o--------o-------------o---------------------o-------------------------------------o
-|  content_api  |  app   |             |  rspec              |                                     |
-|  core_api     |  app   |             |  rspec              |                                     |
-|  kiqr_cloud   |  app   |             |  rspec              |                                     |
-|  kiqr_core    |  gem   |  kiqr_core  |  rspec              |  content_api, core_api, kiqr_cloud  |
-o---------------o--------o-------------o---------------------o-------------------------------------o
-```
-
 ## Contributing
 We welcome contributions from everyone! If you're interested in contributing to Monoz, please check out our contributing guidelines for more information.
 

data/lib/monoz/action.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Monoz
+  class ActionCommand
+    attr_reader :filter, :command
+    def initialize(filter, command)
+      @filter = filter
+      @command = command
+    end
+  end
+
+  class Action
+    attr_reader :name, :commands
+
+    def initialize(name, raw_commands)
+      @name = name
+      @commands = []
+      parse_commands(raw_commands)
+    end
+
+    private
+      def parse_commands(raw_commands)
+        raw_commands.each do |command|
+          @commands << Monoz::ActionCommand.new(command.dig("in"), command.dig("run"))
+        end
+      end
+  end
+end

data/lib/monoz/action_collection.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/module/delegation"
+
+module Monoz
+  class ActionCollection
+    include Enumerable
+    delegate_missing_to :@items
+
+    def initialize
+      @items = []
+      populate_items
+    end
+
+    def exist?(name)
+      !!find(name)
+    end
+
+    def find(name)
+      @items.select { |i| i.name == name.to_s }&.first
+    end
+
+    def all
+      @items
+    end
+
+    private
+      def populate_items
+        actions = Monoz.config.dig("actions")
+        return if actions.empty?
+
+        raise "Invalid format, actions must be a hash." unless actions.is_a?(Hash)
+
+        actions.each do |action_name, config_raw_data|
+          @items << Monoz::Action.new(action_name, config_raw_data)
+        end
+      end
+  end
+end

data/lib/monoz/application.rb

@@ -6,7 +6,7 @@ require "fileutils"
 
 module Monoz
   class Application < Thor
-    class_option :tty, type: :boolean, aliases: ["--verbose", "-t"], default: false
+    class_option :verbose, type: :boolean, aliases: ["--tty", "-t"], default: false
     class_option :filter
 
     def initialize(*args)
@@ -49,5 +49,11 @@ module Monoz
     def version
       say "Monoz version: #{Monoz::VERSION}"
     end
+
+    # This method will be called when a command is not found
+    desc "[ACTION]", "Custom action"
+    def method_missing(action_name, *args)
+      Monoz::Services::ActionService.new(self).call(action_name)
+    end
   end
 end

data/lib/monoz/project_collection.rb

@@ -11,7 +11,7 @@ module Monoz
 
     def initialize(file_path)
       @items = []
-      project_folders = Monoz.config.dig("folders") || ["apps", "gems"]
+      project_folders = Monoz.folders
 
       search_paths = project_folders.map { |folder| File.join(file_path, folder) }
 

data/lib/monoz/services/action_service.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require "yaml"
+require "fileutils"
+
+module Monoz
+  module Services
+    class ActionService < Monoz::Services::BaseService
+      def call(action)
+        @action = Monoz.actions.find(action)
+        say_invalid_action(action) if @action.nil?
+        Monoz.verbose = true
+        run_action
+      end
+
+      private
+        def run_action
+          say "Running Monoz action: "
+          say @action.name, [:bold, :blue]
+
+          @action.commands.each do |action_command|
+            projects = Monoz.projects.filter(action_command.filter).order(:dependants)
+            command = action_command.command.split(" ")
+            Monoz::Services::RunService.new(self).call(projects, *command)
+          end
+        end
+
+        def say_invalid_action(cmd_or_action)
+          say "Error: The command or action ", :red
+          say "#{cmd_or_action} ", [:red, :bold]
+          say "does not exist.", [:red]
+          exit(1)
+        end
+    end
+  end
+end

data/lib/monoz/services/run_service.rb

@@ -2,35 +2,44 @@
 
 require "yaml"
 require "fileutils"
-require "open3"
+require "pty"
 
 module Monoz
-  module Services
-    class RunService < Monoz::Services::BaseService
-      attr_reader :errors, :warnings
+  module Responses
+    class RunServiceResponse
+      attr_reader :output, :exit_code
 
-      def initialize(thor_instance)
-        @projects = nil
-        @errors = []
-        @warnings = []
-        super(thor_instance)
+      def initialize(output, exit_code)
+        @output = output
+        @exit_code = exit_code
       end
 
       def success?
-        !errors? && !warnings?
+        exit_code == 0
       end
 
-      def errors?
-        @errors.any?
+      def failed?
+        !!success?
       end
+    end
+  end
 
-      def warnings?
-        @warnings.any?
+  module Services
+    class RunService < Monoz::Services::BaseService
+      attr_reader :errors, :warnings
+
+      def initialize(thor_instance)
+        super(thor_instance)
+        @projects = nil
+        @errors = []
+        @warnings = []
+        @command = []
       end
 
       def call(projects, *command)
-        raise ArgumentError.new("Missing command") if command.empty?
+        raise ArgumentError, "Missing command" if command.empty?
 
+        @command = command
         if projects.is_a?(Monoz::ProjectCollection)
           @projects = projects.all
         elsif projects.is_a?(Monoz::Project)
@@ -39,30 +48,16 @@ module Monoz
           raise "Invalid projects"
         end
 
-        @projects.each do |project|
-          say "#{project.name}: ", [:bold, :blue]
-          Monoz.tty? ? say(command.join(" ")) : say("#{command.join(" ")} ")
-
-          response = run_commands_in_project(project, *command)
-
-          if response.success?
-            say "\u2713", [:green, :bold] unless Monoz.tty? # Checkmark symbol in green and bold
-          else
-            say "\u2717", [:red, :bold] unless Monoz.tty? # Cross symbol in red
-            say response.output
-            say ""
-            @errors << {
-              project: project.name,
-              command: command.join(" "),
-              exit_code: response.exit_code,
-              output: response.output
-            }
-          end
-        end
+        say "Running ", nil, false
+        say command.join(" "), [:bold], false
+        say " in #{@projects.map { |p| p.name }.join(", ")}:"
 
+        say ""
+        run_commands
         say ""
 
         if errors?
+          say ""
           say "Error: The command ", :red
           say "#{command.join(" ")} ", [:red, :bold]
           say "failed to run in one or more project directories", [:red]
@@ -70,32 +65,74 @@ module Monoz
         end
       end
 
+      def success?
+        !errors? && !warnings?
+      end
+
+      def errors?
+        @errors.any?
+      end
+
+      def warnings?
+        @warnings.any?
+      end
+
       private
-        def run_commands_in_project(project, *command)
-          raise ArgumentError.new("Invalid command") if command.empty?
+        def run_commands
+          @projects.each do |project|
+            if spinner?
+              spinner = Monoz::Spinner.new(@command.join(" "), prefix: project.name).start
+            else
+              say "[#{project.name}] ", [:blue, :bold], nil
+              say @command.join(" ")
+            end
+
+            response = run_in_project(project, *@command)
+
+            if response.success?
+              spinner&.success! if spinner?
+            else
+              spinner&.error! if spinner?
+              say response.output
+              say "" # line break
+              @errors << {
+                project: project.name,
+                command: @command.join(" "),
+                exit_code: response.exit_code,
+                output: response.output
+              }
+            end
+          end
+        end
+
+        def spinner?
+          !Monoz.verbose?
+        end
+
+        def run_in_project(project, *command)
+          raise ArgumentError, "Invalid command" if command.empty?
 
           output = ""
           exit_status = nil
 
           FileUtils.chdir(project.root_path) do
-            if Monoz.tty?
-              Open3.popen2e(*command.map { |arg| Shellwords.escape(arg) }) do |stdin, stdout_err, wait_thr|
-                while line = stdout_err.gets
+            PTY.spawn(*command.map { |arg| Shellwords.escape(arg) }) do |stdout, stdin, pid|
+              begin
+                stdout.each do |line|
                   output += line
-                  print line
+                  print line if Monoz.verbose?
                 end
-
-                exit_status = wait_thr.value.exitstatus
+              rescue Errno::EIO
               end
 
-              say ""
-            else
-              output, status = Open3.capture2e(*command.map { |arg| Shellwords.escape(arg) })
-              exit_status = status.exitstatus
+              Process.wait(pid)
+              exit_status = $?.exitstatus
             end
           end
 
-          return Monoz::Responses::CaptureRunResponse.new(output, exit_status)
+          Monoz::Responses::RunServiceResponse.new(output, exit_status)
+        rescue Errno::ENOENT => e
+          Monoz::Responses::RunServiceResponse.new(e.message, 1)
         end
     end
   end

data/lib/monoz/spinner.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module Monoz
+  class Spinner
+    include Thor::Shell
+
+    def initialize(message, prefix: nil)
+      @spinner = nil
+      @message = message
+      @prefix = prefix
+    end
+
+    def start
+      @spinner = main
+      self
+    end
+
+    def success!
+      @spinner.kill
+      say_formatted(" \u2713 ", [:bold, :green])
+      say() # line break
+    end
+
+    def error!
+      @spinner.kill
+      say_formatted(" \u2717 ", [:bold, :red])
+      say() # line break
+    end
+
+    private
+      def reset
+        say("\r", nil, false)
+      end
+
+      def say_formatted(suffix, suffix_formatting = nil)
+        if @prefix != nil
+          say "\r[#{@prefix}] ", [:blue, :bold], nil
+          say @message, nil, false
+          say suffix, suffix_formatting, false
+        else
+          say "\r#{@message}", nil, false
+          say suffix, suffix_formatting, false
+        end
+      end
+
+      def main
+        spinner_count = 0
+
+        Thread.new do
+          loop do
+            dots = case spinner_count % 3
+                   when 0 then "."
+                   when 1 then ".."
+                   when 2 then "..."
+            end
+
+            say_formatted(dots)
+            spinner_count += 1
+            sleep(0.5)
+          end
+        end
+      end
+  end
+end

data/lib/monoz/version.rb

@@ -1,3 +1,3 @@
 module Monoz
-  VERSION = "0.4.0"
+  VERSION = "0.5.0"
 end

data/lib/monoz.rb

@@ -11,35 +11,20 @@ module Monoz
     class ConfigurationNotFound < StandardError; end
   end
 
-  module Responses
-    class CaptureRunResponse
-      attr_reader :output, :exit_code
-
-      def initialize(output, exit_code)
-        @output = output
-        @exit_code = exit_code
-      end
-
-      def success?
-        exit_code == 0
-      end
-
-      def error?
-        exit_code == 1
-      end
-    end
-  end
-
   module Services
+    autoload "ActionService", "monoz/services/action_service"
     autoload "BaseService", "monoz/services/base_service"
     autoload "InitService", "monoz/services/init_service"
     autoload "RunService", "monoz/services/run_service"
   end
 
+  autoload "Action", "monoz/action"
+  autoload "ActionCollection", "monoz/action_collection"
   autoload "Application", "monoz/application"
   autoload "Configuration", "monoz/configuration"
   autoload "Project", "monoz/project"
   autoload "ProjectCollection", "monoz/project_collection"
+  autoload "Spinner", "monoz/spinner"
 
   class << self
     def app
@@ -54,12 +39,24 @@ module Monoz
       @config ||= Monoz::Configuration.new(pwd)
     end
 
+    def actions
+      @actions ||= Monoz::ActionCollection.new
+    end
+
     def options
       @app&.options
     end
 
-    def tty?
-      Monoz.options.dig("tty") == true
+    def folders
+      config.dig("folders") || ["apps", "gems"]
+    end
+
+    def verbose?
+      @verbose ||= Monoz.options.dig("verbose") == true
+    end
+
+    def verbose=(value)
+      @verbose = value
     end
 
     def projects

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: monoz
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.5.0
 platform: ruby
 authors:
 - kjellberg
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-04-04 00:00:00.000000000 Z
+date: 2023-04-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: thor
@@ -64,13 +64,17 @@ files:
 - README.md
 - bin/monoz
 - lib/monoz.rb
+- lib/monoz/action.rb
+- lib/monoz/action_collection.rb
 - lib/monoz/application.rb
 - lib/monoz/configuration.rb
 - lib/monoz/project.rb
 - lib/monoz/project_collection.rb
+- lib/monoz/services/action_service.rb
 - lib/monoz/services/base_service.rb
 - lib/monoz/services/init_service.rb
 - lib/monoz/services/run_service.rb
+- lib/monoz/spinner.rb
 - lib/monoz/version.rb
 homepage: https://github.com/kjellberg/monoz
 licenses:
@@ -94,7 +98,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.5
+rubygems_version: 3.4.10
 signing_key:
 specification_version: 4
 summary: Command line tool for managing ruby monorepos.