mono_repo_deps 0.1.13

data/lib/mono_repo_deps/package/initializer.rb

@@ -0,0 +1,38 @@
+require 'benchmark'
+
+class MonoRepoDeps::Package::Initializer
+  include MonoRepoDeps::Mixins
+
+  Inject = MonoRepoDeps::Deps[
+    "package.dependency_bypasser",
+    "package.repo"
+  ]
+
+  include Inject
+
+  sig do
+    params(
+      package_name: T.any(Symbol, String),
+      env: Symbol,
+      imported: T::Array[Symbol]
+    )
+    .void
+  end
+  def call(package_name, env:, imported: [])
+    package_name = package_name.to_sym
+    packages_import_order = []
+
+    time = Benchmark.realtime do
+      packages_import_order = dependency_bypasser
+        .call(package_name: package_name, env: env, imported: imported)
+        .map { repo.find(_1) }
+        .each { MonoRepoDeps.current_project.loader.push_dir(_1.workdir_path) }
+        .tap { MonoRepoDeps.current_project.loader.setup }
+        .each { |package| require package.entrypoint_file if File.exist?(package.entrypoint_file) }
+    end
+
+    puts "imported package '#{package_name}' with #{packages_import_order.size} dependencies in #{'%.2f' % time} seconds for env: #{env}"
+
+    nil
+  end
+end

data/lib/mono_repo_deps/package/list.rb

@@ -0,0 +1,10 @@
+class MonoRepoDeps::Package::List
+  include MonoRepoDeps::Mixins
+
+  sig do
+    returns(T::Array[MonoRepoDeps::Package])
+  end
+  def call
+    MonoRepoDeps.current_project.packages
+  end
+end

data/lib/mono_repo_deps/package/repo.rb

@@ -0,0 +1,55 @@
+class MonoRepoDeps::Package::Repo
+  include MonoRepoDeps::Mixins
+
+  Inject = MonoRepoDeps::Deps[
+    "package.list",
+  ]
+
+  include Inject
+
+  sig do
+    returns(T::Array[MonoRepoDeps::Package])
+  end
+  def all
+    list.call
+  end
+
+  sig do
+    params(
+      name: T.nilable(T.any(String, Symbol)),
+    )
+    .returns(T::Array[MonoRepoDeps::Package])
+  end
+  def filter(name: nil)
+    packages = all
+
+    unless name.nil?
+      names = name.is_a?(Array) ? name : [name]
+      names = names.map(&:to_sym)
+
+      packages = packages.select { names.include?(_1.name) }
+    end
+
+    packages
+  end
+
+  sig do
+    params(
+      package_name: T.nilable(T.any(String, Symbol)),
+    )
+    .returns(T.nilable(MonoRepoDeps::Package))
+  end
+  def find(package_name)
+    all.detect { _1.name == package_name.to_sym }
+  end
+
+  sig do
+    params(
+      package_name: T.nilable(T.any(String, Symbol)),
+    )
+    .returns(MonoRepoDeps::Package)
+  end
+  def find!(package_name)
+    find(package_name) || (raise StandardError.new("package '#{package_name}' was not found for MonoRepoDeps project '#{MonoRepoDeps.current_project.root_path}'"))
+  end
+end

data/lib/mono_repo_deps/package.rb

@@ -0,0 +1,48 @@
+class MonoRepoDeps::Package
+  include MonoRepoDeps::Mixins
+
+  attr_reader :name, :root_path, :dependencies, :configs
+
+  DEFAULT_ENV = :_default_
+
+  DependencyDto = Struct.new(:name, :only, :skip, keyword_init: true)
+
+  sig do
+    params(
+      name: Symbol,
+      root_path: String,
+      package_dirname: String,
+      dependencies: T::Hash[Symbol, DependencyDto]
+    )
+    .void
+  end
+  def initialize(name:, root_path:, package_dirname:, dependencies:)
+    @name = name
+    @root_path = root_path
+    @package_dirname = package_dirname
+    @dependencies = dependencies
+
+    nil
+  end
+
+  sig do
+    params(env: T.nilable(Symbol)).returns(T::Array[DependencyDto])
+  end
+  def get_dependencies(env = nil)
+    [DEFAULT_ENV, env].uniq.compact.inject([]) do |acc, item|
+      acc += @dependencies.fetch(item, [])
+    end
+  end
+
+  def get_dependency_envs
+    @dependencies.keys
+  end
+
+  def workdir_path
+    File.join( self.root_path, @package_dirname )
+  end
+
+  def entrypoint_file
+    File.join( self.workdir_path, "#{name}.rb" )
+  end
+end

