mona 0.2.3 → 0.4.0

data/lib/mona/package/factory.rb

@@ -1,95 +0,0 @@
-# frozen_string_literal: true
-class Mona::Package::Factory
-  include Mona::Mixins
-
-  sig do
-    params(
-      package_root: String,
-      package_dirname: String,
-      init_proc: T.proc.params(args: T.anything).returns(T.anything)
-    )
-    .returns(Mona::Package)
-  end
-  def call(package_root, package_dirname, init_proc:)
-    @dependencies = Hash.new { |h, k| h[k] = [] }
-    @current_env = Mona::Package::DEFAULT_ENV
-
-    instance_exec(&init_proc)
-
-    package = Mona::Package.new(
-      name: @name,
-      root_path: package_root,
-      package_dirname: package_dirname,
-      dependencies: @dependencies
-    ).tap { check_duplicate_dependencies(_1) }
-  end
-
-  private
-
-  def check_duplicate_dependencies(package)
-    package.get_dependency_envs.each do |env|
-      already_imported = package
-        .get_dependencies(env)
-        .group_by{ |e| e }
-        .select { |k, v| v.size > 1 }
-        .keys
-
-      if already_imported.any?
-        puts "WARNING: duplicated import for following packages #{already_imported.inspect} was already added for package '#{package.name}' for env '#{env}'"
-      end
-    end
-  end
-
-  sig do
-    params(
-      env: Symbol,
-      block: T.proc.params(args: T.anything).returns(T.anything)
-    )
-    .void
-  end
-  def dependency(env = Mona::Package::DEFAULT_ENV, &block)
-    @current_env = env
-    instance_eval(&block)
-    @current_env = Mona::Package::DEFAULT_ENV
-
-    nil
-  end
-
-  sig do
-    params(
-      package_name: T.any(Symbol, String),
-    )
-    .void
-  end
-  def import(package_name)
-    package_name = package_name.to_sym
-
-    @dependencies[@current_env] << package_name
-
-    nil
-  end
-
-  sig do
-    params(
-      block: T.proc.params(args: T.anything).returns(T.anything)
-    )
-    .void
-  end
-  def package(&block)
-    instance_exec(&block)
-
-    nil
-  end
-
-  sig do
-    params(
-      value: T.any(String, Symbol)
-    )
-    .void
-  end
-  def name(value)
-    @name = value.to_sym
-
-    nil
-  end
-end

data/lib/mona/package/find_root.rb

@@ -1,33 +0,0 @@
-class Mona::Package::FindRoot
-  include Mona::Mixins
-
-  SYSTEM_ROOT = '/'
-
-  sig do
-    params(
-      dir: String,
-      project_root: T.nilable(String),
-    )
-    .returns(String)
-  end
-  def call(dir, project_root)
-    init_dir = dir = File.expand_path(dir)
-    project_root = File.expand_path(project_root || SYSTEM_ROOT)
-
-    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::PACKAGE_FILENAME))
-
-      if File.exist?(project_file_path)
-        return dir
-      elsif dir == project_root
-        raise StandardError.new("Package.rb for path '#{init_dir}' not found")
-      else
-        dir = File.expand_path("../", dir)
-      end
-    end
-  end
-end

data/lib/mona/package/indexer.rb

@@ -1,30 +0,0 @@
-class Mona::Package::Indexer
-  include Mona::Mixins
-
-  Inject = Mona::Deps[
-    "package.builder",
-  ]
-
-  include Inject
-
-  sig do
-    params(
-      packages_lookup_subdir: String,
-      project_root: String,
-      package_dirname: String
-    )
-    .returns(T::Array[Mona::Package])
-  end
-  def call(packages_lookup_subdir, project_root, package_dirname)
-    packages_path = File.join(
-      project_root,
-      packages_lookup_subdir,
-      "**",
-      Mona::PACKAGE_FILENAME
-    )
-
-    Dir[packages_path].map do |package_file_path|
-      builder.call(package_file_path, project_root, package_dirname)
-    end
-  end
-end

data/lib/mona/package/initializer.rb

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

data/lib/mona/package/list.rb

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

data/lib/mona/package/repo.rb

@@ -1,63 +0,0 @@
-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

@@ -1,51 +0,0 @@
-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

@@ -1,20 +0,0 @@
-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

@@ -1,115 +0,0 @@
-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

@@ -1,31 +0,0 @@
-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

@@ -1,26 +0,0 @@
-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

@@ -1,43 +0,0 @@
-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

@@ -1,36 +0,0 @@
-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

@@ -1,21 +0,0 @@
-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

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

data/sig/mona.rbs

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