ree 1.0.27 → 1.0.29

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3da420a1cab7745ea5024e4ff768f5dafd9c171d516f2af413ada44ce97bcb7c
-  data.tar.gz: 1ce4b640ceb2b86065baa948fbff60d9961c9f64780adf19ab0015f1cda518b8
+  metadata.gz: 8a9bafffedbc153f633b682e9a7ecbce4ad38a75dbbb9a7436798a3766d57735
+  data.tar.gz: 4b2562f2fb06c0afc492cce67abf5044b160c900057b5c24e14eb76104bf9049
 SHA512:
-  metadata.gz: 950ec9370962072c1b0734f9c5954739eb3b17987bec12e009309839fb44cd185e9bbe08c2655a49bad8309989e1059f9b2c99ccea31e63ae57ecc82de069b39
-  data.tar.gz: 5bba4ef1e49e50857c6b8b043795c19af0c579832843a7a33a451acd31f0772cddbf00d2aa32aeb764da127e03331e69bc70a120b136c115fa46a310fbf8b103
+  metadata.gz: ad6eddfb2656ed64223758a2b3f9a720597ba9bbca3edddbccb7ca4b284770db9fa03e3b5c81cdd5d771858bfff3e2b39566820a993eaa4f02baf3e821e3f116
+  data.tar.gz: 14ecf3e59cdc5d0b3a78f9fcddc74ea39cc6fb7ff77bbe2a23d6a693cf4d98f47141cfb750b4d60f9a8e09c3971e070f25d70ccff11e76121187b80e603e1666

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    ree (1.0.27)
+    ree (1.0.29)
       commander (~> 4.6.0)
 
 GEM

data/exe/ree

@@ -326,7 +326,7 @@ class ReeCliRunner
           project_path: options_hash[:project_path] || File.expand_path(Dir.pwd)
         }
 
-        puts Ree::CLI::IndexProject.run(**default_options)
+        puts Ree::CLI::Indexing::IndexProject.run(**default_options)
       end
     end
 
@@ -349,7 +349,7 @@ class ReeCliRunner
           project_path: options_hash[:project_path] || File.expand_path(Dir.pwd)
         }
 
-        puts Ree::CLI::IndexFile.run(**default_options)
+        puts Ree::CLI::Indexing::IndexFile.run(**default_options)
       end
     end
 
@@ -372,7 +372,7 @@ class ReeCliRunner
           project_path: options_hash[:project_path] || File.expand_path(Dir.pwd)
         }
 
-        puts Ree::CLI::IndexPackage.run(**default_options)
+        puts Ree::CLI::Indexing::IndexPackage.run(**default_options)
       end
     end
 

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

@@ -2,77 +2,81 @@ require 'json'
 
 module Ree
   module CLI
