ree 1.0.47 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: acd36218ecd239c1b8977b93f10b9d42b21870acd6d20bacf5f4bd403eff7bbe
-  data.tar.gz: d8416af9bb24a3adf8d73e529736ce25538de021661e5c08a19b1d9b7aca9b2a
+  metadata.gz: 2f0f2ca665d289e3603982d8fefe5397fdbfacfdc2e11221e0c1d671e088f1b2
+  data.tar.gz: 2c4c6b8bfcd5e1f88217c39e8c33f914ff4f1d706a08e32a55c281cb5e633e16
 SHA512:
-  metadata.gz: 9f1b24e7100258545120f064a20c02787f10fd0d531ac52072fe1bb1f7202da9a7a62ba8c6f466c2668119cf362149ab42e225ab89dad5ac199df3354996cb75
-  data.tar.gz: f0d263aeefee18f47c81b29a3c8d2d3da51390d90c539eb931d91dc10be8bfd710da10a8880e385ccc36f6ca71a73bafe277e2a7d6b2f03fb805c183e1219f6c
+  metadata.gz: 8dc3a61e17a907c33aa125d7f094fb7fce07b7b35e88e6b76d8973bfe37508d7205a7a687a7bb63b09fe0d639f3d0230c01a320717ee782c2a3aaf6ee94458b2
+  data.tar.gz: 7a0b94dcf8a004578a87ce3c7ee221862729c70afe3998af1ad463710a57023ea05733ba29425358c01f20c49fc7b4081e1a7e61fb82611f6839fabfad050465

data/.rspec

@@ -1,3 +1,4 @@
 --format documentation
 --color
 --require spec_helper
+--exclude-pattern "**/sample_project/**/*"

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    ree (1.0.47)
+    ree (1.1.0)
       commander (~> 5.0.0)
 
 GEM
@@ -45,6 +45,7 @@ PLATFORMS
   x86_64-darwin-19
   x86_64-darwin-21
   x86_64-darwin-22
+  x86_64-darwin-23
   x86_64-linux
 
 DEPENDENCIES

data/exe/ree

@@ -85,12 +85,6 @@ class ReeCliRunner
 
         Ree::CLI::GeneratePackage.run(**options_with_defaults)
         Ree::CLI::GeneratePackagesSchema.run(options_with_defaults[:project_path])
-
-        Ree::CLI::GeneratePackageSchema.run(
-          package_name: options_with_defaults[:package_name],
-          project_path: options_with_defaults[:project_path],
-          silence: false
-        )
       end
     end
 
@@ -112,31 +106,6 @@ class ReeCliRunner
       end
     end
 
-    command :"gen.package_json" do |c|
-      c.syntax      = 'ree gen.package_json PACKAGE_NAME'
-      c.description = 'generates Package.schema.json for specific package'
-      c.summary     = '> ' + c.description
-      c.example     'ree gen.package_json PACKAGE_NAME', ''
-      c.option      '--silence', String, 'Silence all logs'
-      c.option      '--project_path [ROOT_PROJECT_DIR]', String, 'Root project dir path'
-      c.action do |args, options|
-        package_name = args.first || ""
-        options_hash = options.__hash__
-
-        if options_hash[:project_path]
-          options_hash[:project_path] = File.expand_path(options_hash[:project_path])
-        end
-
-        default_options = {
-          package_name: package_name,
-          project_path: options_hash[:project_path] || File.expand_path(Dir.pwd),
-          silence: options_hash.has_key?(:silence)
-        }
-
-        Ree::CLI::GeneratePackageSchema.run(**default_options)
-      end
-    end
-
     command :"gen.template" do |c|
       c.syntax      = "ree gen.template TEMPLATE_NAME [options]"
       c.description = "generates template from ROOT/.ree/templates folder with specified variables"

data/lib/ree/cli/indexing/index_file.rb

@@ -19,7 +19,7 @@ module Ree
   
             current_package_schema = self.find_package(File.dirname(file_path))
   
-            return {} unless current_package_schema
+            return '{}' unless current_package_schema
   
             package_schema = JSON.load_file(current_package_schema)
             current_package_name = package_schema["name"].to_sym
@@ -65,12 +65,6 @@ module Ree
           end
   
           def find_package(dir)
-            package_schema = File.join(dir, Ree::PACKAGE_SCHEMA_FILE)
-  
-            if File.exist?(package_schema)
-              return package_schema
-            end
-  
             if dir == '/'
               return nil
             end

data/lib/ree/cli/indexing/index_package.rb

@@ -23,7 +23,7 @@ module Ree
             hsh[:objects] = {}
   
             package_name = package_name.to_sym
-            facade.load_entire_package(package_name)
+            facade.read_package_structure(package_name)
             package = facade.get_loaded_package(package_name)
             package_hsh = index_package_entry(package)
   

data/lib/ree/cli/indexing/index_project.rb

@@ -30,12 +30,10 @@ module Ree
                 gem_package_hsh = {}
                 gem_package_hsh[:name] = package.name
                 gem_package_hsh[:gem] = package.gem_name