data/lib/mono_repo_deps/project/builder.rb

@@ -0,0 +1,20 @@
+class MonoRepoDeps::Project::Builder
+  include MonoRepoDeps::Mixins
+
+  Inject = MonoRepoDeps::Deps[
+    "project.factory",
+  ]
+
+  include Inject
+
+  sig do
+    params(project_root: String).returns(MonoRepoDeps::Project)
+  end
+  def call(project_root)
+    project_file_path = "#{project_root}/#{MonoRepoDeps::PROJECT_FILENAME}"
+
+    project_init_proc = proc { instance_eval(File.read(project_file_path)) }
+
+    project = factory.call(project_root, init_proc: project_init_proc)
+  end
+end

data/lib/mono_repo_deps/project/factory.rb

@@ -0,0 +1,115 @@
+class MonoRepoDeps::Project::Factory
+  include MonoRepoDeps::Mixins
+
+  sig do
+    params(
+      root_path: String,
+      init_proc: T.proc.params(args: T.anything).returns(T.anything)
+    )
+    .returns(MonoRepoDeps::Project)
+  end
+  def call(root_path, init_proc:)
+    @tasks = []
+    @root_path = root_path
+
+    instance_exec(&init_proc)
+
+    project = MonoRepoDeps::Project.new(
+      root_path: root_path,
+      env: @env,
+      configs_dir: @configs_dir,
+      package_dirname: @package_dirname,
+      packages_lookup_subdir: @packages_lookup_subdir,
+      loader: @loader,
+      tasks: @tasks
+    )
+  end
+
+  private
+
+  sig do
+    params(
+      block: T.proc.params(args: T.anything).returns(T.anything)
+    )
+    .void
+  end
+  def setup(&block)
+    instance_exec(@project, &block)
+
+    nil
+  end
+
+  sig do
+    params(
+      value: T.any(Symbol, String, T.proc.returns(T.any(String, Symbol)))
+    )
+    .void
+  end
+  def set_env(value)
+    @env = (value.is_a?(Proc) ? value.call : value).to_sym
+
+    raise MonoRepoDeps::Error.new("block or value should be provided") if @env.nil?
+
+    nil
+  end
+
+  sig do
+    params(value: String).void
+  end
+  def set_configs_dir(value)
+    @configs_dir = value
+
+    nil
+  end
+
+  sig do
+    params(value: String).void
+  end
+  def set_package_dirname(value)
+    @package_dirname = value
+
+    nil
+  end
+
+  sig do
+    params(
+      name: Symbol,
+      block: T.proc.params(args: T.anything).returns(T.anything)
+    )
+    .void
+  end
+  def set_loader(name, &block)
+    @loader = MonoRepoDeps::Loaders::Base.registry.fetch(name).new(@root_path, &block)
+
+    nil
+  end
+
+  sig do
+    params(value: String).void
+  end
+  def set_packages_lookup_subdir(value)
+    @packages_lookup_subdir = value
+
+    nil
+  end
+
+  sig do
+    params(
+      name: Symbol,
+      on: Symbol,
+      block: T.proc.params(args: T.anything).returns(T.anything),
+    )
+    .void
+  end
+  def register_task(name, on:, &block)
+    @tasks.push(
+      MonoRepoDeps::Task.new(
+        name: name,
+        on: on,
+        block: block
+      )
+    )
+
+    nil
+  end
+end

data/lib/mono_repo_deps/project/find_root.rb

@@ -0,0 +1,31 @@
+require 'zeitwerk'
+require 'singleton'
+
+class MonoRepoDeps::Project::FindRoot
+  include MonoRepoDeps::Mixins
+
+  SYSTEM_ROOT = '/'
+
+  sig do
+    params(dir: String).returns(String)
+  end
+  def call(dir)
+    init_dir = dir = File.expand_path(dir)
+
+    unless File.exist?(init_dir)
+      raise StandardError.new("path '#{init_dir}' does not exist")
+    end
+
+    loop do
+      project_file_path = File.expand_path(File.join(dir, MonoRepoDeps::PROJECT_FILENAME))
+
+      if File.exist?(project_file_path)
+        return dir
+      elsif dir == SYSTEM_ROOT
+        raise StandardError.new("#{MonoRepoDeps::PROJECT_FILENAME} for path '#{init_dir}' not found")
+      else
+        dir = File.expand_path("../", dir)
+      end
+    end
+  end
+end