-    class IndexFile
-      class << self
-        def run(file_path:, project_path:)
-          ENV['REE_SKIP_ENV_VARS_CHECK'] = 'true'
-
-          path = Ree.locate_packages_schema(project_path)
-          dir = Pathname.new(path).dirname.to_s
-
-          Ree.init(dir)
-
-          file_path = File.join(dir, file_path)
-
-          current_package_schema = self.find_package(File.dirname(file_path))
-
-          return {} unless current_package_schema
-
-          package_schema = JSON.load_file(current_package_schema)
-          current_package_name = package_schema["name"].to_sym
-
-          facade = Ree.container.packages_facade
-          Ree.load_package(current_package_name)
-
-          package = facade.get_package(current_package_name)
-
-          files = Dir[
-            File.join(
-              Ree::PathHelper.abs_package_module_dir(package), '**/*.rb'
-            )
-          ]
-
-          return {} if !files.include?(file_path)
-
-          objects_class_names = package.objects.map(&:class_name)
-          file_name_const_string = Ree::StringUtils.camelize(file_path.split('/')[-1].split('.rb')[0])
-          const_string_with_module = "#{package.module}::#{file_name_const_string}"
-
-          return {} if objects_class_names.include?(const_string_with_module) # skip objects
-
-          klass = Object.const_get(const_string_with_module)
-
-          methods = klass
-            .public_instance_methods(false)
-            .reject { _1.match?(/original/) } # remove aliases defined by contracts
-            .map {
-              {
-                name: _1,
-                location: klass.public_instance_method(_1).source_location&.last,
+    module Indexing
+      class IndexFile
+        include Indexing
+
+        class << self
+          def run(file_path:, project_path:)
+            ENV['REE_SKIP_ENV_VARS_CHECK'] = 'true'
+  
+            path = Ree.locate_packages_schema(project_path)
+            dir = Pathname.new(path).dirname.to_s
+  
+            Ree.init(dir)
+  
+            file_path = File.join(dir, file_path)
+  
+            current_package_schema = self.find_package(File.dirname(file_path))
+  
+            return {} unless current_package_schema
+  
+            package_schema = JSON.load_file(current_package_schema)
+            current_package_name = package_schema["name"].to_sym
+  
+            facade = Ree.container.packages_facade
+            Ree.load_package(current_package_name)
+  
+            package = facade.get_package(current_package_name)
+  
+            files = Dir[
+              File.join(
+                Ree::PathHelper.abs_package_module_dir(package), '**/*.rb'
+              )
+            ]
+  
+            return {} if !files.include?(file_path)
+  
+            objects_class_names = package.objects.map(&:class_name)
+            file_name_const_string = Ree::StringUtils.camelize(file_path.split('/')[-1].split('.rb')[0])
+            const_string_with_module = "#{package.module}::#{file_name_const_string}"
+  
+            return {} if objects_class_names.include?(const_string_with_module) # skip objects
+  
+            klass = Object.const_get(const_string_with_module)
+  
+            methods = klass
+              .public_instance_methods(false)
+              .reject { _1.match?(/original/) } # remove aliases defined by contracts
+              .map {
+                {
+                  name: _1,
+                  location: klass.public_instance_method(_1).source_location&.last,
+                }
               }
+  
+            hsh = {
+              path: file_path,
+              package: current_package_name,
+              methods: methods
             }
-
-          hsh = {
-            path: file_path,
-            package: current_package_name,
-            methods: methods
-          }
-
-          JSON.pretty_generate({ file_name_const_string => hsh })
-        end
-
-        def find_package(dir)
-          package_schema = File.join(dir, Ree::PACKAGE_SCHEMA_FILE)
-
-          if File.exist?(package_schema)
-            return package_schema
+  
+            JSON.pretty_generate({ file_name_const_string => hsh })
           end
-
-          if dir == '/'
-            return nil
+  
+          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
+  
+            find_package(File.expand_path('..', dir))
           end
-
-          find_package(File.expand_path('..', dir))
         end
       end
     end

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

@@ -2,127 +2,36 @@ require 'json'
 
 module Ree
   module CLI
-    class IndexPackage
-      class << self
-        def run(package_name:, project_path:)
-          ENV['REE_SKIP_ENV_VARS_CHECK'] = 'true'
+    module Indexing
+      class IndexPackage
+        include Indexing
 
-          path = Ree.locate_packages_schema(project_path)
-          dir = Pathname.new(path).dirname.to_s
-
-          Ree.init(dir)
-
-          facade = Ree.container.packages_facade
-
-          hsh = {}
-          hsh[:package_schema] = {}
-          hsh[:classes] = {}
-          hsh[:objects] = {}
-
-          package_name = package_name.to_sym
-          facade.load_entire_package(package_name)
-          package = facade.get_loaded_package(package_name)
-          package_hsh = index_package_entry(package)
-
-          hsh[:package_schema] = package_hsh
-          hsh = index_public_methods_for_package_classes(package, dir, hsh)
-
-          JSON.pretty_generate(hsh)
-        end
-
-        private
-
-        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),
-              links: _1.links.sort_by(&:object_name).map { |link|
-                {
-                  Ree::ObjectSchema::Links::TARGET => link.object_name,
-                  Ree::ObjectSchema::Links::PACKAGE_NAME => link.package_name,
-                  Ree::ObjectSchema::Links::AS => link.as,
-                  Ree::ObjectSchema::Links::IMPORTS => link.constants
-                }
-              }
-            }
-          }
-
-          package_hsh
-        end
-
-        def map_fn_methods(object)
-          if !object.fn?
-            return []
-          end
+        class << self
+          def run(package_name:, project_path:)
+            ENV['REE_SKIP_ENV_VARS_CHECK'] = 'true'
   
