mono_repo_deps 0.1.14 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8c647d08af8a48b4c6e74925bf12726e25fc8ffbdeda6c393c331bf0fde7da9f
-  data.tar.gz: fefbaa9411bf1ec8654fdbdb4ca227f891d6ad649fb34c7a1311f1fc79efe093
+  metadata.gz: 95e49884e5cf67ed63ea7575df321c0166b5ac505b602d99facf24b866dff026
+  data.tar.gz: e9ce0647794d26570f0e45af5346e27778bc7bc67edce058b801c20250055513
 SHA512:
-  metadata.gz: a1db94be7a45aab92d0e1464d30bbb743d4701d46e4847e35ceed62b1988ab8b5052dfc2048df5b9f015b74b00ead4372e55b55348d8f37b68b08b0764381028
-  data.tar.gz: 1f894de5485f2c93283cc18760ad84b454afc653a5360e740a87c6188edaf19a3f727c72dc30747d72e1b3ccb4eeb08ba2f9c9ed4c4060ce10213d5450e1b880
+  metadata.gz: 7f8e7acfd621406055e2091119857f595d6ba1899f90b5e6c164210f6c81dcb635359942f91cc1797197e4ab83bc89eae6db7837bdeafcd8491d3a1cc93d3d8a
+  data.tar.gz: c04cef773cdb54ca0357d827f9594767203f291c4416d1f5a1557d03f9febeaf86524ef7f1ae39e5b7e8f3a84a417cf74e56e8d60cedbfbc2599fdc8e460fbda

data/example/bounded_contexts/cart/cart_core/Package.rb

@@ -4,9 +4,9 @@ end
 
 dependency do
   import 'cart_datasets'
-  import 'orders_query_api', only: ['orders_datasets']
+  import 'orders_query_api'
 end
 
 dependency :test do
   import 'test_utils'
-end
+end

data/lib/mono_repo_deps/package/dependency_bypasser.rb

@@ -1,3 +1,5 @@
+require 'set'
+
 class MonoRepoDeps::Package::DependencyBypasser
   include MonoRepoDeps::Mixins
 
@@ -11,31 +13,28 @@ class MonoRepoDeps::Package::DependencyBypasser
     params(
       package_name: Symbol,
       env: Symbol,
-      only: T.nilable(T::Array[Symbol]),
-      skip: T.nilable(T::Array[Symbol]),
-      imported: T::Array[Symbol],
-      packages_order: T::Array[Symbol],
     )
     .returns(T::Array[Symbol])
   end
-  def call(package_name:, env:, only: nil, skip: nil, imported: [], packages_order: [])
+  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.include?(package_name)
-    imported.push(package.name)
+    return if !imported.add?(package_name)
 
     package_dependencies = package.get_dependencies(env)
-    package_dependencies = package_dependencies.select { only.include?(_1.name) } unless only.nil?
-    package_dependencies = package_dependencies.reject { skip.include?(_1.name) } unless skip.nil?
-
-    package_dependencies.each do |dependency_dto|
-      self.call(
-        package_name: dependency_dto.name,
-        skip: dependency_dto.skip,
-        only: dependency_dto.only,
+
+    package_dependencies.each do |name|
+      walk(
+        package_name: name,
         imported: imported,
         packages_order: packages_order,
-        env: env
+        env: MonoRepoDeps::Package::DEFAULT_ENV,
       )
     end
 

data/lib/mono_repo_deps/package/factory.rb

@@ -30,7 +30,6 @@ class MonoRepoDeps::Package::Factory
     package.get_dependency_envs.each do |env|
       already_imported = package
         .get_dependencies(env)
-        .map(&:name)
         .group_by{ |e| e }
         .select { |k, v| v.size > 1 }
         .keys
@@ -59,17 +58,13 @@ class MonoRepoDeps::Package::Factory
   sig do
     params(
       package_name: T.any(Symbol, String),
-      skip: T.nilable(T::Array[Symbol]),
-      only: T.nilable(T::Array[Symbol]),
     )
     .void
   end
-  def import(package_name, skip: nil, only: nil)
+  def import(package_name)
     package_name = package_name.to_sym
-    skip = skip&.map(&:to_sym)
-    only = only&.map(&:to_sym)
 
-    @dependencies[@current_env] << MonoRepoDeps::Package::DependencyDto.new(name: package_name, skip: skip, only: only)
+    @dependencies[@current_env] << package_name
 
     nil
   end

data/lib/mono_repo_deps/package/initializer.rb

@@ -14,24 +14,32 @@ class MonoRepoDeps::Package::Initializer
     params(
       package_name: T.any(Symbol, String),
       env: Symbol,
-      imported: T::Array[Symbol]
+      prevent_eager_load: T::Boolean
     )
     .void
   end
-  def call(package_name, env:, imported: [])
-    package_name = package_name.to_sym
-    packages_import_order = []
+  def call(package_name, env:, prevent_eager_load: false)
+    package = repo.find!(package_name.to_sym)
+    sorted_packages = nil
 
     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) }
+      sorted_packages = dependency_bypasser
+        .call(package_name: package.name, env: env)
+        .map { |name| repo.find(name) }
+
+      sorted_packages.each do |sorted_package|
+        MonoRepoDeps.current_project.loader.push_dir(sorted_package.workdir_path)
+        MonoRepoDeps.current_project.loader.loader.do_not_eager_load(sorted_package.workdir_path) if prevent_eager_load
+      end
+
+      MonoRepoDeps.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 #{packages_import_order.size} dependencies in #{'%.2f' % time} seconds for env: #{env}"
+    puts "imported package '#{package_name}' with #{sorted_packages.size} dependencies in #{'%.2f' % time} seconds for env: #{env}"
 
     nil
   end

