ree 1.0.0

data/lib/ree/core/object.rb

@@ -0,0 +1,132 @@
+# frozen_string_literal  = true
+
+class Ree::Object
+  attr_reader :name, :rpath, :schema_rpath, :package_name, :klass,
+              :package_name, :factory, :after_init,
+              :class_name, :links, :mount_as, :freeze,
+              :errors, :linked_const_list, :compiled_frozen,
+              :singleton
+  
+  # @param [Symbol] name Object name
+  # @param [String] schema_rpath Object schema path relative to project root dir
+  # @param [String] rpath Object source file path relative to project root dir
+  def initialize(name, schema_rpath, rpath)
+    @name = name
+    @schema_rpath = schema_rpath
+    @rpath = rpath
+    @links = []
+    @errors = []
+    @loaded = false
+    @freeze = true
+    @compiled = false
+    @singleton = false
+    @compiled_frozen = @freeze
+    @linked_const_list = []
+  end
+
+  def reset
+    @compiled = false
+    @singleton = false
+    @loaded = false
+    @factory = nil
+    @after_init = nil
+    @freeze = true
+    @links = []
+    @errors = []
+    @linked_const_list = []
+  end
+
+  # @param [ArrayOf[String]] list List of imported constants, modules and classes
+  # @return [ArrayOf[String]] All imported constants
+  def add_const_list(list)
+    @linked_const_list += list
+    @linked_const_list.uniq
+  end
+
+  # @param [Bool]
+  def set_as_compiled(frozen)
+    @compiled = true
+    @compiled_frozen = frozen
+  end
+
+  def set_as_not_compiled
+    @compiled = false
+    @compiled_frozen = @freeze
+  end
+
+  def compiled?
+    @compiled
+  end
+
+  def factory?
+    !!@factory
+  end
+
+  def after_init?
+    !!@after_init
+  end
+
+  def set_loaded
+    @loaded = true
+  end
+
+  def loaded?
+    @loaded
+  end
+
+  def freeze?
+    @freeze
+  end
+
+  # @param [Symbol] val Object mount as type (:fn or :bean)
+  def set_mount_as(val)
+    @mount_as = val; self
+  end
+
+  # @param [Bool]
+  def set_freeze(val)
+    @freeze = val; self
+  end
+
+  def set_as_singleton
+    @singleton = true; self
+  end
+
+  def object?
+    @mount_as == :object
+  end
+
+  def fn?
+    @mount_as == :fn
+  end
+
+  # @param [String] rpath Object source file path relative to project root dir
+  def set_rpath(val)
+    @rpath = val; self
+  end
+
+  # @param [String] schema_rpath Object schema path relative to project root dir
+  def set_schema_rpath(val)
+    @schema_rpath = val; self
+  end
+
+  # @param [Class] Object class
+  def set_class(klass)
+    @klass = klass; @class_name = klass.to_s; self
+  end
+
+  # @param [Symbol] Package name
+  def set_package(val)
+    @package_name = val; self
+  end
+
+  # @param [Symbol] Factory method name
+  def set_factory(val)
+    @factory = val; self
+  end
+
+  # @param [Symbol] After init method name
+  def set_after_init(val)
+    @after_init = val; self
+  end
+end

data/lib/ree/core/object_error.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal  = true
+
+class Ree::ObjectError
+  attr_reader :class_name
+  
+  def initialize(class_name)
+    @class_name = class_name
+  end
+end

data/lib/ree/core/object_link.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal  = true
+
+class Ree::ObjectLink
+  attr_reader :object_name, :package_name, :as, :constants
+  
+  # @param [Symbol] object_name Linked object name
+  # @param [Symbol] package_name Linked object package
+  # @param [Symbol] as Linked object alias name
+  def initialize(object_name, package_name, as)
+    @object_name = object_name
+    @package_name = package_name
+    @as = as
+    @constants = []
+  end
+
+  # @param [ArrayOf[String]]
+  # @return [ArrayOf[String]]
+  def set_constants(const_list)
+    @constants = const_list
+  end
+end