-          klass = object.klass
-      
-          method_decorator = Ree::Contracts.get_method_decorator(
-            klass, :call, scope: :instance
-          )
-      
-          begin
-            if method_decorator.nil?
-              parameters = klass.instance_method(:call).parameters
-      
-              args = parameters.inject({}) do |res, param|
-                res[param.last] = Ree::Contracts::CalledArgsValidator::Arg.new(
-                  param.last, param.first, nil, nil
-                )
-      
-                res
-              end
-            else
-              parameters = method_decorator.args.params
-              args = method_decorator.args.get_args
-            end
-          rescue NameError
-            raise Ree::Error.new("method call is not defined for #{klass}")
-          end
-      
-          arg_list = parameters.map do |param|
-            arg = args[param.last]
-            validator = arg.validator
-            arg_type = arg.type
-      
-            type = if validator
-              validator.to_s
-            else
-              if arg_type == :block
-                "Block"
-              else
-                "Any"
-              end
-            end
-      
-            {
-              Ree::ObjectSchema::Methods::Args::ARG => arg.name,
-              Ree::ObjectSchema::Methods::Args::ARG_TYPE => arg.type,
-              Ree::ObjectSchema::Methods::Args::TYPE => type
-            }
+            path = Ree.locate_packages_schema(project_path)
+            dir = Pathname.new(path).dirname.to_s
+  
+            Ree.init(dir)
+  
+            facade = Ree.container.packages_facade
+  
+            hsh = {}
+            hsh[:package_schema] = {}
+            hsh[:classes] = {}
+            hsh[:objects] = {}
+  
+            package_name = package_name.to_sym
+            facade.load_entire_package(package_name)
+            package = facade.get_loaded_package(package_name)
+            package_hsh = index_package_entry(package)
+  
+            hsh[:package_schema] = package_hsh
+            hsh = index_public_methods_for_package_classes(package, hsh)
+  
+            JSON.pretty_generate(hsh)
           end
-      
-          [
-            {
-              Ree::ObjectSchema::Methods::DOC => method_decorator&.doc || "",
-              Ree::ObjectSchema::Methods::THROWS => method_decorator&.errors&.map { _1.name } || [],
-              Ree::ObjectSchema::Methods::RETURN => method_decorator&.contract_definition&.return_contract || "Any",
-              Ree::ObjectSchema::Methods::ARGS => arg_list
-            }
-          ]
-        end
-
-        def index_public_methods_for_package_classes(package, dir, index_hash)
-          Ree::CLI::IndexProject.send(:index_public_methods_for_package_classes, package, index_hash)
         end
       end
     end

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

@@ -1,197 +1,77 @@
 module Ree
   module CLI