data/lib/mono_repo_deps/package/repo.rb

@@ -16,7 +16,15 @@ class MonoRepoDeps::Package::Repo
 
   sig do
     params(
-      name: T.nilable(T.any(String, Symbol)),
+      name: T.nilable(
+        T.any(
+          String,
+          Symbol,
+          T::Array[
+            T.any(String, Symbol)
+          ]
+        )
+      ),
     )
     .returns(T::Array[MonoRepoDeps::Package])
   end

data/lib/mono_repo_deps/package.rb

@@ -5,14 +5,12 @@ class MonoRepoDeps::Package
 
   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]
+      dependencies: T::Hash[Symbol, Symbol]
     )
     .void
   end
@@ -26,12 +24,13 @@ class MonoRepoDeps::Package
   end
 
   sig do
-    params(env: T.nilable(Symbol)).returns(T::Array[DependencyDto])
+    params(env: T.nilable(Symbol)).returns(T::Array[Symbol])
   end
   def get_dependencies(env = nil)
-    [DEFAULT_ENV, env].uniq.compact.inject([]) do |acc, item|
-      acc += @dependencies.fetch(item, [])
-    end
+    default_deps = @dependencies.fetch(DEFAULT_ENV, [])
+    env_deps     = @dependencies.fetch(env, [])
+
+    default_deps | env_deps
   end
 
   def get_dependency_envs
@@ -45,4 +44,8 @@ class MonoRepoDeps::Package
   def entrypoint_file
     File.join( self.workdir_path, "#{name}.rb" )
   end
+
+  def specs_path
+    File.join( self.root_path, '/spec/' )
+  end
 end

data/lib/mono_repo_deps/task/manager.rb

@@ -13,7 +13,7 @@ class MonoRepoDeps::Task::Manager
       args: T.anything,
       kwargs: T.anything
     )
-    .void
+    .returns(T::Boolean)
   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"))
@@ -22,34 +22,15 @@ class MonoRepoDeps::Task::Manager
     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[package.name] = task.block.call(package, kwargs[:args])
         result
       end
 
-      failed_packages = statuses.reject {|package_name, exitstatus| exitstatus.success?}
+      failed_packages = statuses.reject {|package_name, exitstatus| exitstatus == 0}
 
-      if failed_packages.any?
-        puts failed_packages.keys
-        exit 1
-      end
+      failed_packages.any? ? false : true
     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/version.rb

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

data/lib/mono_repo_deps.rb

@@ -45,12 +45,12 @@ module MonoRepoDeps
   class << self
     attr_accessor :current_project
 
-    def init_package(package_name = nil, from: caller_locations.first.path, env: nil)
+    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)
+        Container["package.initializer"].call(package_name, env: env, prevent_eager_load: prevent_eager_load)
       end
     end
 
@@ -84,34 +84,6 @@ module MonoRepoDeps
       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)

data/mono_repo_deps.gemspec

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require_relative "lib/mono_repo_deps/version"
+
+Gem::Specification.new do |spec|
+  spec.name = "mono_repo_deps"
+  spec.version = MonoRepoDeps::VERSION
+  spec.authors = ["Nikita Kononov"]
+  spec.email = ["vocrsz@gmail.com"]
+
+  spec.summary = "A Ruby gem for efficiently managing dependencies within a monorepo."
+  spec.description   = <<-DESC
+    MonoRepoDeps is a powerful tool designed to streamline the process of splitting code into separate packages
+    within a monorepository. It provides a flexible and easy-to-use solution for managing dependencies between
+    packages, making it ideal for large-scale projects with complex codebases.
+
+    Key Features:
+    - Simplifies the organization of code in a monorepo structure.
+    - Manages dependencies seamlessly between different packages.
+    - Enhances collaboration and code sharing among teams working on interconnected components.
+    - Offers a straightforward and customizable configuration for your monorepo setup.
+
+    How to Use:
+    - Install the gem using `gem install MonoRepoDeps`.
+    - Configure MonoRepoDeps with your monorepo specifications.
+    - Enjoy a more efficient and organized development workflow.
+
+    Visit the official documentation for detailed instructions and examples.
+
+    GitHub Repository: https://github.com/droidlabs/MonoRepoDeps
+  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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: mono_repo_deps
 version: !ruby/object:Gem::Version
-  version: 0.1.14
+  version: 0.2.1
 platform: ruby
 authors:
 - Nikita Kononov
-autorequire:
+autorequire: 
 bindir: exe
 cert_chain: []
-date: 2024-01-31 00:00:00.000000000 Z
+date: 2024-10-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: sorbet-runtime
@@ -284,6 +284,7 @@ files:
 - lib/mono_repo_deps/task.rb
 - lib/mono_repo_deps/task/manager.rb
 - lib/mono_repo_deps/version.rb
+- mono_repo_deps.gemspec
 - sig/mono_repo_deps.rbs
 homepage: https://github.com/droidlabs/mono_repo_deps
 licenses:
@@ -292,7 +293,7 @@ metadata:
   homepage_uri: https://github.com/droidlabs/mono_repo_deps
   source_code_uri: https://github.com/droidlabs/mono_repo_deps
   changelog_uri: https://github.com/droidlabs/mono_repo_deps
-post_install_message:
+post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
@@ -308,7 +309,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubygems_version: 3.1.6
-signing_key:
+signing_key: 
 specification_version: 4
 summary: A Ruby gem for efficiently managing dependencies within a monorepo.
 test_files: []