mona 0.2.3

data/example/bounded_contexts/shared/test_utils/Package.rb

@@ -0,0 +1,9 @@
+package do
+  name 'test_utils'
+end
+
+dependency do
+end
+
+dependency :test do
+end

data/example/bounded_contexts/shared/test_utils/bin/console

@@ -0,0 +1,9 @@
+#!/usr/bin/env ruby
+
+require 'bundler/setup'
+require 'mona'
+
+Mona.init(__dir__)
+
+require 'irb'
+IRB.start

data/example/bounded_contexts/shared/test_utils/package/test_utils.rb

@@ -0,0 +1,2 @@
+module TestUtils
+end

data/example/bounded_contexts/storefront/storefront_app/Package.rb

@@ -0,0 +1,11 @@
+package do
+  name 'storefront_app'
+end
+
+dependency do
+  import 'storefront_core'
+end
+
+dependency :test do
+  import 'test_utils'
+end

data/example/bounded_contexts/storefront/storefront_app/bin/console

@@ -0,0 +1,9 @@
+#!/usr/bin/env ruby
+
+require 'bundler/setup'
+require 'mona'
+
+Mona.init(__dir__)
+
+require 'irb'
+IRB.start

data/example/bounded_contexts/storefront/storefront_app/package/storefront_app.rb

@@ -0,0 +1,2 @@
+module StorefrontApp
+end

data/example/bounded_contexts/storefront/storefront_core/Package.rb

@@ -0,0 +1,11 @@
+package do
+  name 'storefront_core'
+end
+
+dependency do
+  import 'storefront_datasets'
+end
+
+dependency :test do
+  import 'test_utils'
+end

data/example/bounded_contexts/storefront/storefront_core/bin/console

@@ -0,0 +1,9 @@
+#!/usr/bin/env ruby
+
+require 'bundler/setup'
+require 'mona'
+
+Mona.init(__dir__)
+
+require 'irb'
+IRB.start

data/example/bounded_contexts/storefront/storefront_core/package/storefront_core.rb

@@ -0,0 +1,2 @@
+module StorefrontCore
+end

data/example/bounded_contexts/storefront/storefront_datasets/Package.rb

@@ -0,0 +1,11 @@
+package do
+  name 'storefront_datasets'
+end
+
+dependency do
+  import 'db_connection'
+end
+
+dependency :test do
+  import 'test_utils'
+end

data/example/bounded_contexts/storefront/storefront_datasets/bin/console

@@ -0,0 +1,9 @@
+#!/usr/bin/env ruby
+
+require 'bundler/setup'
+require 'mona'
+
+Mona.init(__dir__)
+
+require 'irb'
+IRB.start

data/example/bounded_contexts/storefront/storefront_datasets/package/storefront_datasets.rb

@@ -0,0 +1,2 @@
+module StorefrontDatasets
+end

data/example/configs/cart_app/default.yml

@@ -0,0 +1,4 @@
+cart_app:
+  host: 'some_host'
+  port: 1234
+  db:   'some_db'

data/example/configs/cart_app/test.yml

@@ -0,0 +1,3 @@
+cart_app:
+  host: 'some_test_host'
+  db:   'some_test_db'

data/example/configs/orders_app/default.yml

@@ -0,0 +1,4 @@
+orders_app:
+  host: 'some_host'
+  port: 1234
+  db:   'some_db'

data/example/configs/orders_app/test.yml

@@ -0,0 +1,2 @@
+orders_app:
+  host: 'some_test_host'

data/exe/mona

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "bundler/setup"
+require "mona"
+require "thor"
+
+class MonaCli < Thor
+  desc "mona cd PACKAGE", "go to PACKAGE"
+  def cd(package)
+    puts "cd #{Mona.packages(File.expand_path(".")).find(package.to_sym).root_path}"
+  end
+end
+
+MonaCli.start(ARGV)

data/lib/mona/config/loader.rb

