mona 0.2.3

data/lib/mona/package/repo.rb

@@ -0,0 +1,63 @@
+class Mona::Package::Repo
+  include Mona::Mixins
+
+  Inject = Mona::Deps[
+    "package.list",
+  ]
+
+  include Inject
+
+  sig do
+    returns(T::Array[Mona::Package])
+  end
+  def all
+    list.call
+  end
+
+  sig do
+    params(
+      name: T.nilable(
+        T.any(
+          String,
+          Symbol,
+          T::Array[
+            T.any(String, Symbol)
+          ]
+        )
+      ),
+    )
+    .returns(T::Array[Mona::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(Mona::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(Mona::Package)
+  end
+  def find!(package_name)
+    find(package_name) || (raise StandardError.new("package '#{package_name}' was not found for Mona project '#{Mona.current_project.root_path}'"))
+  end
+end

data/lib/mona/package.rb

@@ -0,0 +1,51 @@
+class Mona::Package
+  include Mona::Mixins
+
+  attr_reader :name, :root_path, :dependencies, :configs
+
+  DEFAULT_ENV = :_default_
+
+  sig do
+    params(
+      name: Symbol,
+      root_path: String,
+      package_dirname: String,
+      dependencies: T::Hash[Symbol, Symbol]
+    )
+    .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[Symbol])
+  end
+  def get_dependencies(env = nil)
+    default_deps = @dependencies.fetch(DEFAULT_ENV, [])
+    env_deps     = @dependencies.fetch(env, [])
+
+    default_deps | env_deps
+  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
+
+  def specs_path
+    File.join( self.root_path, '/spec/' )
+  end
+end

data/lib/mona/project/builder.rb

@@ -0,0 +1,20 @@
+class Mona::Project::Builder
+  include Mona::Mixins
+
+  Inject = Mona::Deps[
+    "project.factory",
+  ]
+
+  include Inject
+
+  sig do
+    params(project_root: String).returns(Mona::Project)
+  end
+  def call(project_root)
+    project_file_path = "#{project_root}/#{Mona::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/mona/project/factory.rb

@@ -0,0 +1,115 @@
+class Mona::Project::Factory
+  include Mona::Mixins
+
+  sig do
+    params(
+      root_path: String,
+      init_proc: T.proc.params(args: T.anything).returns(T.anything)
+    )
+    .returns(Mona::Project)
+  end
+  def call(root_path, init_proc:)
+    @tasks = []
+    @root_path = root_path
+
+    instance_exec(&init_proc)
+
+    project = Mona::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 Mona::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 = Mona::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(
+      Mona::Task.new(
+        name: name,
+        on: on,
+        block: block
+      )
+    )
+
+    nil
+  end
+end

data/lib/mona/project/find_root.rb

@@ -0,0 +1,31 @@
+require 'zeitwerk'
+require 'singleton'
+
+class Mona::Project::FindRoot
+  include Mona::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, Mona::PROJECT_FILENAME))
+
+      if File.exist?(project_file_path)
+        return dir
+      elsif dir == SYSTEM_ROOT
+        raise StandardError.new("#{Mona::PROJECT_FILENAME} for path '#{init_dir}' not found")
+      else
+        dir = File.expand_path("../", dir)
+      end
+    end
+  end
+end

data/lib/mona/project/initializer.rb