data/lib/ree/core/object_schema.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal  = true
+
+module Ree::ObjectSchema
+  SCHEMA_TYPE = 'schema_type'
+  REE_VERSION = 'ree_version'
+  NAME = 'name'
+  OBJECT = 'object'
+  LINKS = 'links'
+  CONTEXT = 'context'
+  PATH = 'path'
+  METHODS = 'methods'
+  CLASS = 'class'
+  PACKAGE_NAME = 'package_name'
+  MOUNT_AS = 'mount_as'
+  FACTORY = 'factory'
+  ERRORS = 'errors'
+
+  module Links
+    NAME = 'name'
+    PACKAGE_NAME = 'package_name'
+    TARGET = 'target'
+    AS = 'as'
+    IMPORTS = 'imports'
+
+    module Imports
+      CONST = 'const'
+      AS = 'as'
+    end
+  end
+
+  module Methods
+    ARGS = 'args'
+    METHOD = 'method'
+    RETURN = 'return'
+    THROWS = 'throws'
+    DOC = 'doc'
+
+    module Args
+      ARG = 'arg'
+      TYPE = 'type'
+    end
+  end
+
+  module Errors
+    CODE = 'code'
+  end
+end

data/lib/ree/core/object_schema_builder.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal  = true
+
+class Ree::ObjectSchemaBuilder
+  Schema = Ree::ObjectSchema
+
+  # @param [Ree::Object] object
+  # @param [String] - path to object.schema.json file (ex. /project/bc/accounts/schemas/accounts/accounts_cfg.schema.json)
+  # @return [String]
+  def call(object, schema_path)
+    Ree.logger.debug("generating object schema for '#{object.name}' package")
+
+    if !File.exists?(schema_path)
+      only_dir_path = schema_path.split('/')[0..-2]
+      FileUtils.mkdir_p(File.join(only_dir_path))
+    end
+
+    if !object.loaded?
+      raise Ree::Error.new("object `#{object.name}` from package `#{object.package_name}` is not loaded", :invalid_schema)
+    end
+
+    data = {
+      Schema::SCHEMA_TYPE => Schema::OBJECT,
+      Schema::REE_VERSION => Ree::VERSION,
+      Schema::NAME => object.name,
+      Schema::PATH => object.rpath,
+      Schema::MOUNT_AS => object.mount_as,
+      Schema::CLASS => object.klass.name,
+      Schema::FACTORY => object.factory,
+      Schema::METHODS => map_object_methods(object),
+      Schema::LINKS => object.links.sort_by(&:object_name).map { |link|
+        {
+          Schema::Links::TARGET => link.object_name,
+          Schema::Links::PACKAGE_NAME => link.package_name,
+          Schema::Links::AS => link.as,
+          Schema::Links::IMPORTS => link.constants
+        }
+      }
+    }
+
+    json = JSON.pretty_generate(data)
+
+    File.write(schema_path, json, mode: 'w')
+    json
+  end
+
+  private
+
+  Arg = Ree::Contracts::CalledArgsValidator::Arg
+
+  def map_object_methods(object)
+    if !object.fn?
+      return []
+    end
+
+    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] = 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
+
+      {
+        Schema::Methods::Args::ARG => arg.name,
+        Schema::Methods::Args::TYPE => type
+      }
+    end
+
+    [
+      {
+        Schema::Methods::DOC => method_decorator&.doc || "",
+        Schema::Methods::THROWS => method_decorator&.errors&.map { _1.name } || [],
+        Schema::Methods::RETURN => method_decorator&.contract_definition&.return_contract || "Any",
+        Schema::Methods::ARGS => arg_list
+      }
+    ]
+  end
+end

data/lib/ree/core/package.rb