-    class IndexProject
-      class << self
-        def run(project_path:)
-          ENV['REE_SKIP_ENV_VARS_CHECK'] = 'true'
-
-          path = Ree.locate_packages_schema(project_path)
-          dir = Pathname.new(path).dirname.to_s
-
-          Ree.init(dir)
-
-          index_hash = {}
-          # completion/etc data
-          index_hash[:classes] = {}
-          index_hash[:objects] = {}
-
-          # schema data
-          index_hash[:packages_schema] = {}
-          index_hash[:packages_schema][:packages] = []
-          index_hash[:packages_schema][:gem_packages] = []
-
-          facade = Ree.container.packages_facade
-
-          facade.packages_store.packages.each do |package|
-            if package.gem?
-              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: Ree::CLI::IndexPackage.send(:map_fn_methods, _1),
-                  links: _1.links.sort_by(&:object_name).map { |link|
-                    {
-                      Ree::ObjectSchema::Links::TARGET => link.object_name,
-                      Ree::ObjectSchema::Links::PACKAGE_NAME => link.package_name,
-                      Ree::ObjectSchema::Links::AS => link.as,
-                      Ree::ObjectSchema::Links::IMPORTS => link.constants
+    module Indexing
+      class IndexProject
+        include Indexing
+
+        class << self
+          def run(project_path:)
+            ENV['REE_SKIP_ENV_VARS_CHECK'] = 'true'
+  
+            path = Ree.locate_packages_schema(project_path)
+            dir = Pathname.new(path).dirname.to_s
+  
+            Ree.init(dir)
+  
+            index_hash = {}
+            # completion/etc data
+            index_hash[:classes] = {}
+            index_hash[:objects] = {}
+  
+            # schema data
+            index_hash[:packages_schema] = {}
+            index_hash[:packages_schema][:packages] = []
+            index_hash[:packages_schema][:gem_packages] = []
+  
+            facade = Ree.container.packages_facade
+  
+            facade.packages_store.packages.each do |package|
+              if package.gem?
+                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),
+                    links: _1.links.sort_by(&:object_name).map { |link|
+                      {
+                        Ree::ObjectSchema::Links::TARGET => link.object_name,
+                        Ree::ObjectSchema::Links::PACKAGE_NAME => link.package_name,
+                        Ree::ObjectSchema::Links::AS => link.as,
+                        Ree::ObjectSchema::Links::IMPORTS => link.constants
+                      }
                     }
                   }
                 }
-              }
-
-              index_hash[:packages_schema][:gem_packages] << gem_package_hsh
-
-              next
+  
+                index_hash[:packages_schema][:gem_packages] << gem_package_hsh
+  
+                next
+              end
+  
+              next if package.dir.nil?
+  
+              facade.load_entire_package(package.name)
+  
+              package_hsh = index_package_entry(package)
+  
+              index_hash[:packages_schema][:packages] << package_hsh
+  
+              index_hash = index_public_methods_for_package_classes(package, index_hash)
             end
-
-            next if package.dir.nil?
-
-            facade.load_entire_package(package.name)
-
-            package_hsh = Ree::CLI::IndexPackage.send(:index_package_entry, package)
-
-            index_hash[:packages_schema][:packages] << package_hsh
-
-            index_hash = index_public_methods_for_package_classes(package, index_hash)
-          end
-
-          if facade.get_package(:ree_errors, false)
-            index_hash = index_exceptions(facade.get_package(:ree_errors), index_hash)
-          end
-
-          JSON.pretty_generate(index_hash)
-        end
-
-        private
-
-        def index_public_methods_for_package_classes(package, index_hash)
-          package.objects.each do |obj|
-            klass = obj.klass
-            klass_name = demodulize(klass.to_s)
-            obj_name = obj.name.to_s
-            rpath = obj.rpath
-
-            if obj.tags.include?("enum")
-              hsh = index_class(klass, rpath, package.name)
-              index_hash[:classes][klass_name] ||= []
-              index_hash[:classes][klass_name] << hsh
-              index_hash[:objects][obj_name] ||= []
-              index_hash[:objects][obj_name] << hsh
-            elsif obj.tags.include?("dao")
-              hsh = index_dao(klass, rpath, package.name)
-              index_hash[:objects][obj_name] ||= []
-              index_hash[:objects][obj_name] << hsh
-            elsif obj.tags.include?("object")
-              hsh = index_class(klass, rpath, package.name)
-              index_hash[:objects][obj_name] ||= []
-              index_hash[:objects][obj_name] << hsh
+  
+            if facade.get_package(:ree_errors, false)
+              index_hash = index_exceptions(facade.get_package(:ree_errors), index_hash)
             end