-                gem_package_hsh[:schema_rpath] = package.schema_rpath
                 gem_package_hsh[:entry_rpath] = package.entry_rpath
                 gem_package_hsh[:objects] = package.objects.map {
                   {
                     name: _1.name,
-                    schema_rpath: _1.schema_rpath,
                     file_rpath: _1.rpath,
                     mount_as: _1.mount_as,
                     methods: map_fn_methods(_1),
@@ -57,7 +55,7 @@ module Ree
   
               next if package.dir.nil?
   
-              facade.load_entire_package(package.name)
+              facade.read_package_structure(package.name)
   
               package_hsh = index_package_entry(package)
   

data/lib/ree/cli/indexing.rb

@@ -12,13 +12,11 @@ module Ree
         def index_package_entry(package)
           package_hsh = {}
           package_hsh[:name] = package.name
-          package_hsh[:schema_rpath] = package.schema_rpath
           package_hsh[:entry_rpath] = package.entry_rpath
           package_hsh[:tags] = package.tags
           package_hsh[:objects] = package.objects.map {
             {
               name: _1.name,
-              schema_rpath: _1.schema_rpath,
               file_rpath: _1.rpath,
               mount_as: _1.mount_as,
               methods: map_fn_methods(_1),

data/lib/ree/cli/spec_runner.rb

@@ -118,7 +118,7 @@ module Ree
         names = packages.map(&:name)
 
         names.select do |package_name|
-          package = container.packages_facade.read_package_schema_json(package_name)
+          package = container.packages_facade.get_loaded_package(package_name)
           package.tags.include?(@tag_name)
         end.compact
       end

data/lib/ree/cli.rb

@@ -4,7 +4,6 @@ module Ree
   module CLI
     autoload :Init, 'ree/cli/init'
     autoload :GeneratePackagesSchema, 'ree/cli/generate_packages_schema'
-    autoload :GeneratePackageSchema, 'ree/cli/generate_package_schema'
     autoload :GeneratePackage, 'ree/cli/generate_package'
     autoload :GenerateTemplate, 'ree/cli/generate_template'
     autoload :Indexing, 'ree/cli/indexing'

data/lib/ree/container.rb

@@ -62,6 +62,12 @@ class Ree::Container
   # @param [Symbol] package_name
   # @return [Ree::Package]
   def load_package(package_name)
+    @packages_facade.read_package_structure(package_name)
+  end
+
+  # @param [Symbol] package_name
+  # @return [Ree::Package]
+  def load_entire_package(package_name)
     @packages_facade.load_entire_package(package_name)
   end
 end

data/lib/ree/core/package.rb

@@ -3,13 +3,12 @@
 require 'pathname'
 
 class Ree::Package
-  attr_reader :schema_version, :name, :schema_rpath, :entry_rpath,
+  attr_reader :schema_version, :name, :entry_rpath, :objects_store,
               :module, :tags, :preload, :default_links, :gem_name
 
-  def initialize(schema_version, name, entry_rpath, schema_rpath, gem_name = nil)
+  def initialize(schema_version, name, entry_rpath, gem_name = nil)
     @schema_version = schema_version
     @name = name
-    @schema_rpath = schema_rpath
     @entry_rpath = entry_rpath
     @objects_store = {}
     @deps_store = {}
@@ -51,11 +50,6 @@ class Ree::Package
     @tags = (@tags + list).map(&:to_s).uniq; self
   end
 
-  # @param [String] val
-  def set_schema_rpath(val)
-    @schema_rpath = val; self
-  end
-
   def reset
     @entry_loaded = false
     @schema_loaded = false
@@ -94,7 +88,7 @@ class Ree::Package
   end
 
   def dir
-    @dir ||= @schema_rpath ? Pathname.new(@schema_rpath).dirname.to_s : nil
+    @dir ||= @entry_rpath ? Pathname.new(@entry_rpath).dirname.parent.to_s : nil
   end
 
   def gem?

data/lib/ree/core/package_file_structure_loader.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require 'pathname'
+
+class Ree::PackageFileStructureLoader
+  PACKAGE_FOLDER = 'package'
+
+  # @param [Ree::Package] package Loaded package
+  # @return [Ree::Package]
+  def call(package)
+    return package if package.schema_loaded?
+
+    package_dir = if package && package.gem?
+      File.join(Ree.gem(package.gem_name).dir, package.dir)
+    else
+      File.join(Ree.root_dir, package.dir)
+    end
+
+    root_dir = if package.gem?
+      Ree.gem(package.gem_name).dir
+    else
+      Ree.root_dir
+    end
+
+    object_store = {}
+    package.set_schema_loaded
+   
+    files_dir = File.join(package_dir, PACKAGE_FOLDER)
+    Dir[File.join(files_dir, '**', '*.rb')].each do |path|
+      file_path = Pathname.new(path)
+      object_name = File.basename(path, '.rb')
+      rpath = file_path.relative_path_from(root_dir)
+
+      object = Ree::Object.new(
+        object_name.to_sym,
+        rpath,
+        rpath,
+      )
+
+      if object_store.has_key?(object_name)
+        raise Ree::Error.new("duplicate object name for '#{object_name}': #{rpath}", :invalid_package_file_structure)
+      end
+
+      object_store[object_name] = true
+
+      object.set_package(package.name)
+
+      package.set_object(object)
+    end
+
+    package
+  end
+end

data/lib/ree/core/package_loader.rb

@@ -4,92 +4,98 @@ require 'set'
 require 'pathname'
 
 class Ree::PackageLoader
+  include Ree::Args
+
   def initialize(packages_store)
-    @packages_store = packages_store
     @loaded_paths = {}
     @loaded_packages = {}
+    @packages_store = packages_store
   end
 
-  def reset
-    @loaded_paths = {}
-  end
+  def load_entire_package(package_name)
+    return if @loaded_packages[package_name]
 
-  # @param [Symbol] name Package name
-  def call(name)
-    return @loaded_packages[name] if @loaded_packages.has_key?(name)
+    package = get_loaded_package(package_name)
 
-    Ree.logger.debug("full_package_load(:#{name})")
-    recursively_load_package(name, Hash.new(false))
-    @loaded_packages[name]
-  end
+    return unless package
+    
+    package.objects.each do |package_object|
+      object_path = Ree::PathHelper.abs_object_path(package_object)
 
-  def load_file(path, package_name)
-    @loaded_paths[package_name] ||= {}
-    return if @loaded_paths[package_name][path]
-    @loaded_paths[package_name][path] = true
+      load_file(object_path, package.name)
+    end
 
-    Ree.logger.debug("load_file(:#{package_name}, '#{path}')")
-    Kernel.require(path)
+    @loaded_packages[package.name] = true
+
+    package.deps.each do |dep|
+      load_entire_package(dep.name)
+    end 
   end
 
-  private
+  def get_loaded_package(package_name)
+    package = get_package(package_name)
+    load_package_entry(package_name)
+    
+    return package if package.schema_loaded?
 
-  def recursively_load_package(name, loaded_packages)
-    package = @packages_store.get(name)
-    @loaded_packages[name] = package
+    read_package_structure(package_name)
 
-    if !package
-      raise Ree::Error.new(
-        "Package :#{name} was not found. Did you mistype the name? Run `ree gen.packages_json` to update Packages.schema.json",
-        :invalid_package_name
-      )
+    package
+  end
+
+  def get_package(package_name, raise_if_missing = true)
+    check_arg(package_name, :package_name, Symbol)
+    package = @packages_store.get(package_name)
+
+    if !package && raise_if_missing
+      raise Ree::Error.new("Package :#{package_name} is not found in Packages.schema.json. Run `ree gen.packages_json` to update schema.", :package_schema_not_found)
     end
 
-    if package.dir.nil?
-      package.set_schema_loaded
-      return @loaded_packages[name] = package
+    package
+  end
+
+  def load_package_entry(package_name)
+    package = @packages_store.get(package_name)
+
+    if package.nil?
+      raise Ree::Error.new("package :#{package_name} not found in Packages.schema.json")
     end
 
-    not_loaded = Set.new(
-      [name, package.deps.map(&:name)]
-        .uniq
-        .select { |pn| !loaded_packages[pn] }
+    return if package.loaded?
+
+    Ree.logger.debug("load_package_entry(:#{package_name})")
+
+    load_file(
+      Ree::PathHelper.abs_package_entry_path(package),
+      package_name
     )
+  end
 
-    if not_loaded.include?(name)
-      load_file(
-        Ree::PathHelper.abs_package_entry_path(package), name
-      )
+  def read_package_structure(package_name)
+    package = get_package(package_name)
 
-      Dir[File.join(Ree::PathHelper.abs_package_module_dir(package), '**/*.rb')].each do |path|
-        load_file(path, name)
-      end
+    Ree.logger.debug("read_package_file_structure(:#{package_name})")
 
-      loaded_packages[name] = true
+    if !package.dir
+      package.set_schema_loaded
+      return package
     end
 
-    if !ENV.has_key?('REE_SKIP_ENV_VARS_CHECK')
-      package.env_vars.each do |env_var|
-        if !ENV.has_key?(env_var.name)
-          msg = <<~DOC
-            package: :#{package.name}
-            path: #{File.join(Ree::PathHelper.project_root_dir(package), package.entry_rpath)}
-            error: Package :#{name} requires env var '#{env_var.name}' to be set
-          DOC
-
-          raise Ree::Error.new(msg, :env_var_not_set)
-        end
-      end
-    end
+    Ree::PackageFileStructureLoader.new.call(package)
+  end
 
-    package.deps.each do |dep|
-      if !loaded_packages[dep.name]
-        recursively_load_package(dep.name, loaded_packages)
-      end
-    end
+  def reset
+    @loaded_paths = {}
+  end
+
+  def load_file(path, package_name)
+    @loaded_paths[package_name] ||= {}
+    return if @loaded_paths[package_name][path]
+    @loaded_paths[package_name][path] = true
 
-    package.set_schema_loaded
+    Ree.logger.debug("load_file(:#{package_name}, '#{path}')")
 
-    @loaded_packages[name] = package
+    Kernel.require(path)
   end
 end
+

data/lib/ree/core/packages_detector.rb

@@ -4,40 +4,38 @@ require 'pathname'
 
 class Ree::PackagesDetector
   # @param [String] dir Packages root dir
-  # @return [ArrayOf[{name: String, entry_path: String, package_schema_path: String, gem_name: Nilor[String]}]]
+  # @return [ArrayOf[{name: String, entry_path: String, gem_name: Nilor[String]}]]
   def call(dir, gem_name = nil)
     if !Dir.exist?(dir)
       raise Ree::Error.new("dir does not exist: #{dir}", :invalid_dir)
     end
 
-    files = File.join(dir, "**/", Ree::PACKAGE_SCHEMA_FILE)
     names = {}
+    packages = []
 
-    Dir[files].map do |file|
-      package_schema_path = Pathname
-        .new(file)
-        .relative_path_from(Pathname.new(dir))
-        .to_s
+    package_dirs = File.join(dir, "**/package")
+    Dir[package_dirs].each do |package_dir|
+      next unless File.directory?(package_dir)
 
-      name = package_schema_path.split('/')[-2]
-      entry_path = Ree::PathHelper.package_entry_path(package_schema_path)
+      dir_path = Pathname.new(package_dir)
+      name = dir_path.parent.basename.to_s
 
-      if !File.exist?(File.join(dir, entry_path))
-        Ree.logger.error("Entry file does not exist for '#{name}' package: #{entry_path}")
-      end
+      next if names.has_key?(name)
 
-      if names.has_key?(name)
-        raise Ree::Error.new("package '#{name}' has duplicate defintions.\n\t1) #{names[name]},\n\t2) #{entry_path}", :duplicate_package)
-      end
+      package_rel_path = dir_path.relative_path_from(dir)
+      parent_rel_path = dir_path.parent.relative_path_from(dir)
+
+      entry_path = Ree::PathHelper.package_entry_path(package_rel_path)
 
       names[name] = entry_path
 
-      {
+      packages << {
         name: name.to_sym,
         entry_path: entry_path,
-        package_schema_path: package_schema_path,
         gem_name: gem_name
       }
     end
+
+    packages
   end
 end

data/lib/ree/core/packages_schema.rb

@@ -11,12 +11,12 @@ module Ree::PackagesSchema
 
   module Packages
     NAME = 'name'
-    SCHEMA = 'schema'
+    ENTRY_PATH = 'entry_path'
     GEM = 'gem'
   end
 
   module GemPackages
     NAME = 'name'
-    SCHEMA = 'schema'
+    ENTRY_PATH = 'entry_path'
   end
 end

data/lib/ree/core/packages_schema_builder.rb

@@ -19,20 +19,21 @@ class Ree::PackagesSchemaBuilder
       gem_packages += @packages_detector.call(gem.dir, gem.name)
     end
 
+
     result = {
       Schema::SCHEMA_VERSION => Schema::SCHEMA_VERSION_NUMBER,
       Schema::SCHEMA_TYPE => Schema::PACKAGES,
       Schema::PACKAGES => packages.sort_by { _1[:name] }.map {
         {
           Schema::Packages::NAME => _1.fetch(:name),
-          Schema::Packages::SCHEMA => _1.fetch(:package_schema_path),
+          Schema::Packages::ENTRY_PATH => _1.fetch(:entry_path),
         }
       },
       Schema::GEM_PACKAGES => gem_packages.sort_by { [_1.fetch(:gem_name), _1.fetch(:name)] }.map {
         {
           Schema::Packages::GEM => _1.fetch(:gem_name),
           Schema::Packages::NAME => _1.fetch(:name),
-          Schema::Packages::SCHEMA => _1.fetch(:package_schema_path),
+          Schema::Packages::ENTRY_PATH => _1.fetch(:entry_path),
         }
       },
     }

data/lib/ree/core/packages_schema_loader.rb

@@ -48,7 +48,7 @@ class Ree::PackagesSchemaLoader
 
     data.each do |item|
       name = item[Schema::Packages::NAME].to_s
-      schema_rpath = item[Schema::Packages::SCHEMA].to_s
+      entry_path = item[Schema::Packages::ENTRY_PATH].to_s
       list = [name, schema]
 
       if list.reject(&:empty?).size != list.size
@@ -56,7 +56,7 @@ class Ree::PackagesSchemaLoader
       end
 
       if names.has_key?(name)
-        raise Ree::Error.new("duplicate package name for '#{item[:name]}'", :invalid_packages_schema)
+        raise Ree::Error.new("duplicate package name for '#{name}'", :invalid_packages_schema)
       end
 
       names[name] = true
@@ -64,8 +64,7 @@ class Ree::PackagesSchemaLoader
       package = Ree::Package.new(
         schema_version,
         name.to_sym,
-        Ree::PathHelper.package_entry_path(schema_rpath),
-        schema_rpath,
+        entry_path,
         gem_name
       )
 
@@ -83,8 +82,7 @@ class Ree::PackagesSchemaLoader
         Ree::Package.new(
           schema_version,
           name.to_sym,
-          Ree::PathHelper.package_entry_path(schema_rpath),
-          schema_rpath,
+          entry_path,
           gem_name
         )
       )

data/lib/ree/core/path_helper.rb

@@ -55,16 +55,14 @@ class Ree::PathHelper
     # @param [String] directory inside package
     # @return [String] name of package
     def package_name_from_dir(dir)
-      package_schema = File.join(dir, Ree::PACKAGE_SCHEMA_FILE)
-
-      if File.exist?(package_schema)
-        return package_schema.split('/')[-2]
-      end
-
       if dir == '/'
         return nil
       end
 
+      if dir == 'package'
+        return File.expand_path('..', dir)
+      end
+
       package_name_from_dir(File.expand_path('..', dir))
     end
 
@@ -90,12 +88,6 @@ class Ree::PathHelper
       )
     end
 
-    # @param [Ree::Package] package Package schema
-    # @return [String] Absolute package schema path
-    def abs_package_schema_path(package)
-      File.join(project_root_dir(package), package.schema_rpath)
-    end
-
     # @param [Ree::Package] package Package schema
     # @return [String] Absolute package folder path (ex. /data/project/bc/accounts)
     def abs_package_dir(package)

data/lib/ree/dsl/build_package_dsl.rb

@@ -133,7 +133,7 @@ class Ree::BuildPackageDsl
     package = @packages_facade.get_package(name, false)
 
     if package.nil?
-      package = Ree::Package.new(Ree::VERSION, name, nil, nil, nil)
+      package = Ree::Package.new(Ree::VERSION, name, nil, nil)
       @packages_facade.store_package(package)
     end
 

data/lib/ree/dsl/import_dsl.rb

@@ -6,6 +6,8 @@ class Ree::ImportDsl
   end
 
   def execute(klass, proc)
+    patch_const_missing
+    
     class_constant = self.class.instance_exec(&proc)
 
     [
@@ -28,8 +30,21 @@ class Ree::ImportDsl
       .eval("#{e.name} = Ree::ImportDsl::ClassConstant.new('#{e.name}')")
 
     retry
+  ensure
+    cancel_patch_const_missing
   end
 
+  def patch_const_missing
+    return if @_original_const_missing
+    @_original_const_missing = Module.instance_method(:const_missing)
+    Module.define_method(:const_missing){ |const_name| raise NameError.new("class not found #{const_name.to_s}", const_name) }
+  end
+
+  def cancel_patch_const_missing
+    Module.define_method(:const_missing, @_original_const_missing)
+    @_original_const_missing = nil
+  end
+  
   private def extract_constants(class_constant)
     [class_constant] + class_constant.constants
   end

data/lib/ree/facades/packages_facade.rb

@@ -27,23 +27,10 @@ class Ree::PackagesFacade
     end
   end
 
-  def perf_mode?(package)
-    package.gem? ? true : Ree.performance_mode?
-  end
-
   # @param [Symbol] package_name
   # @return [Ree::Package]
   def get_loaded_package(package_name)
-    package = get_package(package_name)
-    return package if package.schema_loaded?
-
-    if perf_mode?(package)
-      read_package_schema_json(package_name)
-    else
-      load_entire_package(package_name)
-    end
-
-    package
+    @package_loader.get_loaded_package(package_name)
   end
 
   # @param [Symbol] package_name
@@ -53,10 +40,6 @@ class Ree::PackagesFacade
     package = get_loaded_package(package_name)
     object = package.get_object(object_name)
 
-    if !object && perf_mode?(package)
-      raise Ree::Error.new("Ree object :#{object_name} for package :#{package_name} not found")
-    end
-
     object
   end
 
@@ -67,98 +50,26 @@ class Ree::PackagesFacade
     !object.nil?
   end
 
-  # @param [Symbol] package_name
-  # @return nil
-  def dump_package_schema(package_name)
-    Ree.logger.debug("dump_package_schema(:#{package_name})")
-
-    read_package_schema_json(package_name)
-    package = get_package(package_name)
-
-    if package.dir
-      schema_path = Ree::PathHelper.abs_package_schema_path(package)
-
-      if !File.exist?(schema_path)
-        raise Ree::Error.new("File does not exist: #{schema_path}", :invalid_path)
-      end
-
-      schema = Ree::PackageSchemaBuilder.new.call(package)
-      json = JSON.pretty_generate(schema)
-      File.write(schema_path, json, mode: 'w')
-
-      json
-    end
-  end
-
-  # @param [Symbol] package_name
-  # @return nil
-  def write_package_schema(package_name)
-    Ree.logger.debug("write_package_schema(:#{package_name})")
-
-    load_entire_package(package_name)
-    package = get_package(package_name)
-
-    if package.dir
-      schema_path = Ree::PathHelper.abs_package_schema_path(package)
-
-      if !File.exist?(schema_path)
-        raise Ree::Error.new("File does not exist: #{schema_path}", :invalid_path)
-      end
-
-      schema = Ree::PackageSchemaBuilder.new.call(package)
-      json = JSON.pretty_generate(schema)
-      File.write(schema_path, json, mode: 'w')
-
-      json
-    end
-  end
-
   # @param [Symbol] package_name
   # @return nil
   def load_package_entry(package_name)
-    package = @packages_store.get(package_name)
-
-    if package.nil?
-      raise Ree::Error.new("package :#{package_name} not found in Packages.schema.json")
-    end
-
-    return if package.loaded?
-
-    Ree.logger.debug("load_package_entry(:#{package_name})")
-
-    load_file(
-      Ree::PathHelper.abs_package_entry_path(package),
-      package_name
-    )
+    @package_loader.load_package_entry(package_name)
   end
 
+
   # @param [Symbol] package_name
   # @param [Symbol] object_name
   # @return [Ree::Object]
   def load_package_object(package_name, object_name)
     package = get_loaded_package(package_name)
-    load_package_entry(package_name)
-
     object = get_object(package_name, object_name)
-    return object if object && object.loaded?
-
-    if !object && !perf_mode?(package)
-      Dir[
-        File.join(
-          Ree::PathHelper.abs_package_module_dir(package),
-          "**/#{object_name}.rb"
-        )
-      ].each do |path|
-        load_file(path, package_name)
-      end
-
-      object = get_object(package_name, object_name)
-    end
 
-    if !object
+    unless object
       raise Ree::Error.new("object :#{object_name} from :#{package_name} was not found")
     end
 
+    return object if object.loaded?
+
     Ree.logger.debug("load_package_object(:#{package_name}, :#{object_name})")
 
     if object.rpath
@@ -171,26 +82,14 @@ class Ree::PackagesFacade
 
   # @param [Symbol] package_name
   # @return [Ree::Package]
-  def load_entire_package(package_name)
-    @package_loader.call(package_name)
+  def read_package_structure(package_name)
+    @package_loader.read_package_structure(package_name)
   end
 
   # @param [Symbol] package_name
   # @return [Ree::Package]
-  def read_package_schema_json(package_name)
-    @loaded_schemas ||= {}
-    return @loaded_schemas[package_name] if @loaded_schemas[package_name]
-
-    Ree.logger.debug("read_package_schema_json(:#{package_name})")
-    package = get_package(package_name)
-
-    if !package.dir
-      package.set_schema_loaded
-      return package
-    end
-
-    schema_path = Ree::PathHelper.abs_package_schema_path(package)
-    @loaded_schemas[package_name] = Ree::PackageSchemaLoader.new.call(schema_path, package)
+  def load_entire_package(package_name)
+    @package_loader.load_entire_package(package_name)
   end
 
   # @return [Ree::PackagesStore]
@@ -217,14 +116,7 @@ class Ree::PackagesFacade
   # @param [Symbol] package_name
   # @return [Ree::Package]
   def get_package(package_name, raise_if_missing = true)
-    check_arg(package_name, :package_name, Symbol)
-    package = @packages_store.get(package_name)
-
-    if !package && raise_if_missing
-      raise Ree::Error.new("Package :#{package_name} is not found in Packages.schema.json. Run `ree gen.packages_json` to update schema.", :package_schema_not_found)
-    end
-
-    package
+    @package_loader.get_package(package_name, raise_if_missing)
   end
 
   # @param [Ree::Package] package

data/lib/ree/templates/init/ree.setup.rb

@@ -8,7 +8,4 @@ end
 if ENV['RUBY_ENV'] == 'production'
   # Define preload context for registered objects
   Ree.preload_for(:production)
-
-  # Use performance mode to load packages and registered objects based on schema files
-  Ree.set_performance_mode
 end

data/lib/ree/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Ree
-  VERSION = "1.0.47"
+  VERSION = "1.1.0"
 end

data/lib/ree.rb

@@ -32,10 +32,8 @@ module Ree
   autoload :BuildPackageDsl, 'ree/dsl/build_package_dsl'
   autoload :PackageDSL, 'ree/package_dsl'
   autoload :PackageEnvVar, 'ree/core/package_env_var'
+  autoload :PackageFileStructureLoader, 'ree/core/package_file_structure_loader'
   autoload :PackageLoader, 'ree/core/package_loader'
-  autoload :PackageSchema, 'ree/core/package_schema'
-  autoload :PackageSchemaBuilder, 'ree/core/package_schema_builder'
-  autoload :PackageSchemaLoader, 'ree/core/package_schema_loader'
   autoload :PackagesDetector, 'ree/core/packages_detector'
   autoload :PackagesFacade, 'ree/facades/packages_facade'
   autoload :PackagesSchema, 'ree/core/packages_schema'
@@ -56,7 +54,6 @@ module Ree
   SCHEMAS = 'schemas'
   SCHEMA = 'schema'
   REE_SETUP = 'ree.setup.rb'
-  PACKAGE_SCHEMA_FILE = 'Package.schema.json'
   PACKAGES_SCHEMA_FILE = 'Packages.schema.json'
   ROOT_DIR_MESSAGE = 'Ree.root_dir is not set. Use Ree.init(DIR) to set project dir'
 
@@ -116,19 +113,6 @@ module Ree
       logger.level = Logger::DEBUG
     end
 
-    # Ree will use schema files to load packages and registered objects
-    def set_performance_mode
-      @performance_mode = true
-    end
-
-    def set_dev_mode
-      @performance_mode = false
-    end
-
-    def performance_mode?
-      !!@performance_mode
-    end
-
     # Define preload context for registered objects
     def preload_for(env)
       check_arg(env, :env, Symbol)
@@ -215,6 +199,11 @@ module Ree
       container.load_package(name)
     end
 
+    def load_entire_package(name)
+      check_arg(name, :name, Symbol)
+      container.load_entire_package(name)
+    end
+
     def locate_packages_schema(path)
       check_arg(path, :path, String)
       Ree.logger.debug("locate_packages_schema: #{path}")
@@ -228,23 +217,6 @@ module Ree
     def root_dir
       @root_dir || (raise Ree::Error.new(ROOT_DIR_MESSAGE, :invalid_root_dir))
     end
-
-    def generate_schemas_for_all_packages(silence = false)
-      Ree.logger.debug("generate_schemas_for_all_packages") if !silence
-      facade = container.packages_facade
-
-      facade.class.write_packages_schema
-      facade.load_packages_schema
-
-      facade.packages_store.packages.each do |package|
-        next if package.gem?
-        next if package.dir.nil?
-        puts("Generating Package.schema.json for :#{package.name} package") if !silence
-
-        facade.load_entire_package(package.name)
-        facade.write_package_schema(package.name)
-      end
-    end
   end
 end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ree
 version: !ruby/object:Gem::Version
-  version: 1.0.47
+  version: 1.1.0
 platform: ruby
 authors:
 - Ruslan Gatiyatov
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2024-08-26 00:00:00.000000000 Z
+date: 2025-01-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: commander
@@ -64,7 +64,6 @@ files:
 - lib/ree/bean_dsl.rb
 - lib/ree/cli.rb
 - lib/ree/cli/generate_package.rb
-- lib/ree/cli/generate_package_schema.rb
 - lib/ree/cli/generate_packages_schema.rb
 - lib/ree/cli/generate_template.rb
 - lib/ree/cli/indexing.rb
@@ -127,10 +126,8 @@ files:
 - lib/ree/core/package.rb
 - lib/ree/core/package_dep.rb
 - lib/ree/core/package_env_var.rb
+- lib/ree/core/package_file_structure_loader.rb
 - lib/ree/core/package_loader.rb
-- lib/ree/core/package_schema.rb
-- lib/ree/core/package_schema_builder.rb
-- lib/ree/core/package_schema_loader.rb
 - lib/ree/core/packages_detector.rb
 - lib/ree/core/packages_schema.rb
 - lib/ree/core/packages_schema_builder.rb
@@ -178,9 +175,7 @@ files:
 - lib/ree/templates/package/.rspec
 - lib/ree/templates/package/<%=package_subdir_name%>/<%=package_name%>.rb
 - lib/ree/templates/package/<%=package_subdir_name%>/<%=package_name%>/.gitkeep
-- lib/ree/templates/package/Package.schema.json
 - lib/ree/templates/package/bin/console
-- lib/ree/templates/package/spec/package_schema_spec.rb
 - lib/ree/templates/package/spec/spec_helper.rb
 - lib/ree/templates/template_detector.rb
 - lib/ree/templates/template_renderer.rb

data/lib/ree/cli/generate_package_schema.rb

@@ -1,40 +0,0 @@
-require 'fileutils'
-
-module Ree
-  module CLI
-    class GeneratePackageSchema
-      class << self
-        def run(package_name:, project_path:, silence: false)
-          ENV['REE_SKIP_ENV_VARS_CHECK'] = 'true'
-
-          path = Ree.locate_packages_schema(project_path)
-          dir = Pathname.new(path).dirname.to_s
-
-          Ree.init(dir)
-          Ree.set_dev_mode
-
-          if package_name.strip.empty?
-            puts("Generating Package.schema.json for all packages") if !silence
-            Ree.generate_schemas_for_all_packages(silence)
-            return
-          end
-
-          puts("Generating Package.schema.json for :#{package_name} package") if !silence
-
-          package_name = package_name.to_sym
-
-          facade = Ree.container.packages_facade
-          facade.load_packages_schema
-          facade.load_entire_package(package_name)
-          facade.write_package_schema(package_name)
-
-          package = facade.get_package(package_name)
-          schema_path = Ree::PathHelper.abs_package_schema_path(package)
-
-          puts("output: #{schema_path}") if !silence
-          puts("done") if !silence
-        end
-      end
-    end
-  end
-end

data/lib/ree/core/package_schema.rb

@@ -1,31 +0,0 @@
-# frozen_string_literal: true
-
-module Ree::PackageSchema
-  SCHEMA_VERSION_NUMBER = '1.1'
-
-  SCHEMA_TYPE = 'schema_type'
-  REE_VERSION = 'ree_version'
-  SCHEMA_VERSION = 'schema_version'
-  NAME = 'name'
-  PACKAGE = 'package'
-  ENTRY_PATH = 'entry_path'
-  OBJECTS = 'objects'
-  ENV_VARS = 'env_vars'
-  DEPENDS_ON = 'depends_on'
-  TAGS = 'tags'
-
-  module Objects
-    NAME = 'name'
-    SCHEMA = 'schema'
-    TAGS = 'tags'
-  end
-
-  module DependsOn
-    NAME = 'name'
-  end
-
-  module EnvVars
-    NAME = 'name'
-    DOC = 'doc'
-  end
-end

data/lib/ree/core/package_schema_builder.rb

@@ -1,46 +0,0 @@
-# frozen_string_literal: true
-
-require 'pathname'
-require 'json'
-
-class Ree::PackageSchemaBuilder
-  Schema = Ree::PackageSchema
-
-  # @param [Ree::Package] package
-  # @return [Hash]
-  def call(package)
-    Ree.logger.debug("generating package schema for '#{package.name}' package")
-
-    if !package.loaded?
-      raise Ree::Error.new("package schema should be loaded", :invalid_schema)
-    end
-
-    data = {
-      Schema::SCHEMA_TYPE => Schema::PACKAGE,
-      Schema::SCHEMA_VERSION => Schema::SCHEMA_VERSION_NUMBER,
-      Schema::NAME => package.name,
-      Schema::ENTRY_PATH => package.entry_rpath,
-      Schema::TAGS => package.tags,
-      Schema::DEPENDS_ON => package.deps.sort_by(&:name).map { |dep|
-        {
-          Schema::DependsOn::NAME => dep.name,
-        }
-      },
-      Schema::ENV_VARS => package.env_vars.sort_by(&:name).map { |var|
-        {
-          Schema::EnvVars::NAME => var.name,
-          Schema::EnvVars::DOC => var.doc,
-        }
-      },
-      Schema::OBJECTS => package.objects.select { !_1.rpath.nil? }.sort_by(&:name).map { |object|
-        {
-          Schema::Objects::NAME => object.name,
-          Schema::Objects::SCHEMA => object.schema_rpath,
-          Schema::Objects::TAGS => object.tags
-        }
-      }
-    }
-
-    data
-  end
-end

data/lib/ree/core/package_schema_loader.rb

@@ -1,172 +0,0 @@
-# frozen_string_literal: true
-
-require 'json'
-require 'pathname'
-
-class Ree::PackageSchemaLoader
-  # Sample Package.schema.json
-  # {
-  #   "schema_type": "package",
-  #   "schema_version": "1.2.3",
-  #   "name": "accounts",
-  #   "entry_path": "package/accounts.rb",
-  #   "depends_on": [
-  #     {
-  #       "name": "clock",
-  #     },
-  #     {
-  #       "name": "test_utils",
-  #     }
-  #   ],
-  #   "env_vars": [
-  #     {
-  #       "name": "accounts.string_var",
-  #       "doc": null
-  #     },
-  #     {
-  #       "name": "accounts.integer_var",
-  #       "doc": "integer value"
-  #     }
-  #   ],
-  #   "objects": [
-  #     {
-  #       "name": "accounts_cfg",
-  #       "schema": "schemas/accounts/accounts_cfg.schema.json"
-  #     },
-  #     {
-  #       "name": "transaction",
-  #       "schema": "schemas/accounts/transaction.schema.json"
-  #     }
-  #   ]
-  # }
-
-  Schema = Ree::PackageSchema
-
-  # @param [String] abs_schema_path Absolute path to package Package.schema.json file
-  # @param [Nilor[Ree::Package]] existing_package Loaded package
-  # @return [Ree::Package]
-  def call(abs_schema_path, existing_package = nil)
-    if !File.exist?(abs_schema_path)
-      raise Ree::Error.new("File not found: #{abs_schema_path}", :invalid_package_schema)
-    end
-
-    json_schema = begin
-      JSON.load_file(abs_schema_path)
-    rescue
-      raise Ree::Error.new("Invalid content: #{abs_schema_path}", :invalid_package_schema)
-    end
-
-    schema_type = json_schema.fetch(Schema::SCHEMA_TYPE)
-
-    if schema_type != Schema::PACKAGE
-      raise Ree::Error.new("Invalid schema type: #{abs_schema_path}", :invalid_package_schema)
-    end
-
-    schema_version = json_schema.fetch(Schema::SCHEMA_VERSION) { Schema::SCHEMA_VERSION_NUMBER }
-    entry_rpath = json_schema.fetch(Schema::ENTRY_PATH)
-    package_name = json_schema.fetch(Schema::NAME).to_sym
-
-    root_dir = if existing_package && existing_package.gem?
-      Ree.gem(existing_package.gem_name).dir
-    else
-      Ree.root_dir
-    end
-
-    schema_rpath = Pathname
-      .new(abs_schema_path)
-      .relative_path_from(Pathname.new(root_dir))
-      .to_s
-
-    object_store = {}
-    deps_store = {}
-    vars_store = {}
-
-    package = if existing_package
-      existing_package
-        .set_schema_version(schema_version)
-        .set_entry_rpath(entry_rpath)
-        .set_schema_rpath(schema_rpath)
-    else
-      Ree::Package.new(
-        schema_version,
-        package_name,
-        entry_rpath,
-        schema_rpath,
-        nil
-      )
-    end
-
-    package.set_schema_loaded
-
-    json_schema.fetch(Schema::OBJECTS).each do |item|
-      name = item[Schema::Objects::NAME].to_s
-      schema_rpath = item[Schema::Objects::SCHEMA].to_s
-      list = [name, schema_rpath]
-      tags = item[Schema::Objects::TAGS] || []
-
-      if list.reject(&:empty?).size != list.size
-        raise Ree::Error.new("invalid object data for #{item.inspect}: #{abs_schema_path}", :invalid_package_schema)
-      end
-
-      if object_store.has_key?(name)
-        raise Ree::Error.new("duplicate object name for '#{item[:name]}': #{abs_schema_path}", :invalid_package_schema)
-      end
-
-      object_store[name] = true
-
-      object = Ree::Object.new(
-        name.to_sym,
-        schema_rpath,
-        Ree::PathHelper.object_rpath(schema_rpath),
-      )
-
-      object.add_tags(tags)
-      object.set_package(package.name)
-
-      package.set_object(object)
-    end
-
-    deps = json_schema.fetch(Schema::DEPENDS_ON).map do |item|
-      name = item[Schema::DependsOn::NAME].to_sym
-      list = [name]
-
-      if list.reject(&:empty?).size != list.size
-        raise Ree::Error.new("invalid depends_on for: #{item.inspect}", :invalid_package_schema)
-      end
-
-      if deps_store.has_key?(name)
-        raise Ree::Error.new("duplicate depends_on name for '#{item[:name]}'", :invalid_package_schema)
-      end
-
-      deps_store[name] = true
-      Ree::PackageDep.new(name)
-    end
-
-    package.set_deps(deps)
-
-    env_vars = json_schema.fetch(Schema::ENV_VARS).map do |item|
-      name = item[Schema::EnvVars::NAME].to_s
-      doc = item[Schema::EnvVars::DOC]
-      list = [name]
-
-      if list.reject(&:empty?).size != list.size
-        raise Ree::Error.new("invalid env_var for: #{item.inspect}", :invalid_package_schema)
-      end
-
-      if vars_store.has_key?(name)
-        raise Ree::Error.new("duplicate env_var name for '#{item[:name]}'", :invalid_package_schema)
-      end
-
-      vars_store[name] = true
-
-      Ree::PackageEnvVar.new(name, doc)
-    end
-
-    package.set_env_vars(env_vars)
-
-    tags = json_schema.fetch(Schema::TAGS)
-    package.set_tags(tags)
-
-    package
-  end
-end

data/lib/ree/templates/package/spec/package_schema_spec.rb

@@ -1,14 +0,0 @@
-RSpec.describe "<%= Ree::StringUtils.camelize(package_name) %>" do
-  it "generates package schema" do
-    require 'fileutils'
-
-    packages_schema_path = Ree.locate_packages_schema(__dir__)
-    packages_schema_dir = Pathname.new(packages_schema_path).dirname.to_s
-
-    FileUtils.cd packages_schema_dir do
-      expect(
-        system("bundle exec ree gen.package_json <%= package_name %> --silence")
-      ).to eq(true)
-    end
-  end
-end