@@ -0,0 +1,177 @@
+# frozen_string_literal  = true
+
+require 'pathname'
+
+class Ree::Package
+  attr_reader :ree_version, :name, :schema_rpath, :entry_rpath,
+              :module, :tags, :preload, :default_links, :gem_name
+
+  def initialize(ree_version, name, entry_rpath, schema_rpath, gem_name = nil)
+    @ree_version = ree_version
+    @name = name
+    @schema_rpath = schema_rpath
+    @entry_rpath = entry_rpath
+    @objects_store = {}
+    @deps_store = {}
+    @env_vars_store = {}
+    @entry_loaded = false
+    @schema_loaded = false
+    @loaded = false
+    @tags = []
+    @preload = {}
+    @preloaded = false
+    @gem_name = gem_name
+  end
+
+  def set_default_links(&block)
+    @default_links = block; self
+  end
+
+  # @param [Bool] val
+  def set_preloaded(val)
+    @preloaded = val; self
+  end
+
+  def preloaded?
+    @preloaded
+  end
+
+  # @param [String] val
+  def set_ree_version(val)
+    @ree_version = val; self
+  end
+
+  # @param [String] val
+  def set_entry_rpath(val)
+    @entry_rpath = val; self
+  end
+
+  # @param [ArrayOf[String]] list
+  def set_tags(list)
+    @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
+    @loaded = false
+    @deps_store = {}
+    @env_vars_store = {}
+    @preload = {}
+  end
+
+  def set_preload(val)
+    @preload = val; self
+  end
+
+  def loaded?
+    @loaded
+  end
+
+  def set_loaded
+    @loaded = true
+  end
+
+  def set_entry_loaded
+    @entry_loaded = true
+  end
+
+  def set_schema_loaded
+    @schema_loaded = true
+  end
+
+  def entry_loaded?
+    @entry_loaded
+  end
+
+  def schema_loaded?
+    @schema_loaded
+  end
+
+  def dir
+    @dir ||= @schema_rpath ? Pathname.new(@schema_rpath).dirname.to_s : nil
+  end
+
+  def gem?
+    !!@gem_name
+  end
+
+  # @param [Module] mod
+  def set_module(mod)
+    @module = mod; self
+  end
+
+  # @list [ArrayOf[Ree::PackageDepsSchema]]
+  def set_deps(list)
+    list.each do |item|
+      @deps_store[item.name] = item
+    end
+  end
+
+  def deps
+    @deps_store.values
+  end
+
+  # @param [Ree::PackageDep] dep
+  def set_dep(dep)
+    old = @deps_store[dep.name]
+    @deps_store[dep.name] = dep
+    old
+  end
+
+  # @param [Symbol] name
+  def get_dep(name)
+    @deps_store[name]
+  end
+
+  # @param [ArrayOf[Ree::PackageEnvVar]] list
+  def set_env_vars(list)
+    list.each do |item|
+      @env_vars_store[item.name] = item
+    end
+  end
+
+  def env_vars
+    @env_vars_store.values
+  end
+
+  # @param [Ree::PackageEnvVar] var
+  def set_env_var(var)
+    old = @env_vars_store[var.name]
+    @env_vars_store[var.name] = var
+    old
+  end
+
+  # @param [String] name
+  def get_env_var(name)
+    @env_vars_store[name]
+  end
+
+  # @param [Ree::Object] object
+  # @return [Nilor[Ree::Object]] Previous object version
+  def set_object(object)
+    if object.package_name != @name
+      raise Ree::Error.new("package should only include objects from the same package")
+    end
+
+    existing = @objects_store[object.name]
+    return existing if existing
+
+    @objects_store[object.name] = object
+  end
+
+  # @param [Symbol] name
+  # @return [Nilor[Ree::Object]]
+  def get_object(name)
+    @objects_store[name]
+  end
+
+  def objects
+    @objects_store.values.flatten
+  end
+end