@@ -0,0 +1,74 @@
+require 'yaml'
+require 'erb'
+require 'ostruct'
+
+class Mona::Config::Loader
+  include Mona::Mixins
+
+  DEFAULT_CONFIG_FILENAME = 'default.yml'
+
+  sig do
+    params(
+      config_name: T.any(String, Symbol),
+    )
+    .returns(Mona::Config)
+  end
+  def call(config_name)
+    config_name = config_name.to_s
+    config = Mona::Config.new
+
+    default_config_filename = File.join(
+      Mona.current_project.root_path,
+      Mona.current_project.configs_dir,
+      config_name,
+      DEFAULT_CONFIG_FILENAME
+    )
+
+    unless File.exist?(default_config_filename)
+      raise StandardError.new("Config '#{config_name}' was not found. Add it to '#{default_config_filename}'")
+    end
+
+    hash =
+      begin
+        YAML.load( ERB.new(File.read(default_config_filename)).result )
+      rescue => e
+        puts ERB.new(File.read(default_config_filename)).result.inspect
+      end
+
+    hash_to_config(
+      hash: hash,
+      config: config
+    )
+
+    env_config_filename = File.join(
+      Mona.current_project.root_path,
+      Mona.current_project.configs_dir,
+      config_name,
+      "#{Mona.current_project.env}.yml"
+    )
+
+    hash_to_config(
+      hash: YAML.load( ERB.new(File.read(env_config_filename)).result ),
+      config: config
+    ) if File.exist?(env_config_filename)
+
+    config.send(config_name)
+  end
+
+  private
+
+  def hash_to_config(hash:, config:)
+    hash.each do |key, value|
+      if value.is_a?(Hash)
+        nested_config = config.read_attribute(key)
+        if nested_config.nil? || !nested_config.is_a?(Mona::Config)
+          nested_config = Mona::Config.new
+        end
+        hash_to_config(hash: value, config: nested_config)
+        config.write_attribute(key, nested_config)
+      else
+        config.write_attribute(key, value)
+      end
+    end
+  end
+end

data/lib/mona/config/manager.rb

@@ -0,0 +1,20 @@
+class Mona::Config::Manager
+  include Mona::Mixins
+
+  Inject = Mona::Deps[
+    config_loader: "config.loader"
+  ]
+
+  include Inject
+
+  sig do
+    params(
+      method_name: Symbol,
+      args: T.anything
+    )
+    .returns(Mona::Config)
+  end
+  def method_missing(method_name, *args)
+    config_loader.call(method_name)
+  end
+end

data/lib/mona/config.rb

@@ -0,0 +1,23 @@
+class Mona::Config
+  def initialize(attributes = {})
+    @attributes = attributes
+  end
+
+  def read_attribute(key)
+    @attributes[key.to_s]
+  end
+
+  def write_attribute(key, value)
+    @attributes[key.to_s] = value
+  end
+
+  def method_missing(method_name, *_args)
+    read_attribute(method_name)
+  end
+
+  def to_h
+    @attributes.each_with_object({}) do |(k, v), h|
+      h[k] = self.class === v ? v.to_h : v
+    end
+  end
+end

data/lib/mona/loaders/base.rb

@@ -0,0 +1,63 @@
+class Mona::Loaders::Base
+  include Mona::Mixins
+
+  class << self
+    def registry
+      @registry ||= {}
+    end
+
+    def inherited(subclass)
+      name = subclass.to_s.split("::").last.downcase.to_sym
+
+      registry[name] = subclass
+    end
+  end
+
+  attr_reader :overwriters, :inflections, :ignore_dirs, :autoload_dirs, :loader, :root_path
+
+  def initialize(root_path, &block)
+    @root_path = root_path
+    @overwriters = []
+    @inflections = {}
+    @ignore_dirs = []
+    @autoload_dirs = []
+
+    instance_exec(&block) if block_given?
+  end
+
+  def push_dir(dir)
+    @autoload_dirs.push(dir)
+  end
+
+  def setup
+    raise StandardError.new('not implemented')
+  end
+
+  def reload
+    raise StandardError.new('not implemented')
+  end
+
+  def eager_load
+    raise StandardError.new('not implemented')
+  end
+
+  def check_classes
+    raise StandardError.new('not implemented')
+  end
+
+  module SetupDsl
+    def inflect(hash)
+      @inflections.merge!(hash)
+    end
+
+    def overwrite(proc)
+      overwriters.push(proc)
+    end
+
+    def ignore(glob)
+      @ignore_dirs.push(glob)
+    end
+  end
+
+  include SetupDsl
+end

data/lib/mona/loaders/zeitwerk.rb