@@ -0,0 +1,26 @@
+class Mona::Project::Initializer
+  include Mona::Mixins
+
+  Inject = Mona::Deps[
+    "package.indexer",
+    "project.builder",
+    "project.find_root"
+  ]
+
+  include Inject
+
+  sig do
+    params(dir: String).returns(Mona::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/mona/project.rb

@@ -0,0 +1,43 @@
+class Mona::Project
+  include Mona::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: Mona::Loaders::Base,
+    tasks: []
+  }
+
+  sig do
+    params(
+      root_path: String,
+      env: Symbol,
+      loader: T.nilable(Mona::Loaders::Base),
+      configs_dir: T.nilable(String),
+      package_dirname: T.nilable(String),
+      packages_lookup_subdir: T.nilable(String),
+      tasks: T.nilable(T::Array[Mona::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/mona/task/manager.rb

@@ -0,0 +1,36 @@
+class Mona::Task::Manager
+  include Mona::Mixins
+
+  Inject = Mona::Deps[
+    packages_repo: "package.repo"
+  ]
+
+  include Inject
+
+  sig do
+    params(
+      method_name: Symbol,
+      args: T.anything,
+      kwargs: T.anything
+    )
+    .returns(T::Boolean)
+  end
+  def method_missing(method_name, *args, **kwargs)
+    task = Mona.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] = task.block.call(package, kwargs[:args])
+        result
+      end
+
+      failed_packages = statuses.reject {|package_name, exitstatus| exitstatus == 0}
+
+      failed_packages.any? ? false : true
+    else
+      raise StandardError.new("unsupported task subject: #{task.on}")
+    end
+  end
+end

data/lib/mona/task.rb

@@ -0,0 +1,21 @@
+class Mona::Task
+  include Mona::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/mona/version.rb

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

data/lib/mona.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+require 'mona/version'
+require 'dry/system'
+require 'benchmark'
+require "zeitwerk"
+require 'pry'
+
+module Mona
+  class Error < StandardError; end
+
+  PROJECT_FILENAME = 'Monafile.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 'mona' do |dir|
+        dir.namespaces.add nil, key: nil, const: "mona"
+      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, prevent_eager_load: false)
+      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, prevent_eager_load: prevent_eager_load)
+      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 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/mona.gemspec

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require_relative "lib/mona/version"
+
+Gem::Specification.new do |spec|
+  spec.name = "mona"
+  spec.version = Mona::VERSION
+  spec.authors = ["Nikita Kononov"]
+  spec.email = ["vocrsz@gmail.com"]
+
+  spec.summary = "A Ruby gem for efficiently managing dependencies within a monorepository."
+  spec.description   = <<-DESC
+    A Ruby gem for efficiently managing dependencies within a monorepository. \n
+    GitHub Repository: https://github.com/droidlabs/mono_repo_deps
+  DESC
+  spec.homepage = "https://github.com/droidlabs/mono_repo_deps"
+  spec.license = "MIT"
+  spec.required_ruby_version = ">= 2.7.0"
+
+  # spec.metadata["allowed_push_host"] = "Set to your gem server 'https://example.com'"
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = "https://github.com/droidlabs/mono_repo_deps"
+  spec.metadata["changelog_uri"] = "https://github.com/droidlabs/mono_repo_deps"
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files = Dir.chdir(__dir__) do
+    `git ls-files -z`.split("\x0").reject do |f|
+      (File.expand_path(f) == __FILE__) ||
+        f.start_with?(*%w[bin/ test/ spec/ features/ .git .circleci appveyor Gemfile])
+    end
+  end
+  spec.bindir = "exe"
+  spec.executables = spec.files.grep(/\Aexe\//) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency 'sorbet-runtime', "~> 0.5.11164"
+
+  spec.add_dependency "dry-auto_inject", "~> 1.0.1"
+  spec.add_dependency "dry-core", "~> 1.0.0"
+  spec.add_dependency "dry-configurable", "~> 1.0.1"
+  spec.add_dependency "dry-container", "~> 0.11.0"
+  spec.add_dependency "dry-system", "~> 1.0.1"
+
+  spec.add_dependency "zeitwerk", "~> 2.6.12"
+
+  spec.add_dependency "thor"
+
+  spec.add_development_dependency "bundler", "~> 2.2"
+  spec.add_development_dependency "rake", "~> 13.0"
+  spec.add_development_dependency "rspec", "~> 3.0"
+  spec.add_development_dependency "pry"
+end

data/sig/mona.rbs

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