data/lib/ree/core/package_dep.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal  = true
+
+class Ree::PackageDep
+  attr_reader :name
+  
+  def initialize(name)
+    @name = name
+  end
+end

data/lib/ree/core/package_env_var.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal  = true
+
+class Ree::PackageEnvVar
+  attr_reader :name, :doc
+
+  # @param [String] name Env var name
+  # @param [Nilor[String]] Env var description
+  def initialize(name, doc)
+    @name = name
+    @doc = doc
+  end
+end

data/lib/ree/core/package_loader.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal  = true
+
+require 'set'
+require 'pathname'
+
+class Ree::PackageLoader
+  def initialize(packages_store)
+    @packages_store = packages_store
+    @loaded_paths = {}
+    @loaded_packages = {}
+  end
+
+  def reset
+    @loaded_paths = {}
+  end
+
+  # @param [Symbol] name Package name
+  def call(name)
+    return @loaded_packages[name] if @loaded_packages.has_key?(name)
+
+    Ree.logger.debug("full_package_load(:#{name})")
+    recursively_load_package(name, Hash.new(false))
+    @loaded_packages[name]
+  end
+
+  def load_file(path, package_name)
+    @loaded_paths[package_name] ||= {}
+    return if @loaded_paths[package_name][path]
+    @loaded_paths[package_name][path] = true
+
+    Ree.logger.debug("load_file(:#{package_name}, '#{path}')")
+    Kernel.require(path)
+  end
+
+  private
+
+  def recursively_load_package(name, loaded_packages)
+    @loaded_packages[name] = true
+    package = @packages_store.get(name)
+
+    if package.dir.nil?
+      package.set_schema_loaded
+      return package
+    end
+
+    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
+      )
+    end
+
+    not_loaded = Set.new(
+      [name, package.deps.map(&:name)]
+        .uniq
+        .select { |pn| !loaded_packages[pn] }
+    )
+
+    if not_loaded.include?(name)
+      load_file(
+        Ree::PathHelper.abs_package_entry_path(package), name
+      )
+
+      Dir[File.join(Ree::PathHelper.abs_package_module_dir(package), '**/*.rb')].each do |path|
+        load_file(path, name)
+      end
+
+      loaded_packages[name] = true
+    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
+
+    package.deps.each do |dep|
+      if !loaded_packages[dep.name]
+        recursively_load_package(dep.name, loaded_packages)
+      end
+    end
+
+    package.set_schema_loaded
+
+    @loaded_packages[name] = package
+  end
+end

data/lib/ree/core/package_schema.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal  = true
+
+module Ree::PackageSchema
+  SCHEMA_TYPE = 'schema_type'
+  REE_VERSION = 'ree_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'
+  end
+
+  module DependsOn
+    NAME = 'name'
+  end
+
+  module EnvVars
+    NAME = 'name'
+    DOC = 'doc'
+  end
+end

data/lib/ree/core/package_schema_builder.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal  = true
+
+require 'pathname'
+require 'json'
+
+class Ree::PackageSchemaBuilder
+  Schema = Ree::PackageSchema
+
+  # @param [Ree::Package] package
+  # @param [String] - abs_path Absolute path to Package.schema.json file (ex. /project/bc/accounts/Package.schema.json)
+  # @return [nil]
+  def call(package, abs_path)
+    Ree.logger.debug("generating package schema for '#{package.name}' package")
+
+    if !File.exists?(abs_path)
+      raise Ree::Error.new("File does not exist: #{abs_path}", :invalid_path)
+    end
+
+    if !package.loaded?
+      raise Ree::Error.new("package schema should be loaded", :invalid_schema)
+    end
+    
+    data = {
+      Schema::SCHEMA_TYPE => Schema::PACKAGE,
+      Schema::REE_VERSION => Ree::VERSION,
+      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,
+        }
+      }
+    }
+
+    json = JSON.pretty_generate(data)
+
+    File.write(abs_path, json, mode: 'w')
+    nil
+  end
+end