@@ -0,0 +1,77 @@
+require 'zeitwerk'
+require 'benchmark'
+
+class Mona::Loaders::Zeitwerk < Mona::Loaders::Base
+  include Mona::Mixins
+
+  ERROR_MESSAGE_REGEX = /expected file (?<path>[\w\/]+.rb) to define constant (?<klass>[\w:]+)/
+
+  def initialize(...)
+    @loader = Zeitwerk::Loader.new
+    @loader.inflector = Class.new(Zeitwerk::Inflector).new
+
+    super(...)
+  end
+
+  def setup
+    apply_rules_for(@loader)
+    @loader.setup
+  end
+
+  def eager_load
+    time = Benchmark.realtime do
+      @loader.eager_load
+    end
+
+    puts "eager_load dependencies in #{'%.2f' % time} seconds"
+  end
+
+  def check_classes
+    check_classes_loader = @loader.dup
+    check_classes_loader.on_load { |cpath, value, abspath| puts value }
+
+    errors = []
+
+    begin
+      check_classes_loader.eager_load
+    rescue Zeitwerk::NameError => e
+      match = e.message.match(ERROR_MESSAGE_REGEX)
+
+      raise e if match.nil?
+
+      # TODO: use logger
+      errors << "#{match[:path]} => #{match[:klass]}"
+      check_classes_loader.ignore(match[:path])
+      retry
+    end
+
+    puts errors
+    raise StandardError.new("loader fails with #{errors.count} errors") if errors.any?
+
+    nil
+  end
+
+  def apply_rules_for(entity)
+    @autoload_dirs.uniq.each { entity.push_dir(_1) }
+    @ignore_dirs.uniq
+      .map { File.join(Mona.current_project.root_path, _1) }
+      .each { entity.ignore( _1 ) }
+
+    entity.inflector.inflect(@inflections)
+
+    result_overwriter = ->(kname) { @overwriters.each { |o| kname = o.call(kname) }; kname }
+    entity.inflector.define_singleton_method(:camelize) do |basename, abspath|
+      result_overwriter.call( super(basename, abspath) )
+    end
+  end
+
+  def ignore(glob)
+    super(glob)
+
+    # TODO: if loader.setup is true => push dir directly to the @loader
+    @ignore_dirs
+      .uniq
+      .map { File.join(root_path, _1) }
+      .each { @loader.ignore( _1 ) }
+  end
+end

data/lib/mona/package/builder.rb

@@ -0,0 +1,27 @@
+class Mona::Package::Builder
+  include Mona::Mixins
+
+  Inject = Mona::Deps[
+    "package.find_root",
+    "package.factory"
+  ]
+
+  include Inject
+
+  sig do
+    params(
+      package_path: String,
+      project_root: String,
+      package_dirname: String
+    )
+    .returns(Mona::Package)
+  end
+  def call(package_path, project_root, package_dirname)
+    package_root_path = find_root.call(package_path, project_root)
+    package_file_path = "#{package_root_path}/#{Mona::PACKAGE_FILENAME}"
+
+    package_init_proc = proc { instance_eval(File.read(package_file_path)) }
+
+    package = factory.call(package_root_path, package_dirname, init_proc: package_init_proc)
+  end
+end

data/lib/mona/package/dependency_bypasser.rb

@@ -0,0 +1,43 @@
+require 'set'
+
+class Mona::Package::DependencyBypasser
+  include Mona::Mixins
+
+  Inject = Mona::Deps[
+    packages_repo: "package.repo"
+  ]
+
+  include Inject
+
+  sig do
+    params(
+      package_name: Symbol,
+      env: Symbol,
+    )
+    .returns(T::Array[Symbol])
+  end
+  def call(package_name:, env:)
+    walk(package_name: package_name, env: env, imported: Set.new)
+  end
+
+  private
+
+  def walk(package_name:, env:, imported:, packages_order: [])
+    package = packages_repo.find!(package_name)
+
+    return if !imported.add?(package_name)
+
+    package_dependencies = package.get_dependencies(env)
+
+    package_dependencies.each do |name|
+      walk(
+        package_name: name,
+        imported: imported,
+        packages_order: packages_order,
+        env: Mona::Package::DEFAULT_ENV,
+      )
+    end
+
+    packages_order.push(package_name)
+  end
+end

data/lib/mona/package/factory.rb

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

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

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

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

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