data/lib/mono_repo_deps/project/initializer.rb

@@ -0,0 +1,26 @@
+class MonoRepoDeps::Project::Initializer
+  include MonoRepoDeps::Mixins
+
+  Inject = MonoRepoDeps::Deps[
+    "package.indexer",
+    "project.builder",
+    "project.find_root"
+  ]
+
+  include Inject
+
+  sig do
+    params(dir: String).returns(MonoRepoDeps::Project)
+  end
+  def call(dir)
+    project_root = find_root.call(dir)
+
+    project = builder.call(project_root)
+
+    project_packages = indexer.call(project.packages_lookup_subdir, project.root_path, project.package_dirname)
+
+    project.set_packages(project_packages)
+
+    project
+  end
+end

data/lib/mono_repo_deps/project.rb

@@ -0,0 +1,43 @@
+class MonoRepoDeps::Project
+  include MonoRepoDeps::Mixins
+
+  attr_reader :env, :configs_dir, :package_dirname, :root_path, :packages, :loader, :tasks, :packages_lookup_subdir
+
+  DEFAULT_OPTIONS = {
+    configs_dir: 'configs',
+    package_dirname: 'package',
+    packages_lookup_subdir: ".",
+    loader: MonoRepoDeps::Loaders::Base,
+    tasks: []
+  }
+
+  sig do
+    params(
+      root_path: String,
+      env: Symbol,
+      loader: T.nilable(MonoRepoDeps::Loaders::Base),
+      configs_dir: T.nilable(String),
+      package_dirname: T.nilable(String),
+      packages_lookup_subdir: T.nilable(String),
+      tasks: T.nilable(T::Array[MonoRepoDeps::Task])
+    )
+    .void
+  end
+  def initialize(root_path:, env:, loader: nil, configs_dir: nil, package_dirname: nil, packages_lookup_subdir: nil, tasks: nil)
+    @root_path = root_path
+    @env = env
+    @packages = []
+
+    @loader = loader || DEFAULT_OPTIONS.fetch(:loader).new(@root_path)
+    @tasks = tasks || DEFAULT_OPTIONS.fetch(:tasks)
+    @configs_dir = configs_dir || DEFAULT_OPTIONS.fetch(:configs_dir)
+    @package_dirname = package_dirname || DEFAULT_OPTIONS.fetch(:package_dirname)
+    @packages_lookup_subdir = packages_lookup_subdir || DEFAULT_OPTIONS.fetch(:packages_lookup_subdir)
+
+    nil
+  end
+
+  def set_packages(packages)
+    @packages = packages
+  end
+end

data/lib/mono_repo_deps/task/manager.rb

@@ -0,0 +1,55 @@
+class MonoRepoDeps::Task::Manager
+  include MonoRepoDeps::Mixins
+
+  Inject = MonoRepoDeps::Deps[
+    packages_repo: "package.repo"
+  ]
+
+  include Inject
+
+  sig do
+    params(
+      method_name: Symbol,
+      args: T.anything,
+      kwargs: T.anything
+    )
+    .void
+  end
+  def method_missing(method_name, *args, **kwargs)
+    task = MonoRepoDeps.current_project.tasks.detect { _1.name == method_name } || (raise StandardError.new("task '#{method_name}' not found for project"))
+
+    case task.on
+    when :package
+      statuses = kwargs[:packages].inject({}) do |result, package_name|
+        package = packages_repo.find!(package_name.to_sym)
+        result[package.name] = do_in_child(task.block, package, kwargs[:args])
+        result
+      end
+
+      failed_packages = statuses.reject {|package_name, exitstatus| exitstatus.success?}
+
+      if failed_packages.any?
+        puts failed_packages.keys
+        exit 1
+      end
+    else
+      raise StandardError.new("unsupported task subject: #{task.on}")
+    end
+  end
+
+  private
+
+  def do_in_child(block, *args)
+    read, write = IO.pipe
+
+    pid = fork do
+      read.close
+      block.call(*args)
+    end
+
+    write.close
+    Process.wait(pid)
+
+    exit($?.exitstatus)
+  end
+end

data/lib/mono_repo_deps/task.rb

