monoz 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 3809e6abcde49688db77aeb2c395d7293a68528ac2a3a3fab51a753de5040048
+  data.tar.gz: 138e119bf0ba056dd1f1ca54061b1d24e5c507a25e42a035a8639d2d548900e2
+SHA512:
+  metadata.gz: 5b52995d260a8ef32d5ee8341624f80e96ab5836b35995033ecbb2cc54987757102d0e4b8b4e9cebe1bf28190ce5895d8d5f6896700ec17e1d43bfccd3c28ff3
+  data.tar.gz: fb384e4182854c0ab3633869e62283306af0a24f3bb030e99bc43514f1bf68f5107651b344480f4b22838890963d9233b50a3d7e31a83c55ef53fbeaf1ae2895

data/README.md

@@ -0,0 +1,98 @@
+# Monoz
+
+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
+
+You can install Monoz by running the following command:
+
+```console
+$ gem install monoz
+```
+
+## Getting started
+
+To initialize a Monoz repository in the current directory, simply run:
+
+```console
+$ monoz init
+```
+*For a specific directory, provide the path as an argument.*
+
+
+This will create a new Monoz repo with the following structure:
+
+```
+├── .git
+├── apps
+├── gems
+└── monoz.yml
+```
+
+### Adding projects
+
+Once you've initialized your Monoz repository, you can start adding projects to it.
+
+To add a new project, simply create a new directory in either the `apps/` or `gems/` directory, depending on whether it's an application or a library.
+
+For example, a Monoz repository with both a frontend and a backend application that shares the same libraries could look like this:
+
+```
+├── .git
+├── apps
+│   ├── example-com
+│   └── example-com-admin
+├── gems
+│   ├── myengine
+│   ├── sharedmodels
+│   └── privatelibrary
+└── monoz.yml
+```
+
+### Bundle projects
+
+To manage the dependencies of your projects, you can use the monoz bundle command. This command will create a new Gemfile.lock file in each project directory based on the dependencies specified in their respective Gemfiles.
+
+To bundle all the projects in the Monoz repository, simply run:
+
+```console
+$ monoz bundle
+```
+
+This will create a `Gemfile.lock` file for each project in the repository.
+
+If you want to update the dependencies of your projects, you can use the `monoz bundle update` command. This command will update the `Gemfile.lock` file of each project based on the latest available versions of their dependencies.
+
+To update the dependencies of all projects in the Monoz repository, simply run:
+
+```console
+$ monoz bundle update
+```
+
+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.
+
+### Inspect projects
+
+You can inspect the projects in your Monoz repository using the monoz inspect 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 inspect command:
+
+```console
+$ monoz inspect
+
+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.
+
+## License
+
+Monoz is released under the MIT License.

data/bin/monoz

@@ -0,0 +1,11 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "monoz"
+
+begin
+  Monoz::Cli::Main.start(ARGV)
+rescue Monoz::Errors::ConfigurationNotFound
+  puts "This is not a valid Monoz directory."
+  puts "Run monoz init to initialize Monoz in the current directory."
+end

data/lib/monoz/cli/bundle.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require "thor"
+require "yaml"
+
+module Monoz
+  module Cli
+    class Bundle < Thor
+      default_task :install
+
+      desc "install", "Install dependencies in all projects"
+      def install
+        Monoz.projects.order(:dependants).each do |project|
+          say "#{project.type} ", project.text_color, false
+          say "[#{project.name}] ", [:blue, :bold], false
+          say "bundle install", :green
+          project.run "bundle", "install"
+        end
+      end
+
+      desc "update", "Update dependencies in all projects"
+      def update
+        Monoz.projects.order(:dependants).each do |project|
+          say "#{project.type} ", project.text_color, false
+          say "[#{project.name}] ", [:blue, :bold], false
+          say "bundle update", :green
+          project.run "bundle", "update"
+        end
+      end
+    end
+  end
+end

data/lib/monoz/cli/inspect.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require "thor"
+require "yaml"
+
+module Monoz
+  module Cli
+    class Inspect < Thor
+      default_task :all
+
+      desc "all", "Returns a list of all projects in this monozrepo"
+      def all
+        Monoz.projects.order(:name).to_table
+      end
+
+      desc "apps", "Returns a list of apps in this monozrepo"
+      def apps
+        Monoz.projects.order(:name).filter(:apps).to_table
+      end
+
+      desc "gems", "Returns a list of gems in this monozrepo"
+      def gems
+        Monoz.projects.filter(:gems).order(:name).to_table
+      end
+    end
+  end
+end

data/lib/monoz/cli/main.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require "thor"
+require "yaml"
+require "fileutils"
+
+module Monoz
+  module Cli
+    class Main < Thor
+      desc "init [PATH]", "Initialize a monozrepo at the specified PATH"
+      def init(path = ".")
+        Monoz::Services::InitService.new(self).call(path)
+      end
+
+      desc "bundle", "Run bundle commands in all projects"
+      subcommand "bundle", Monoz::Cli::Bundle
+
+      desc "inspect", "Inspect this monozrepo"
+      subcommand "inspect", Monoz::Cli::Inspect
+
+      map "run" => "run_action"
+      desc "run [action]", "Run commands in all projects"
+      def run_action(keys = nil)
+        return help("run") if keys.nil? || keys == "help"
+
+        Monoz::Services::RunActionService.new(self).call(keys)
+      end
+
+      desc "version", "Get the current version of Monoz"
+      def version
+        say "Monoz version: #{Monoz::VERSION}"
+      end
+    end
+  end
+end

data/lib/monoz/configuration.rb

@@ -0,0 +1,43 @@
+require "yaml"
+require "active_support/core_ext/module/delegation"
+
+module Monoz
+  class Configuration
+    attr_reader :config_file_path
+    delegate_missing_to :@contents
+
+    def initialize(project_path)
+      @config_file_path = find_config_file(project_path)
+      raise Monoz::Errors::ConfigurationNotFound.new("Configuration not found at: #{project_path}") unless @config_file_path
+      @contents = load_config(@config_file_path) || {}
+    end
+
+    def contents
+      @contents ||= load_config(@config_file_path) if @config_file_path
+    end
+
+    def root_path
+      File.dirname @config_file_path
+    end
+
+    class << self
+      def default_config
+        { "folders" => ["apps", "gems"] }
+      end
+    end
+
+    private
+    def find_config_file(dir_path)
+      while dir_path != "/"
+        config_file_path = File.join(dir_path, "monoz.yml")
+        return config_file_path if File.exist?(config_file_path)
+
+        dir_path = File.dirname(dir_path)
+      end
+    end
+
+    def load_config(config_file_path)
+      YAML.load_file(config_file_path)
+    end
+  end
+end

data/lib/monoz/project.rb

@@ -0,0 +1,123 @@
+module Monoz
+  class Project
+    attr_reader :name, :root_path, :gemspec, :type, :dependencies, :gem_name, :dependants
+
+    def initialize(root_path)
+      @root_path = root_path
+    
+      parse_project_files
+      parse_dependencies
+
+      setup_instance_variables
+    end
+
+    def is_gem?
+      !gemspec_path.nil?
+    end
+
+    def valid?
+      @root_path != nil && gemfile_path != nil
+    end
+
+    def run(*command)
+      FileUtils.chdir(root_path) do
+        system(*command)
+      end
+    end
+
+    def text_color
+      is_gem? ? :green : :blue
+    end
+
+    def test_frameworks
+      frameworks = []
+
+      rspec_files = Dir.glob(File.join(@root_path, "**/*_spec.rb"))
+      if !rspec_files.empty?
+        frameworks << "rspec"
+      end
+
+      minitest_files = Dir.glob(File.join(@root_path, "test/**/*_test.rb"))
+      if !minitest_files.empty?
+        frameworks << "minitest"
+      end
+
+      frameworks
+    end
+
+    private
+    def parse_project_files
+      @gemspec = parse_gemspec
+    end
+
+    def parse_dependencies
+      @dependencies = gem_dependencies
+    end
+
+    def parse_gemspec
+      return nil unless (gemspec_file = gemspec_path) && File.exist?(gemspec_file)
+
+      spec = Gem::Specification.load(gemspec_file)
+      {
+        name: spec.name,
+        version: spec.version.to_s
+      }
+    end
+
+    def setup_instance_variables
+      @name = File.basename(root_path)
+      @gem_name = @gemspec.dig(:name) if is_gem?
+      @type = is_gem? ? "gem" : "app"
+      @test_frameworks = 
+      @dependants = []
+    end
+
+    def gemspec_path
+      Dir.glob(File.join(@root_path, "*.gemspec")).first
+    end
+
+    def gemfile_path
+      Dir.glob(File.join(@root_path, "Gemfile")).first
+    end
+
+    def gem_dependencies
+      dependencies = {}
+
+      # Check if a Gemfile exists
+      if (gemfile = gemfile_path) && File.exist?(gemfile)
+        gemfile_content = File.read(gemfile)
+
+        # Use regex to find all gem entries
+        gem_entries = gemfile_content.scan(/gem\s+['"]([^'"]+)['"](?:,\s*['"]([^'"]+)['"])?(?:,\s*['"]([^'"]+)['"])?/)
+        
+        # Add each gem and its version to the hash
+        gem_entries.each do |gem_entry|
+          gem_name = gem_entry[0]
+          version_spec = gem_entry[1] || ""
+          dependencies[gem_name] = version_spec
+        end
+      end
+
+      # Check if a gemspec exists
+      if (gemspec_file = gemspec_path) && File.exist?(gemspec_file)
+        spec = Gem::Specification.load(gemspec_file)
+        spec.dependencies.each do |dep|
+          dependencies[dep.name] = dep.requirement.to_s
+        end
+      end
+
+      dependencies
+    end
+
+    public
+
+    # Update dependants of this project based on other projects in the collection
+    def update_dependants(collection)
+      collection.each do |project|
+        if project.dependencies.key?(name)
+          project.dependants << self
+        end
+      end
+    end
+  end
+end

data/lib/monoz/project_collection.rb

@@ -0,0 +1,121 @@
+require "pathname"
+require "active_support/core_ext/module/delegation"
+require "terminal-table"
+
+module Monoz
+  class ProjectCollection
+    include Enumerable
+    delegate_missing_to :@items
+
+    def initialize(file_path)
+      @items = []
+      project_folders = Monoz.config.dig("folders") || ["apps", "gems"]
+
+      search_paths = project_folders.map { |folder| File.join(file_path, folder) }
+      
+      search_paths.each do |search_path|
+        Dir.glob(File.join(search_path, "*/Gemfile")).each do |gemfile_path|
+          project_path = File.dirname(gemfile_path)
+          project = Project.new(project_path)
+          if project.valid?
+            @items << project 
+            refresh_dependants(project)
+          end
+        end
+      end
+    end
+
+    def exist?(name)
+      !!find(name)
+    end
+
+    def find(name)
+      @items.select { |i| i.name == name }&.first
+    end
+
+    def all
+      @items
+    end
+
+    def order(key)
+      if key.to_sym == :name
+        @items = order_by_name
+        self
+      elsif key.to_sym == :dependants
+        @items = order_by_dependants
+        self
+      else
+        raise "Invalid order key: #{key}"
+      end
+    end
+
+    def filter(key)
+      if key.to_sym == :apps
+        @items = @items.select { |i| i.type == "app" }
+        self
+      elsif key.to_sym == :gems
+        @items = @items.select { |i| i.type == "gem" }
+        self
+      else
+        raise "Invalid filter key: #{key}"
+      end
+    end
+
+    def to_table
+      rows = []
+      @items.each do |project|
+        rows << [project.name, project.type, project.gem_name, project.test_frameworks.join(", "), project.dependants.join(", ")]
+      end
+      table = Terminal::Table.new(
+        headings: ["Project", "Type", "Gem Name", "Test Framework(s)", "Dependants"],
+        rows: rows,
+        style: { padding_left: 2, padding_right: 2, border_i: "o" },
+      )
+      puts table
+    end
+
+    private
+      def refresh_dependants(project)
+        @items.each do |other_project|
+          next if other_project == project
+          other_project.dependencies.each do |dep_name, _|
+            if dep_name == project.gem_name
+              project.dependants << other_project.name
+              break
+            end
+          end
+        end
+      end
+
+      def order_by_name
+        @items.sort_by(&:name)
+      end
+
+      def order_by_dependants
+        sorted_items = []
+        items = @items.dup # make a copy of items to avoid modifying @items
+        dependants = Hash.new { |h, k| h[k] = [] }
+
+        # build a hash of dependants for each project
+        items.each do |project|
+          project.dependants.each do |dependant|
+            dependants[dependant] << project.name
+          end
+        end
+
+        # perform a topological sort
+        until items.empty?
+          no_dependencies = items.select { |project| dependants[project.name].empty? }
+          raise "Circular dependency detected" if no_dependencies.empty?
+          sorted_items.concat(no_dependencies)
+          no_dependencies.each do |project|
+            items.delete(project)
+            dependants.each { |_, v| v.delete(project.name) }
+          end
+        end
+
+        sorted_items
+      end
+
+  end
+end

data/lib/monoz/services/base_service.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require "yaml"
+require "fileutils"
+
+module Monoz
+  module Services
+    class BaseService
+      include Thor::Shell
+
+      def initialize(thor_instance)
+        @thor = thor_instance
+      end
+
+      class << self
+        def call(path)
+          new(path).call
+        end
+      end
+    end
+  end
+end

data/lib/monoz/services/init_service.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require "yaml"
+require "fileutils"
+
+module Monoz
+  module Services
+    class InitService < Monoz::Services::BaseService
+      def call(path)
+        config_file_path = File.join(File.expand_path(path), "monoz.yml")
+        project_dir = File.dirname(config_file_path)
+
+        if File.exist?(config_file_path)
+          @thor.say "Error: monoz.yaml already exists in #{config_file_path}", :red
+          return
+        end
+
+        FileUtils.mkdir_p(project_dir)
+        FileUtils.mkdir_p(File.join(project_dir, "apps"))
+        FileUtils.mkdir_p(File.join(project_dir, "gems"))
+        FileUtils.touch(File.join(project_dir, "apps/.keep"))
+        FileUtils.touch(File.join(project_dir, "gems/.keep"))
+        File.write(config_file_path, Monoz::Configuration.default_config.to_yaml)
+
+        FileUtils.chdir(project_dir) do
+          system "git", "init"
+        end
+
+        @thor.say "Successfully initialized Monoz in #{project_dir}", :green
+      end
+    end
+  end
+end

data/lib/monoz/services/run_action_service.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require "yaml"
+require "fileutils"
+
+module Monoz
+  module Services
+    class RunActionService < Monoz::Services::BaseService
+      def call(keys = nil)
+        action = Monoz.config.dig("actions", *keys)
+
+        if action.nil?
+          say "Invalid action: ", :red, false
+          say keys, [:red, :bold]
+          exit 0
+        end
+
+        pp action
+        # Monoz.projects.order(:dependants).each do |project|
+        #   project.run "ls"
+        # end
+      end
+    end
+  end
+end

data/lib/monoz/version.rb

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

data/lib/monoz.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require_relative "monoz/version"
+
+require "pathname"
+
+module Monoz
+  module Errors
+    class ConfigurationNotFound < StandardError; end
+  end
+
+  module Cli
+    autoload "Bundle", "monoz/cli/bundle"
+    autoload "Inspect", "monoz/cli/inspect"
+    autoload "Main", "monoz/cli/main"
+    autoload "Run", "monoz/cli/run"
+  end
+
+  module Services
+    autoload "BaseService", "monoz/services/base_service"
+    autoload "InitService", "monoz/services/init_service"
+    autoload "RunActionService", "monoz/services/run_action_service"
+  end
+
+  autoload "Configuration", "monoz/configuration"
+  autoload "Project", "monoz/project"
+  autoload "ProjectCollection", "monoz/project_collection"
+
+  class << self
+    def config
+      @config ||= Monoz::Configuration.new(pwd)
+    end
+
+    def projects
+      Monoz::ProjectCollection.new(config.root_path)
+    end
+
+    def pwd
+      @pwd ||= Pathname.new(Dir.pwd)
+    end
+
+    def pwd=(value)
+      @pwd = value
+    end
+  end
+end

metadata

@@ -0,0 +1,102 @@
+--- !ruby/object:Gem::Specification
+name: monoz
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- kjellberg
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2023-04-04 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: thor
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '7'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '7'
+- !ruby/object:Gem::Dependency
+  name: terminal-table
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.0.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.0.1
+description: Command line tool for managing ruby monorepos.
+email:
+- 2277443+kjellberg@users.noreply.github.com
+executables:
+- monoz
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- bin/monoz
+- lib/monoz.rb
+- lib/monoz/cli/bundle.rb
+- lib/monoz/cli/inspect.rb
+- lib/monoz/cli/main.rb
+- lib/monoz/configuration.rb
+- lib/monoz/project.rb
+- lib/monoz/project_collection.rb
+- lib/monoz/services/base_service.rb
+- lib/monoz/services/init_service.rb
+- lib/monoz/services/run_action_service.rb
+- lib/monoz/version.rb
+homepage: https://github.com/kjellberg/monoz
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/kjellberg/monoz
+  source_code_uri: https://github.com/kjellberg/monoz
+  changelog_uri: https://github.com/kjellberg/monoz
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.6.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.4.5
+signing_key:
+specification_version: 4
+summary: Command line tool for managing ruby monorepos.
+test_files: []