+  
+            JSON.pretty_generate(index_hash)
           end
-
-          recursively_index_module(package.module, index_hash, package, {})
-
-          index_hash
-        end
-
-        def recursively_index_module(mod, index_hsh, package, mod_index)
-          return if !mod.is_a?(Module)
-          return if mod_index[mod]
-
-          mod_index[mod] = true
-
-          mod.constants.each do |const_name|
-            const = mod.const_get(const_name)
-
-            recursively_index_module(const, index_hsh, package, mod_index)
-
-            next if !const.is_a?(Class)
-            next if package.objects.any? { |o| o.klass == const }
-            next if index_hsh[:classes].has_key?(demodulize(const.name))
-
-            const_abs_path = mod.const_source_location(const.name)&.first
-            next if !const_abs_path
-
-            rpath = Pathname.new(const_abs_path).relative_path_from(Ree.root_dir).to_s
-            hsh = index_class(const, rpath, package.name)
-            class_name = demodulize(const.name)
-
-            index_hsh[:classes][class_name] ||= []
-            index_hsh[:classes][class_name] << hsh
-          end
-        end
-
-        def index_class(klass, rpath, package_name)
-          all_methods = klass.public_instance_methods(false)
-          orig_methods = all_methods.grep(/original/)
-
-          methods = (all_methods - orig_methods) # remove aliases defined by contracts
-            .map { |m|
-              orig_method_name = orig_methods.find { |om| om.match(/original_#{Regexp.escape(m.name)}_[0-9a-fA-F]+/) }
-              orig_method = orig_method_name ? klass.public_instance_method(orig_method_name) : nil
-
-              {
-                name: m,
-                parameters: orig_method&.parameters&.map { |param| { name: param.last, required: param.first } },
-                location: orig_method&.source_location&.last,
-              }
-            }
-
-          {
-            path: rpath,
-            package: package_name,
-            methods: methods
-          }
-        end
-
-        def index_dao(klass, rpath, package_name)
-          filters = (klass.instance_variable_get(:@filters) || []).map do
-            {
-              name: _1.name,
-              parameters: _1.proc.parameters.map { |param|
-                {name: param.last, required: param.first}
-              },
-              location: _1.proc&.source_location&.last
-            }
-          end
-
-          {
-            path: rpath,
-            package: package_name,
-            methods: filters
-          }
-        end
-
-        def index_exceptions(errors_package, index_hash)
-          errors_package.objects.each do |obj|
-            const_name = demodulize(obj.class_name)
-            file_name = File.join(
-              Ree::PathHelper.abs_package_module_dir(errors_package),
-              obj.name.to_s + ".rb"
-            )
-
-            hsh = {
-              path: file_name,
-              package: errors_package.name,
-              methods: []
-            }
-
-            index_hash[:classes][const_name] ||= []
-            index_hash[:classes][const_name] << hsh
-          end
-
-          index_hash
-        end
-
-        def demodulize(str)
-          str.split("::").last
         end
       end
     end

data/lib/ree/cli/indexing.rb

@@ -0,0 +1,265 @@
+module Ree
+  module CLI
+    module Indexing
+      autoload :IndexProject, 'ree/cli/indexing/index_project'
+      autoload :IndexFile, 'ree/cli/indexing/index_file'
+      autoload :IndexPackage, 'ree/cli/indexing/index_package'
+
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+      module ClassMethods
+        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),
+              links: _1.links.sort_by(&:object_name).map { |link|
+                {
+                  Ree::ObjectSchema::Links::TARGET => link.object_name,
+                  Ree::ObjectSchema::Links::PACKAGE_NAME => link.package_name,
+                  Ree::ObjectSchema::Links::AS => link.as,
+                  Ree::ObjectSchema::Links::IMPORTS => link.constants
+                }
+              }
+            }
+          }
+
+          package_hsh
+        end
+
+        def map_fn_methods(object)
+          if !object.fn?
+            return []
+          end
+  
+          klass = object.klass
+
+          object_is_action = object.tags.include?("action")
+          action_caster = object.klass.const_get(:ActionCaster) if object.klass.const_defined?(:ActionCaster)
+      
+          method_name = object_is_action ? :__original_call : :call
+          method_decorator = Ree::Contracts.get_method_decorator(
+            klass, method_name, scope: :instance
+          )
+      
+          begin
+            if method_decorator.nil?
+              parameters = klass.instance_method(:call).parameters
+      
+              args = parameters.inject({}) do |res, param|
+                res[param.last] = Ree::Contracts::CalledArgsValidator::Arg.new(
+                  param.last, param.first, nil, nil
+                )
+      
+                res
+              end
+            else
+              parameters = method_decorator.args.params
+              args = method_decorator.args.get_args
+            end
+          rescue NameError
+            raise Ree::Error.new("method call is not defined for #{klass}")
+          end
+
+          
+          arg_list = parameters.map do |param|
+            arg = args[param.last]
+            validator = arg.validator
+            arg_type = arg.type
+
+            type = if object_is_action && action_caster && arg.name == :attrs
+              map_mapper_fields(action_caster.fields).to_s.gsub(/\\*\"/, "").gsub(/\=\>/, ' => ')
+            else 
+              if validator
+                validator.to_s
+              else
+                arg_type == :block ? "Block" : "Any"
+              end
+            end
+      
+            {
+              Ree::ObjectSchema::Methods::Args::ARG => arg.name,
+              Ree::ObjectSchema::Methods::Args::ARG_TYPE => arg.type,
+              Ree::ObjectSchema::Methods::Args::TYPE => type
+            }
+          end
+      
+          [
+            {
+              Ree::ObjectSchema::Methods::DOC => method_decorator&.doc || "",
+              Ree::ObjectSchema::Methods::THROWS => method_decorator&.errors&.map { _1.name } || [],
+              Ree::ObjectSchema::Methods::RETURN => method_decorator&.contract_definition&.return_contract || "Any",
+              Ree::ObjectSchema::Methods::ARGS => arg_list
+            }
+          ]
+        end
+
+        def index_public_methods_for_package_classes(package, index_hash)
+          package.objects.each do |obj|
+            klass = obj.klass
+            klass_name = demodulize(klass.to_s)
+            obj_name = obj.name.to_s
+            rpath = obj.rpath
+
+            if obj.tags.include?("enum")
+              hsh = index_class(klass, rpath, package.name)
+              index_hash[:classes][klass_name] ||= []
+              index_hash[:classes][klass_name] << hsh
+              index_hash[:objects][obj_name] ||= []
+              index_hash[:objects][obj_name] << hsh
+            elsif obj.tags.include?("dao")
+              hsh = index_dao(klass, rpath, package.name)
+              index_hash[:objects][obj_name] ||= []
+              index_hash[:objects][obj_name] << hsh
+            elsif obj.tags.include?("object")
+              hsh = index_class(klass, rpath, package.name)
+              index_hash[:objects][obj_name] ||= []
+              index_hash[:objects][obj_name] << hsh
+            end
+          end
+
+          recursively_index_module(package.module, index_hash, package, {})
+
+          index_hash
+        end
+
+        private
+
+        def recursively_index_module(mod, index_hsh, package, mod_index)
+            return if !mod.is_a?(Module)
+            return if mod_index[mod]
+  
+            mod_index[mod] = true
+  
+            mod.constants.each do |const_name|
+              const = mod.const_get(const_name)
+  
+              recursively_index_module(const, index_hsh, package, mod_index)
+  
+              next if !const.is_a?(Class)
+              next if package.objects.any? { |o| o.klass == const }
+              next if index_hsh[:classes].has_key?(demodulize(const.name))
+  
+              const_abs_path = mod.const_source_location(const.name)&.first
+              next if !const_abs_path
+  
+              rpath = Pathname.new(const_abs_path).relative_path_from(Ree.root_dir).to_s
+              hsh = index_class(const, rpath, package.name)
+              class_name = demodulize(const.name)
+  
+              index_hsh[:classes][class_name] ||= []
+              index_hsh[:classes][class_name] << hsh
+            end
+          end
+  
+          def index_class(klass, rpath, package_name)
+            all_methods = klass.public_instance_methods(false)
+            orig_methods = all_methods.grep(/original/)
+  
+            methods = (all_methods - orig_methods) # remove aliases defined by contracts
+              .map { |m|
+                orig_method_name = orig_methods.find { |om| om.match(/original_#{Regexp.escape(m.name)}_[0-9a-fA-F]+/) }
+                orig_method = orig_method_name ? klass.public_instance_method(orig_method_name) : nil
+  
+                {
+                  name: m,
+                  parameters: orig_method&.parameters&.map { |param| { name: param.last, required: param.first } },
+                  location: orig_method&.source_location&.last,
+                }
+              }
+  
+            {
+              path: rpath,
+              package: package_name,
+              methods: methods
+            }
+          end
+  
+          def index_dao(klass, rpath, package_name)
+            filters = (klass.instance_variable_get(:@filters) || []).map do
+              {
+                name: _1.name,
+                parameters: _1.proc.parameters.map { |param|
+                  {name: param.last, required: param.first}
+                },
+                location: _1.proc&.source_location&.last
+              }
+            end
+  
+            {
+              path: rpath,
+              package: package_name,
+              methods: filters
+            }
+          end
+  
+          def index_exceptions(errors_package, index_hash)
+            errors_package.objects.each do |obj|
+              const_name = demodulize(obj.class_name)
+              file_name = File.join(
+                Ree::PathHelper.abs_package_module_dir(errors_package),
+                obj.name.to_s + ".rb"
+              )
+  
+              hsh = {
+                path: file_name,
+                package: errors_package.name,
+                methods: []
+              }
+  
+              index_hash[:classes][const_name] ||= []
+              index_hash[:classes][const_name] << hsh
+            end
+  
+            index_hash
+          end
+
+        def map_mapper_fields(fields, acc = {})
+          fields.keys.each do |key|
+            acc_key = fields[key].optional ? "#{key}?".to_sym : key
+            acc[acc_key] = map_field(fields[key], {})
+          end
+
+          acc
+        end
+
+        def map_field(field, acc = {})
+          if field.type.fields != {}
+            map_mapper_fields(field.type.fields, acc)
+          else
+            type_klass = field.type.type.class
+            type = demodulize(type_klass)
+
+            case
+            when type == "Array"
+              subject_type = field.type.type.subject.type
+              if subject_type.fields != {}
+                "ArrayOf[#{map_mapper_fields(field.type.type.subject.type.fields)}]"
+              else
+                "ArrayOf[#{demodulize(field.type.type.subject.type.type.class)}]"
+              end
+            when %w(Any Bool DateTime Date Float Integer String Time).include?(type)
+              field.null ? "Nilor[#{type}]" : type
+            else
+              field_type = field.type.type
+              field_type.instance_variables.length > 0 ? field_type.instance_variable_get(field_type.instance_variables.first)&.to_s : type
+            end
+          end
+        end
+
+        def demodulize(klass)
+          klass.to_s.split("::").last
+        end
+      end
+    end
+  end
+end

data/lib/ree/cli.rb

@@ -9,9 +9,7 @@ module Ree
     autoload :DeleteObjectSchema, 'ree/cli/delete_object_schema'
     autoload :GeneratePackage, 'ree/cli/generate_package'
     autoload :GenerateTemplate, 'ree/cli/generate_template'
-    autoload :IndexProject, 'ree/cli/indexing/index_project'
-    autoload :IndexFile, 'ree/cli/indexing/index_file'
-    autoload :IndexPackage, 'ree/cli/indexing/index_package'
+    autoload :Indexing, 'ree/cli/indexing'
     autoload :SpecRunner, 'ree/cli/spec_runner'
   end
 end

data/lib/ree/dsl/import_dsl.rb

@@ -4,12 +4,12 @@ class Ree::ImportDsl
   def execute(klass, proc)
     self.class.instance_exec(&proc)
   rescue Ree::ImportDsl::UnlinkConstError => e
-    const_removed = remove_const(klass, e.const)
+    const_removed = remove_or_assign_const(klass, e.const)
 
     retry if const_removed
   rescue NoMethodError => e
     if e.name == :&
-      const_removed = remove_const(klass, e.receiver)
+      const_removed = remove_or_assign_const(klass, e.receiver)
 
       if const_removed
         retry
@@ -29,7 +29,7 @@ class Ree::ImportDsl
 
   class UnlinkConstError < StandardError
     attr_reader :const
-    
+
     def initialize(const)
       @const = const
     end
@@ -82,25 +82,63 @@ class Ree::ImportDsl
 
   private
 
-  def remove_const(klass, constant)
-    const_removed = false
+  def remove_or_assign_const(klass, constant)
+    retry_after = false
 
     klass.constants.each do |const_sym|
       const = klass.const_get(const_sym)
+      next if const.is_a?(ClassConstant)
 
       if constant.is_a?(Class) || constant.is_a?(Module)
         if (const.is_a?(Class) || const.is_a?(Module)) && const.name == constant.name
           klass.send(:remove_const, const_sym)
-          const_removed = true
+          retry_after = true
           break
         end
       elsif const == constant
         klass.send(:remove_const, const_sym)
-        const_removed = true
+        retry_after = true
         break
       end
     end
 
-    const_removed
+    return true if retry_after
+
+    const_name = if constant.is_a?(String)
+      constant.to_sym
+    elsif constant.is_a?(Class) || constant.is_a?(Module)
+      constant.name
+    else
+      raise ArgumentError.new("unknown constant: #{constant.inspect}")
+    end
+
+    if parent_constant?(klass, const_name)
+      klass.const_set(const_name, ClassConstant.new(const_name.to_s))
+      retry_after = true
+    end
+
+    retry_after
+  end
+
+  private
+
+  def parent_constant?(klass, const_name)
+    modules = klass.to_s.split("::")[0..-2]
+
+    result = modules.each_with_index.any? do |mod, index|
+      mod = Object.const_get(modules[0..index].join("::"))
+      mod.constants.include?(const_name)
+    end
+
+    result || acnchestor_constant?(klass, const_name)
+  end
+
+  def acnchestor_constant?(klass, const_name)
+    return false if klass.ancestors.include?(klass) && klass.ancestors.size == 1
+
+    klass.ancestors.any? do |anchestor|
+      next if anchestor == klass
+      anchestor.constants.include?(const_name) || acnchestor_constant?(anchestor, const_name)
+    end
   end
 end

data/lib/ree/link_dsl.rb

@@ -167,7 +167,7 @@ module Ree::LinkDSL
 
       if dep_package.nil?
         raise Ree::Error.new(
-          "Package :#{package_name} is not added as dependency for :#{current_package_name} package\npackage path: #{File.join(Ree.root_dir, current_package.entry_rpath)}\nclass:#{self.name}",
+          "Package :#{package_name} is not added as dependency for :#{current_package_name} package\npackage path: #{File.join(Ree.root_dir, current_package.entry_rpath || "")}\nclass:#{self.name}",
           :invalid_dsl_usage
         )
       end

data/lib/ree/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ree
 version: !ruby/object:Gem::Version
-  version: 1.0.27
+  version: 1.0.29
 platform: ruby
 authors:
 - Ruslan Gatiyatov
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2023-03-10 00:00:00.000000000 Z
+date: 2023-08-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: commander
@@ -69,6 +69,7 @@ files:
 - 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
 - lib/ree/cli/indexing/index_file.rb
 - lib/ree/cli/indexing/index_package.rb
 - lib/ree/cli/indexing/index_project.rb