@@ -0,0 +1,21 @@
+class MonoRepoDeps::Task
+  include MonoRepoDeps::Mixins
+
+  attr_reader :name, :on, :block
+
+  sig do
+    params(
+      name: Symbol,
+      on: Symbol,
+      block: T.proc.params(args: T.anything).returns(T.anything),
+    )
+    .void
+  end
+  def initialize(name:, on:, block:)
+    @name = name.to_sym
+    @on = on
+    @block = block
+
+    nil
+  end
+end

data/lib/mono_repo_deps/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module MonoRepoDeps
+  VERSION = "0.1.13"
+end

data/lib/mono_repo_deps.rb

@@ -0,0 +1,138 @@
+# frozen_string_literal: true
+
+require 'mono_repo_deps/version'
+require 'dry/system'
+require 'benchmark'
+require "zeitwerk"
+require 'pry'
+
+module MonoRepoDeps
+  class Error < StandardError; end
+
+  PROJECT_FILENAME = 'MonoRepoConfig.rb'
+  PACKAGE_FILENAME = 'Package.rb'
+
+  module Mixins
+    def self.included(base)
+      require 'sorbet-runtime'
+
+      base.extend T::Sig
+    end
+  end
+
+  class Container < Dry::System::Container
+    use :env, inferrer: -> { ENV.fetch("RUBY_ENV", :production).to_sym }
+    # use :logging
+
+    configure do |config|
+      config.root = __dir__
+
+      config.component_dirs.add 'mono_repo_deps' do |dir|
+        dir.namespaces.add nil, key: nil, const: "mono_repo_deps"
+      end
+    end
+  end
+
+  Deps = Container.injector
+
+  Container.finalize! unless Container.env == :test
+
+  Zeitwerk::Loader
+    .for_gem
+    .tap(&:setup)
+    .tap(&:eager_load)
+
+  class << self
+    attr_accessor :current_project
+
+    def init_package(package_name = nil, from: caller_locations.first.path, env: nil)
+      sync_current_project!(from) do
+        package_name ||= Container["package.builder"].call(from, current_project.root_path, current_project.package_dirname).name
+        env ||= current_project.env
+
+        Container["package.initializer"].call(package_name, env: env)
+      end
+    end
+
+    def root(from = caller_locations.first.path)
+      sync_current_project!(from) do
+        current_project.root_path
+      end
+    end
+
+    def tasks(from = caller_locations.first.path)
+      sync_current_project!(from) do
+        Container["task.manager"]
+      end
+    end
+
+    def loader(from = caller_locations.first.path)
+      sync_current_project!(from) do
+        current_project.loader
+      end
+    end
+
+    def configs(from = caller_locations.first.path)
+      sync_current_project!(from) do
+        Container["config.manager"]
+      end
+    end
+
+    def packages(from = caller_locations.first.path)
+      sync_current_project!(from) do
+        Container["package.repo"]
+      end
+    end
+
+    def check_classes(from = caller_locations.first.path)
+      sync_current_project!(from) do
+        all_packages = Container["package.repo"].all
+        total_count = all_packages.size
+        imported = []
+        packages_order = []
+
+        all_packages.each_with_index do |package, idx|
+          puts "loading package #{package.name} (#{idx+1}/#{total_count}/#{imported.size})"
+
+          Container["package.dependency_bypasser"].call(
+            package_name: package.name,
+            imported: imported,
+            packages_order: packages_order,
+            env: current_project.env
+          )
+        end
+
+        packages_order
+          .uniq
+          .map { Container["package.repo"].find(_1) }
+          .each { current_project.loader.push_dir(_1.workdir_path) }
+          .tap { current_project.loader.setup }
+          .each { require _1.entrypoint_file if File.exist?(_1.entrypoint_file) }
+          .tap { current_project.loader.check_classes }
+      end
+    end
+
+    def sync_current_project!(path, &block)
+      path = File.expand_path(path)
+      path = File.dirname(path) unless File.directory?(path)
+
+      root = Container['project.find_root'].call(path)
+
+      if @current_project && @current_project.root_path == root
+        return block.call
+      end
+
+      synchronize do
+        @current_project = Container["project.initializer"].call(path)
+
+        block.call
+      end
+    end
+
+    def synchronize(&block)
+      @mutex ||= Mutex.new
+
+      @mutex.synchronize(&block)
+    end
+  end
+end

data/sig/mono_repo_deps.rbs

@@ -0,0 +1,4 @@
+module MonoRepoDeps
+  VERSION: String
+  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+end